597 lines
15 KiB
C++
597 lines
15 KiB
C++
///
|
|
/// \file channelRegalia.h
|
|
///
|
|
/// Classes are:
|
|
/// ChannelRegalia
|
|
/// ChannelRequestMetaData
|
|
/// ChannelRequestMetaDataClient
|
|
/// ChannelRequestMetaDataRepository
|
|
/// ChannelRequestStatus
|
|
///
|
|
/// \author Jan Chrin, PSI
|
|
/// \date Release: February 2015
|
|
/// \version CAFE 1.0.0
|
|
///
|
|
|
|
#ifndef CHANNELINFO_H
|
|
#define CHANNELINFO_H
|
|
|
|
#include <cstring>
|
|
#include <statusCodes.h>
|
|
#include <defines.h>
|
|
#include <cafeEnum.h>
|
|
|
|
//required for channelDataStore
|
|
#include <PVDataHolder.h>
|
|
#include <PVCtrlHolder.h>
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Struct defining channel properties and connection status for use in Conduit container
|
|
*
|
|
*/
|
|
class ChannelRegalia
|
|
{
|
|
private:
|
|
CAFEStatus cafeStatus;
|
|
public:
|
|
friend struct change_accessRightsHandlerArgs;
|
|
friend struct change_accessRead;
|
|
friend struct change_accessWrite;
|
|
friend struct change_channelID;
|
|
friend struct change_connectionHandlerArgs;
|
|
friend struct change_eventHandlerArgs;
|
|
//friend struct change_channelRegalia;
|
|
friend class Connect;
|
|
friend class HandleHelper;
|
|
friend class Conduit;
|
|
friend class ConduitGroup;
|
|
protected:
|
|
chid channelID; //
|
|
bool connectFlag;
|
|
const char * hostName;
|
|
unsigned int nelem; //native
|
|
chtype dataType; //native
|
|
unsigned short accessRead; //0 or 1
|
|
unsigned short accessWrite; //0 or 1
|
|
dbr_class_name_t className; //dbr_string_t
|
|
//connectionState as given by connection_handler args: CA_OP_CONN_UP or CA_OP_CONN_DOWN
|
|
int connectionState; //as given by CA_OP_
|
|
int cafeConnectionState; //as given by cafe_cs_state in statusCodes
|
|
|
|
//void setChannelID (chid id) {channelID=id;};
|
|
void setConnectFlag (bool c)
|
|
{
|
|
connectFlag=c;
|
|
};
|
|
void setHostName (const char * h)
|
|
{
|
|
hostName=h;
|
|
};
|
|
void setDataType (chtype d)
|
|
{
|
|
dataType=d;
|
|
};
|
|
void setAccessRead (unsigned short r)
|
|
{
|
|
accessRead=r;
|
|
};
|
|
void setAccessWrite(unsigned short w)
|
|
{
|
|
accessWrite=w;
|
|
};
|
|
void setReadAccess (unsigned short r)
|
|
{
|
|
accessRead=r;
|
|
};
|
|
void setWriteAccess(unsigned short w)
|
|
{
|
|
accessWrite=w;
|
|
};
|
|
void setNelem (unsigned int n)
|
|
{
|
|
nelem=n;
|
|
};
|
|
void setConnectionState (int cs)
|
|
{
|
|
connectionState=cs;
|
|
};
|
|
void setCafeConnectionState (int ccs)
|
|
{
|
|
cafeConnectionState=ccs;
|
|
};
|
|
|
|
public:
|
|
chid getChannelID() const
|
|
{
|
|
return channelID;
|
|
};
|
|
bool getConnectFlag()const
|
|
{
|
|
return connectFlag;
|
|
};
|
|
const char * getHostName() const
|
|
{
|
|
return hostName;
|
|
};
|
|
std::string getHostNameAsString()
|
|
{
|
|
std::string h= hostName;
|
|
return h;
|
|
};
|
|
chtype getDataType() const
|
|
{
|
|
return dataType;
|
|
};
|
|
const char * getClassName() const
|
|
{
|
|
return className;
|
|
};
|
|
std::string getClassNameAsString()
|
|
{
|
|
std::string c=className;
|
|
return c;
|
|
};
|
|
unsigned short getAccessRead() const
|
|
{
|
|
return accessRead;
|
|
};
|
|
unsigned short getAccessWrite()const
|
|
{
|
|
return accessWrite;
|
|
};
|
|
unsigned short getReadAccess() const
|
|
{
|
|
return accessRead;
|
|
};
|
|
unsigned short getWriteAccess()const
|
|
{
|
|
return accessWrite;
|
|
};
|
|
unsigned int getNelem() const
|
|
{
|
|
return nelem;
|
|
};
|
|
int getConnectionState() const
|
|
{
|
|
return connectionState;
|
|
};
|
|
int getCafeConnectionState() const
|
|
{
|
|
return cafeConnectionState;
|
|
};
|
|
std::string getConnectionStateAsString()
|
|
{
|
|
if(connectionState==CA_OP_CONN_UP)
|
|
{
|
|
return "CA_OP_CONN_UP";
|
|
}
|
|
else if(connectionState==CA_OP_CONN_DOWN)
|
|
{
|
|
return "CA_OP_CONN_DOWN";
|
|
}
|
|
else
|
|
{
|
|
return "CA_OP_CONN is UNKNOWN: THIS SHOULD NEVER APPEAR!";
|
|
}
|
|
};
|
|
|
|
std::string getCafeConnectionStateAsString()
|
|
{
|
|
return cafeStatus.csc.message(cafeConnectionState);
|
|
};
|
|
|
|
ChannelRegalia():channelID((chid) NULL), connectFlag(false), nelem((unsigned int) 1),
|
|
dataType((chtype) CAFE_TYPENOTCONN),
|
|
accessRead((unsigned short) 0), accessWrite((unsigned short) 0),
|
|
connectionState((int) CA_OP_CONN_DOWN), cafeConnectionState((int) ICAFE_CS_NEVER_CONN)
|
|
{
|
|
strcpy(className, "");
|
|
hostName="";
|
|
};
|
|
|
|
~ChannelRegalia() {};
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Struct defining channel properties and connection status for use in displays
|
|
*
|
|
*/
|
|
class ChannelDataStore
|
|
{
|
|
public:
|
|
|
|
std::string description;
|
|
ChannelRegalia info;
|
|
PVDataHolder pvd;
|
|
PVCtrlHolder pvc;
|
|
|
|
ChannelDataStore()
|
|
{
|
|
|
|
|
|
};
|
|
|
|
~ChannelDataStore() {};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Stores strings for Enum datatypes
|
|
*
|
|
*/
|
|
class ChannelEnumStrings
|
|
{
|
|
public:
|
|
friend struct change_eventHandlerArgs;
|
|
private:
|
|
char options [MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];
|
|
short noOptions;
|
|
public:
|
|
ChannelEnumStrings():noOptions( (short) 0) {};
|
|
short getNoOptions() const
|
|
{
|
|
return noOptions;
|
|
};
|
|
std::vector<std::string> getOptions() const
|
|
{
|
|
std::vector<std::string> optionsV;
|
|
optionsV.reserve(noOptions);
|
|
for ( short i=0; i<noOptions; ++i)
|
|
{
|
|
optionsV.push_back(options[i]);
|
|
}
|
|
return optionsV;
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
* Stores device/attribute pairing
|
|
*
|
|
*/
|
|
class ChannelDeviceAttribute
|
|
{
|
|
private:
|
|
std::string pv;
|
|
std::string device;
|
|
std::string attribute;
|
|
std::string deliminator;
|
|
public:
|
|
ChannelDeviceAttribute() {};
|
|
~ChannelDeviceAttribute() {};
|
|
|
|
int init(std::string _pv, std::string _deliminator)
|
|
{
|
|
pv=_pv;
|
|
deliminator=_deliminator;
|
|
short posOfSeparator=pv.find_first_of(deliminator);
|
|
if (posOfSeparator<0)
|
|
{
|
|
device="";
|
|
attribute="";
|
|
return ECAFE_DEVICE_ATTRIB_NOT_FOUND;
|
|
}
|
|
else
|
|
{
|
|
device= pv.substr(0,posOfSeparator);
|
|
attribute=pv.substr(posOfSeparator+1,pv.size());
|
|
//Check for .VAL and remove
|
|
std::size_t found = attribute.find(".");
|
|
if (found != std::string::npos)
|
|
{
|
|
attribute=attribute.substr(0, found);
|
|
}
|
|
}
|
|
return ICAFE_NORMAL;
|
|
};
|
|
|
|
const char * getDeliminator() const
|
|
{
|
|
return deliminator.c_str();
|
|
};
|
|
const char * getDevice() const
|
|
{
|
|
return device.c_str();
|
|
};
|
|
const char * getAttribute() const
|
|
{
|
|
return attribute.c_str();
|
|
};
|
|
const char * getAttrib() const
|
|
{
|
|
return attribute.c_str();
|
|
};
|
|
std::string getDeliminatorAsString() const
|
|
{
|
|
return deliminator;
|
|
};
|
|
std::string getDeviceAsString() const
|
|
{
|
|
return device;
|
|
};
|
|
std::string getAttributeAsString() const
|
|
{
|
|
return attribute;
|
|
};
|
|
};
|
|
|
|
|
|
/**
|
|
* 0. Struct defining channel datatype/nelem executed by CAFE for use in Conduit container
|
|
*
|
|
*/
|
|
class ChannelRequestMetaData
|
|
{
|
|
public:
|
|
friend struct change_connectionHandlerArgs;
|
|
friend struct change_dataBufferSize_CTRL;
|
|
friend struct change_dataBufferSize_TIME;
|
|
friend struct change_dataBufferSize_PRIMITIVE;
|
|
friend struct change_dataBufferSize_STSACK;
|
|
friend struct change_eventHandlerArgs;
|
|
|
|
friend struct copy_channelRequestMetaDataToChannelRequestMetaDataRepository;
|
|
|
|
friend class Conduit;
|
|
friend class ConduitGroup;
|
|
|
|
protected:
|
|
chid channelID; //of requested item
|
|
unsigned int nelem; //depends on Policy
|
|
unsigned int nelemCache; //nelem To Retrieve From Cache
|
|
chtype dataType; //depends on Policy
|
|
chtype dbrDataType; //depends on Policy
|
|
CAFENUM::DBR_TYPE cafeDbrType;
|
|
void * usrArg; //from Conduit.usrArg
|
|
unsigned int byteSize; //data buffer (bytes) must be large enough to store data
|
|
unsigned int offset;
|
|
|
|
public:
|
|
void setNelem(unsigned int n)
|
|
{
|
|
nelem= n > 0 ? n : 1;
|
|
//nelemCache= nelem > nelemCache ? nelemCache : nelem;
|
|
}; // byteSize=dbr_size_n(dbrDataType,nelem); };
|
|
void setNelemCache(unsigned int n)
|
|
{
|
|
nelemCache= n > 0 ? n : 1;
|
|
}
|
|
void setUsrArg(void * u)
|
|
{
|
|
usrArg=u;
|
|
};
|
|
void setDataType(chtype d)
|
|
{
|
|
dataType=d;
|
|
};
|
|
void setDbrDataType(chtype dbr)
|
|
{
|
|
dbrDataType=dbr;
|
|
}; //byteSize=dbr_size_n(dbrDataType,nelem);};
|
|
void setCafeDbrType(CAFENUM::DBR_TYPE cd)
|
|
{
|
|
cafeDbrType=cd;
|
|
};
|
|
void setDbrTypesFromCafeDbrType(CAFENUM::DBR_TYPE cd)
|
|
{
|
|
cafeDbrType=cd;
|
|
switch(cafeDbrType)
|
|
{
|
|
case CAFENUM::DBR_TIME:
|
|
dbrDataType = dbf_type_to_DBR_TIME(dataType);
|
|
break;
|
|
case CAFENUM::DBR_STS:
|
|
dbrDataType = dbf_type_to_DBR_STS(dataType);
|
|
break;
|
|
case CAFENUM::DBR_PRIMITIVE:
|
|
dbrDataType = dbf_type_to_DBR(dataType);
|
|
break;
|
|
default:
|
|
//Print Warning Message?
|
|
dbrDataType = dbf_type_to_DBR_TIME(dataType);
|
|
cafeDbrType = CAFENUM::DBR_TIME;
|
|
break;
|
|
}
|
|
};
|
|
|
|
|
|
void setByteSize(unsigned int b)
|
|
{
|
|
byteSize=b;
|
|
};
|
|
|
|
unsigned int getNelem() const
|
|
{
|
|
return nelem;
|
|
};
|
|
unsigned int getNelemCache() const
|
|
{
|
|
return nelemCache;
|
|
};
|
|
void * getUsrArg() const
|
|
{
|
|
return usrArg;
|
|
};
|
|
chtype getDataType() const
|
|
{
|
|
return dataType;
|
|
};
|
|
chtype getDbrDataType() const
|
|
{
|
|
return dbrDataType;
|
|
};
|
|
CAFENUM::DBR_TYPE getCafeDbrType() const
|
|
{
|
|
return cafeDbrType;
|
|
};
|
|
|
|
unsigned int getByteSize() const
|
|
{
|
|
return byteSize;
|
|
};
|
|
|
|
void setOffset(unsigned int o)
|
|
{
|
|
offset=o;
|
|
};
|
|
unsigned int getOffset() const
|
|
{
|
|
return offset;
|
|
};
|
|
|
|
//Constructors
|
|
ChannelRequestMetaData():channelID((chid) NULL), nelem((unsigned int) 1), nelemCache((unsigned int) 1),
|
|
dataType((chtype) DBF_NO_ACCESS), dbrDataType((chtype) TYPENOTCONN), //
|
|
cafeDbrType( (CAFENUM::DBR_TYPE) NULL),
|
|
usrArg((void *) NULL), byteSize((unsigned int) 0), offset((unsigned int) 0)
|
|
{
|
|
|
|
}; //CAStatus((long) ECA_NORMAL){};
|
|
|
|
~ChannelRequestMetaData() {};
|
|
};
|
|
|
|
|
|
/**
|
|
* -1. Struct defining channel datatype/nelem requested by client for use in Conduit container
|
|
*
|
|
*/
|
|
class ChannelRequestMetaDataClient: public ChannelRequestMetaData
|
|
{
|
|
public:
|
|
|
|
//protected:
|
|
//unsigned int offset;
|
|
public:
|
|
//void setOffset(unsigned int o) {offset=o;};
|
|
//unsigned int getOffset() const {return offset;};
|
|
|
|
//Constructors
|
|
ChannelRequestMetaDataClient() {}; //:offset((unsigned int) 0){};
|
|
~ChannelRequestMetaDataClient() {};
|
|
};
|
|
|
|
|
|
/**
|
|
* Gives status of the Request message \n
|
|
* messageStatus = requestStatus if requestStatus != ECA_NORMAL else \n
|
|
* messageStatus = requestStatus or messageStatus=callbackStatus (if policy WITH_CALLBACK)
|
|
*
|
|
*/
|
|
class ChannelRequestStatus
|
|
{
|
|
|
|
private:
|
|
int preRequestStatus; // current status of channel
|
|
int requestStatus; // from get/put operation
|
|
int pendStatus; // from pend_io operation
|
|
int callbackStatus; // used by CAFE::waitForEvent() to record status of callback
|
|
int messageStatus; // overall status
|
|
CAFENUM::StatusMessageKind messageKind; // statusMessageKind indicating method status occuping overall messageStatus
|
|
|
|
bool hasCallbackInitiated;
|
|
bool hasCallbackTriggered;
|
|
CAFENUM::CallbackProgressKind callbackProgressKind;
|
|
|
|
public:
|
|
int getPreRequestStatus() const
|
|
{
|
|
return preRequestStatus;
|
|
};
|
|
int getRequestStatus() const
|
|
{
|
|
return requestStatus;
|
|
};
|
|
int getPendStatus() const
|
|
{
|
|
return pendStatus;
|
|
};
|
|
int getCallbackStatus() const
|
|
{
|
|
return callbackStatus;
|
|
};
|
|
int getMessageStatus() const
|
|
{
|
|
return messageStatus;
|
|
};
|
|
CAFENUM::StatusMessageKind getMessageKind() const
|
|
{
|
|
return messageKind;
|
|
};
|
|
CAFENUM::CallbackProgressKind getCallbackProgressKind() const
|
|
{
|
|
return callbackProgressKind;
|
|
};
|
|
|
|
void setPreRequestStatus (int s)
|
|
{
|
|
preRequestStatus=s;
|
|
messageStatus=s;
|
|
messageKind=(CAFENUM::StatusMessageKind) CAFENUM::PRE_REQUEST;
|
|
};
|
|
void setRequestStatus (int r)
|
|
{
|
|
requestStatus = r;
|
|
messageStatus=r;
|
|
messageKind=(CAFENUM::StatusMessageKind) CAFENUM::FROM_REQUEST;
|
|
};
|
|
void setPendStatus (int p)
|
|
{
|
|
pendStatus = p;
|
|
messageStatus=p;
|
|
messageKind=(CAFENUM::StatusMessageKind) CAFENUM::FROM_PEND;
|
|
};
|
|
void setCallbackStatus (int c)
|
|
{
|
|
callbackStatus= c;
|
|
messageStatus=c;
|
|
messageKind=(CAFENUM::StatusMessageKind) CAFENUM::FROM_CALLBACK;
|
|
};
|
|
void setCallbackKind (bool hasInit, bool hasTrig)
|
|
{
|
|
hasCallbackInitiated=hasInit;
|
|
hasCallbackTriggered=hasTrig;
|
|
if ( hasInit && !hasTrig)
|
|
{
|
|
callbackProgressKind=(CAFENUM::CallbackProgressKind) CAFENUM::PENDING;
|
|
}
|
|
else if (!hasInit && hasTrig)
|
|
{
|
|
callbackProgressKind=(CAFENUM::CallbackProgressKind) CAFENUM::COMPLETE;
|
|
}
|
|
else if (!hasInit && !hasTrig)
|
|
{
|
|
callbackProgressKind=(CAFENUM::CallbackProgressKind) CAFENUM::NOT_INITIATED;
|
|
}
|
|
else
|
|
{
|
|
std::cout << "CAFE INTERNAL POLICY ERROR" << std::endl;
|
|
std::cout << "ChannelRequestStatus::setCallbackKind gives an INVALID callbackProgressKind" << std::endl;
|
|
}
|
|
};
|
|
//void setMessageStatus (long mstatus) {messageStatus = mstatus;};
|
|
// void setMessageKind (StatusMessageKind mkind) { if (mkind<=CAFENUM::FROM_CALLBACK && mkind >= CAFENUM::PRE_REQUEST)
|
|
// {messageKind = mkind;} else {cout<< mkind << " is an invalid statusMessageKind!" << endl;}};
|
|
|
|
ChannelRequestStatus():preRequestStatus(ICAFE_CS_NEVER_CONN),requestStatus(ICAFE_CS_NEVER_CONN),pendStatus(ICAFE_CS_NEVER_CONN),
|
|
callbackStatus(ICAFE_CS_NEVER_CONN),messageStatus(ICAFE_CS_NEVER_CONN),messageKind((CAFENUM::StatusMessageKind) CAFENUM::NO_MESSAGE),
|
|
hasCallbackInitiated(false),hasCallbackTriggered(false),callbackProgressKind((CAFENUM::CallbackProgressKind) CAFENUM::NOT_INITIATED) {};
|
|
};
|
|
|
|
#endif // CHANNELINFO_H
|