317 lines
13 KiB
C++
317 lines
13 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>
|
|
|
|
using namespace std;
|
|
|
|
/**
|
|
* 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;};
|
|
string getHostNameAsString() {string h= hostName; return h;};
|
|
chtype getDataType() const {return dataType;};
|
|
const char * getClassName() const {return className;};
|
|
string getClassNameAsString() {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;};
|
|
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!";}};
|
|
|
|
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(){};
|
|
};
|
|
|
|
|
|
/**
|
|
* 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;};
|
|
char getOptions() const {return options[MAX_ENUM_STATES][MAX_ENUM_STRING_SIZE];};
|
|
};
|
|
|
|
|
|
/**
|
|
* 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());
|
|
}
|
|
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" << 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
|