/// /// \file handleHelper.cpp /// \author Jan Chrin, PSI /// \date Release, February 2015 /// \version CAFE 1.0.0 /// #include #include #include using namespace std; #if HAVE_PYTHON_H /** * \brief HandleHelper::setPyGetCallbackFn \n * Set Python callback function for asynchronous get operations\n * * \param _handle input: handle identifying Conduit object * \param callbackFn input: void * callback function * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::setPyGetCallbackFn(unsigned int _handle, void * callbackFn) { #define __METHOD__ "HandleHelper::setPyGetCallbackFn(unsigned int _handle, void * callbackFn" cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_pyGetCallbackFn(callbackFn)); } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief HandleHelper::setPyPutCallbackFn \n * Set Python callback function for asynchronous put operations\n * * \param _handle input: handle identifying Conduit object * \param callbackFn input: void * callback function * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::setPyPutCallbackFn(unsigned int _handle, void * callbackFn) { #define __METHOD__ "HandleHelper::setPyPutCallbackFn(unsigned int _handle, void * callbackFn" cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_pyPutCallbackFn(callbackFn)); } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief HandleHelper::setPyConnectCallbackFn \n * Set Python callback function invoked on connect/disconnect\n * * \param _handle input: handle identifying Conduit object * \param callbackFn input: void * callback function * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::setPyConnectCallbackFn(unsigned int _handle, void * callbackFn) { #define __METHOD__ "HandleHelper::setPyConnectCallbackFn(unsigned int _handle, void * callbackFn " cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { bool _pycbflag = true; handle_index.modify(it_handle, change_pyOpenCallbackFlag(_pycbflag)); handle_index.modify(it_handle, change_pyConnectCallbackFn(callbackFn)); //cout << "Handle=" << _handle << __METHOD__ << endl; //cout << callbackFn << endl; } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } #endif /** * \brief HandleHelper::addWidget \n * Inserts widget to vector of widgets associated to handle\n * * \param _handle input: handle identifying Conduit object * \param eidget input: void * giving the widget * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::addWidget(unsigned int _handle, void * widget) { #define __METHOD__ "HandleHelper::addWidget(unsigned int _handle, void * widget" cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_widgetInsert(widget)); } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Get widgets associated to handle. * Typically one widget is associated to a handle (but can be more). * \param _handle input : Conduit object reference * \return returns vector of widgets; length 0 is none or invalid handle */ int HandleHelper::getWidgets(unsigned int _handle, std::vector &widgetV) { #define __METHOD__ \ "HandleHelper::getWidgets(unsigned int _handle, vector &widgetV" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { widgetV=vector((*it_handle).getWidgetV()); } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return status; #undef __METHOD__ } /** * \brief HandleHelper::removeWidget \n * Removes widget from vector of widgets associated to handle\n * * \param _handle input: handle identifying Conduit object * \param widget input: void * giving the widget to remove * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::removeWidget(unsigned int _handle, void * widget) { #define __METHOD__ "HandleHelper::removeWidget(unsigned int _handle, void * widget" cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_widgetErase(widget)); } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Checks what's in the hash table against actual ca server data \n * Do for all handles * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int HandleHelper::checkConsistency() { #define __METHOD__ "HandleHelper::checkConsistency()" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus=checkConsistency( (*itcs).getHandle()); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * \brief Checks what's in the hash table against actual ca server data * \param _handle input : Conduit object reference * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int HandleHelper::checkConsistency(unsigned int _handle) { #define __METHOD__ "HandleHelper::checkConsistency(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { unsigned int nflag=0; string message=""; ChannelRegalia chInfo=(*it_handle).getChannelRegalia(); if (chInfo.getChannelID()==NULL) return ECAFE_NULLCHID; int op=chInfo.getConnectionState(); if (op==CA_OP_CONN_UP) { if (ca_state(chInfo.getChannelID()) != cs_conn) { chInfo.setConnectionState (CA_OP_CONN_DOWN); chInfo.setCafeConnectionState(ICAFE_CS_DISCONN); chInfo.setConnectFlag(false); nflag=1; message.append("CONNECT TRUE WHEN FALSE\n"); } if (ca_element_count(chInfo.getChannelID()) != chInfo.getNelem()) { chInfo.setNelem (ca_element_count(chInfo.getChannelID())); message.append("NELEM COUNT WRONG IN HASH TABLE\n"); nflag=10; } if (ca_field_type(chInfo.getChannelID()) != chInfo.getDataType()) { chInfo.setDataType (ca_field_type(chInfo.getChannelID())); message.append("NATIVE DATATYPE WRONG IN HASH TABLE\n"); nflag=100; } } else { if (ca_state(chInfo.getChannelID()) == cs_conn) { chInfo.setConnectionState (CA_OP_CONN_UP); chInfo.setCafeConnectionState(ICAFE_CS_CONN); chInfo.setConnectFlag(true); nflag=2; message.append("CONNECT FALSE WHEN TRUE\n"); } } if (ca_read_access( chInfo.getChannelID()) != chInfo.getReadAccess()) { chInfo.setReadAccess (ca_read_access(chInfo.getChannelID())); message.append("READ ACCESS WRONG IN HASH TABLE\n"); nflag=1000; } if (ca_write_access(chInfo.getChannelID()) != chInfo.getWriteAccess()) { chInfo.setWriteAccess (ca_write_access(chInfo.getChannelID())); message.append("WRITE ACCESS WRONG IN HASH TABLE\n"); nflag=10000; } if (nflag>0) { std::cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << std::endl; std::cout << "Following Corrections Made:" << std::endl; std::cout << message << endl; //else { // std::cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << std::endl; // std::cout << "CA CONSISTENCY VERIFIED " << std::endl; //} if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRegalia(chInfo)); if(MUTEX) { cafeMutex.unlock(); } return ECAFE_INCONSISTENT_CONTAINER_CORRECTED; } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves whether pv is of enumerated type * \param _handle input: handle * \return true if enum type else false */ bool HandleHelper::isEnum(unsigned int _handle) { #define __METHOD__ "HandleHelper::isEnum(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { if (!(*it_handle).isConnected() && (*it_handle).isConnected() == ICAFE_CS_NEVER_CONN ) { return false; } PVCtrlHolder _pvc; unsigned int nelem=getNelemRequestCtrl(_handle); if (nelem >1) { setNelemToRetrieveFromCtrlCache(_handle,1); } _pvc.setNelem(nelem); int _stat = (*it_handle).getPVCtrlHolder(_pvc) ; //return to previous if (nelem!=1) { setNelemToRetrieveFromCtrlCache(_handle,nelem); } if (_stat==ICAFE_NORMAL) { if (_pvc.getNoEnumStrings()>0 ) { // cafeBeta 1.0 uses shared pointer //_pvc.deleteVal(); return true; } } // cafeBeta 1.0 uses shared pointer //_pvc.deleteVal(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return false; } return false; #undef __METHOD__ } /** * \brief Retrieves enum unsigned short state of enumerated string type * \param _handle input: handle * \param enumStringValue input: enum string state * \return short enum value else -1 */ short HandleHelper::getEnumFromString(unsigned int _handle, std::string enumStringValue) { #define __METHOD__ "HandleHelper::getEnumFromString(unsigned int _handle, string enumStringValue)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { //Never connected so do not know if (!(*it_handle).isConnected() && (*it_handle).getStatus() == ICAFE_CS_NEVER_CONN ) { return -1; } PVCtrlHolder _pvc; unsigned int nelem=getNelemRequestCtrl(_handle); if (nelem >1) { setNelemToRetrieveFromCtrlCache(_handle,1); } _pvc.setNelem(nelem); int _stat = (*it_handle).getPVCtrlHolder(_pvc) ; //return to previous if (nelem != 1) { setNelemToRetrieveFromCtrlCache(_handle,nelem); } if (_stat==ICAFE_NORMAL) { return _pvc.getEnumFromString(enumStringValue); } else { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(_stat); cout << "Error for handle=" << _handle << " in (*it_handle).getPVCtrlHolder(_pvc) " << endl; return -1; } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return -1; } return false; #undef __METHOD__ } /** * \brief Retrieves string value of enum unsigned short * \param _handle input: handle * \param enumValue input: unsigned short enum value * \return string stringValue else "" */ string HandleHelper::getStringFromEnum(unsigned int _handle, unsigned short enumValue) { #define __METHOD__ "HandleHelper::getStringFromEnum(unsigned int _handle, unsigned short enumValue)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { //Never connected so do not know if (!(*it_handle).isConnected() && (*it_handle).getStatus() == ICAFE_CS_NEVER_CONN ) { return (string) ""; } PVCtrlHolder _pvc; unsigned int nelem=getNelemRequestCtrl(_handle); if (nelem >1) { setNelemToRetrieveFromCtrlCache(_handle,1); } _pvc.setNelem(nelem); int _stat = (*it_handle).getPVCtrlHolder(_pvc) ; //return to previous if (nelem!=1) { setNelemToRetrieveFromCtrlCache(_handle,nelem); } if (_stat==ICAFE_NORMAL) { return _pvc.getStringFromEnum(enumValue); } else { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(_stat); cout << "Error for handle=" << _handle << " in (*it_handle).getPVCtrlHolder(_pvc) " << endl; return (string) ""; } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return (string) ""; } return (string) ""; #undef __METHOD__ } /** * \brief Retrieves vector value options of enum unsigned short * \param _handle input: handle * \return string stringValue else "" */ vector HandleHelper::getEnumStrings(unsigned int _handle) { #define __METHOD__ "HandleHelper::getEnumStrings(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); vector stringEnumValues; if (it_handle != handle_index.end()) { //Never connected so do not know if (!(*it_handle).isConnected() && (*it_handle).getStatus() == ICAFE_CS_NEVER_CONN ) { return stringEnumValues; //empty } PVCtrlHolder _pvc; unsigned int nelem=getNelemRequestCtrl(_handle); if (nelem >1) { setNelemToRetrieveFromCtrlCache(_handle,1); } _pvc.setNelem(nelem); int _stat = (*it_handle).getPVCtrlHolder(_pvc) ; //return to previous if (nelem!=1) { setNelemToRetrieveFromCtrlCache(_handle,nelem); } if (_stat==ICAFE_NORMAL) { return _pvc.getEnumStrings(); } else { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(_stat); cout << "Error for handle=" << _handle << " in (*it_handle).getPVCtrlHolder(_pvc) " << endl; return stringEnumValues; } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return stringEnumValues; //empty } return stringEnumValues; //empty #undef __METHOD__ } /** * \brief Gets the user arg as uint in event callback; meant for retrieving the current monitor ID * \param _handle input: handle * \return (uint) usr.args; meant for monitorID */ unsigned int HandleHelper::getUsrArgsAsUInt(unsigned int _handle) { #define __METHOD__ "unsigned int getUsrArgsAsUInt(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned long monid=0; if (it_handle != handle_index.end()) { monid = (unsigned long) (*it_handle).getUsrArgs(); //monid = (unsigned long) (*it_handle).getChannelRequestMetaData().getUsrArg(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return monid; #undef __METHOD__ } /** * \brief Gets the datatype of handle from within the callback function * \param _handle input: handle * \return chtype dataType */ chtype HandleHelper::getDataTypeCB(unsigned int _handle) { #define __METHOD__ "chtype getDataTypeCB(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); chtype chval=0; if (it_handle != handle_index.end()) { chval = (unsigned long) (*it_handle).getDataType(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return chval; #undef __METHOD__ } /** * \brief Gets the dbrdatatype of handle from within the callback function * \param _handle input: handle * \return chtype dataType */ chtype HandleHelper::getDbrDataTypeCB(unsigned int _handle) { #define __METHOD__ "chtype getDbrDataTypeCB(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); chtype chval=0; if (it_handle != handle_index.end()) { chval = (unsigned long) (*it_handle).getDbrDataType(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return chval; #undef __METHOD__ } /** * \brief Gets the cafeDbrType of handle from within the callback function * \param _handle input: handle * \return CAFENUM::DBR_TYPE cafeDbrDataType */ CAFENUM::DBR_TYPE HandleHelper::getCafeDbrTypeCB(unsigned int _handle) { #define __METHOD__ "CAFENUM:DBR_TYPE getCafeDbrTypeCB(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); CAFENUM::DBR_TYPE chval=CAFENUM::DBR_NONE; if (it_handle != handle_index.end()) { chval = (*it_handle).getCafeDbrType(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return chval; #undef __METHOD__ } /** * \brief Retrieves the native data type from ChannelRegalia object * \param _handle input: handle * \param ndt output: CAFE_DATATYPE object * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::getDataTypeNative(unsigned int _handle, chtype & ndt) { #define __METHOD__ "HandleHelper::getDataTypeNative(unsigned int _handle, CAFE_DATATYPE &cdt)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { ndt = (*it_handle).getChannelRegalia().getDataType(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves channel meta deta held in ChannelRequestStatusGetClassName object * \param _handle input: handle * \param crsClassName output: ChannelRequestStatus instance * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::getChannelRequestStatusGetClassName(unsigned int _handle, ChannelRequestStatus &crsClassName) { #define __METHOD__ "HandleHelper::getChannelRequestStatusGetClassName(unsigned int _handle, ChannelRequestStatus &crsClassName)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { crsClassName = (*it_handle).getChannelRequestStatusGetClassName(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves channel meta deta held in ChannelRequestStatusGetSTSACK object * \param _handle input: handle * \param crsSTSACK output: ChannelRequestStatus instance * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::getChannelRequestStatusGetSTSACK(unsigned int _handle, ChannelRequestStatus &crsSTSACK) { #define __METHOD__ "HandleHelper::getChannelRequestStatusGetSTACK(unsigned int _handle, ChannelRequestStatus &crsSTSACK)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { crsSTSACK = (*it_handle).getChannelRequestStatusGetSTSACK(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves channel meta deta held in ChannelRequestStatusGetCtrl object * \param _handle input: handle * \param crsCtrl output: ChannelRequestStatus instance * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::getChannelRequestStatusGetCtrl(unsigned int _handle, ChannelRequestStatus &crsCtrl) { #define __METHOD__ "HandleHelper::getChannelRequestStatusGetCtrl(unsigned int _handle, ChannelRequestStatus &crsCtrl)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { crsCtrl = (*it_handle).getChannelRequestStatusGetCtrl(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves channel meta deta held in ChannelRequestStatusGet object * \param _handle input: handle * \param crs output: ChannelRequestStatus instance * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::getChannelRequestStatusGet (unsigned int _handle, ChannelRequestStatus &crs) { #define __METHOD__ "HandleHelper::getChannelRequestStatusGet(unsigned int _handle, ChannelRequestStatus &crs)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { crs = (*it_handle).getChannelRequestStatusGet(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves channel meta deta held in the ChannelRegalia object * \param _handle input: handle * \param channelInfo output: ChannelRegalia object * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::getChannelRegalia(unsigned int _handle, ChannelRegalia & channelInfo) { #define __METHOD__ "HandleHelper::getChannelInfo(unsigned int _handle, ChannelRegalia channelInfo)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { channelInfo = (*it_handle).getChannelRegalia(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Given the deliminator, sets the device/attribute components of the epics channel, for all handles * \param deliminator deliminator: string (at PSI this is ususally a colon, i.e. ":") * \return ICAFE_NORMAL if all OK else ERROR */ int HandleHelper::setChannelDeviceAttribute(std::string deliminator) { int localStatus=ICAFE_NORMAL; int gStatus=ICAFE_NORMAL; bool sflag=false; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus= setChannelDeviceAttribute ((*itcs).getHandle(), deliminator); if (localStatus !=ICAFE_NORMAL && !sflag) { gStatus=localStatus; sflag=true; } } return gStatus; } /** * \brief Given the deliminator, sets the device/attribute components of the epics channel for a givem handle * \param _handle input: handle to Conduit Objecte * \param deliminator input: string (at PSI this is ususally a colon, i.e. ":") * \return ICAFE_NORMAL if all OK else ERROR */ int HandleHelper::setChannelDeviceAttribute(unsigned int _handle, std::string deliminator) { #define __METHOD__ "HandleHelper::setChannelDeviceAttribute(unsigned int _handle, std::string deliminator)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { ChannelDeviceAttribute channelDeviceAttribute; channelDeviceAttribute.init((*it_handle).pv, deliminator); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelDeviceAttribute( channelDeviceAttribute)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves pv units for a given handle * \param _handle input: handle to Conduit Object * \param precision output: device precision * \return ICAFE_NORMAL if all OK else ERROR */ int HandleHelper::getPrecision(unsigned int _handle, short & precision) { #define __METHOD__ "HandleHelper::getPrecision" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { precision = (*it_handle).getPrecision(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves pv units for a given handle * \param _handle input: handle to Conduit Object * \param units output: pv units * \return ICAFE_NORMAL if all OK else ERROR */ int HandleHelper::getUnits(unsigned int _handle, std::string & units) { #define __METHOD__ "HandleHelper::getUnits" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { units = (*it_handle).getUnits(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves pv description for a given handle * \param _handle input: handle to Conduit Object * \param desc output: pv description * \return ICAFE_NORMAL if all OK else ERROR */ int HandleHelper::getDescription(unsigned int _handle, std::string & desc) { #define __METHOD__ "HandleHelper::getDescription" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { desc = (*it_handle).getDescription(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Whether description field has been filled for a given handle * \param _handle input: handle to Conduit Object * \param desc output: true if description field has been filled * \return ICAFE_NORMAL if all OK else ERROR */ bool HandleHelper::hasDescription(unsigned int _handle) { #define __METHOD__ "HandleHelper::getDescription" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; bool hasDesc=false; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { if (!(*it_handle).isConnected() && (*it_handle).getStatus() == ICAFE_CS_NEVER_CONN ) { return hasDesc; } hasDesc = (*it_handle).hasDescription(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return hasDesc; } return hasDesc; #undef __METHOD__ } /** * \brief Retrieves device name for a given handle * \param _handle input: handle to Conduit Object * \param device output: device name * \return ICAFE_NORMAL if all OK else ERROR */ int HandleHelper::getChannelDevice(unsigned int _handle, std::string & device) { #define __METHOD__ "HandleHelper::getChannelDevice" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { device = (*it_handle).getDevice(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves attribute name for a given handle * \param _handle input: handle to Conduit Object * \param attribute output: attribute name * \return ICAFE_NORMAL if all OK else ERROR */ int HandleHelper::getChannelAttribute(unsigned int _handle, std::string & attribute) { #define __METHOD__ "HandleHelper::getChannelAttribute" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { attribute = (*it_handle).getAttribute(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves the total number of handled * \return noHandles: Total no. of handles */ unsigned int HandleHelper::getNoHandles() { #define __METHOD__ "HandleHelper::getNoHandles()" unsigned int nHandle=0; // Loop through all elements; for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { ++nHandle; } return nHandle; #undef __METHOD__ } /** * \brief Retrieves the next available handle * \return handle: value of next available handle */ unsigned int HandleHelper::getNextFreeHandle() { #define __METHOD__ "HandleHelper::getNextFreeHandle()" unsigned int freeHandle=0; vector handleVector; handleVector.reserve(getNoHandles()); // Loop through all elements; for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { handleVector.push_back((*itcs).getHandle()); } std::sort (handleVector.begin(), handleVector.begin()); for (std::vector::iterator itui=handleVector.begin(); itui!=handleVector.end(); ++itui) { ++freeHandle; if ( (*itui) !=freeHandle) { return freeHandle; } } //const unsigned int min_int = std::numeric_limits::min(); const unsigned int max_int = std::numeric_limits::max(); if (freeHandle == max_int) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cout << "THE MAXIMUM ALLOWED NUMBER OF HANDLES HAS BEEN REACHED " << endl; cout << "THIS MAXIMUM VALUE IS " << max_int << endl; } return ++freeHandle; //this will give zero if max_int reached #undef __METHOD__ } /** * \brief Retrieves context for a first matching of this process variable * \param _pv input: process variable * \return ccc : ca_client_context (NULL if not found) */ ca_client_context * HandleHelper::getContextFromPV(const char * _pv) { #define __METHOD__ "HandleHelper::getContextFromPV(const char * _pv)" cafeConduit_set_by_pv & pv_index = cs.get (); cafeConduit_set_by_pv::iterator it_pv; char pv[PVNAME_SIZE]; removeLeadingAndTrailingSpaces(_pv, pv); it_pv = pv_index.find(pv); // Three possibilities of getting a match! if (it_pv != pv_index.end()) { // Examine ca_client_context noting that channels within a group dO count! return (*it_pv).getClientContext() ; } else { // Loop through all elements and search for pv match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { //if((*itcs).getGroupHandle()>0) {continue;} // Channels within a group don't count! if (!strcmp((*itcs).getPV(), _pv)) { //cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; //out << " INFORMATION to author: MATCHed Handle= " << (*itcs).handle << " to PV= " << _pv << endl; //cout << " by looping through tcs::iterator, while the pv::iterator was NOT found! " << endl; return (*itcs).getClientContext(); } } } return NULL; #undef __METHOD__ } /** * \brief Retrieves the ca_client_context for first matching of handle * \param handle input: handle * \return ccc output: ca_client_context */ ca_client_context * HandleHelper::getContextFromHandle(unsigned int handle) { #define __METHOD__ "HandleHelper::getContextFromHandle(unsigned int handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { return (*it_handle).getClientContext(); } else { // Loop through all elements and search for handle/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { // if((*itcs).getGroupHandle()>0) {continue;} // Channels within a group don't count! if ( (*itcs).getHandle()==handle) { //cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; //cout << " INFORMATION to author: MATCHed Handle= " << handle << " to PV= " << (*itcs).getPV() << endl; //cout << " by looping through tcs::iterator, while the by_handle::iterator was NOT found! " << endl; return (*itcs).getClientContext(); } } } //cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; //cout << "PV for Handle=" << handle << " not found " << endl; return NULL; #undef __METHOD__ } /** * \brief Retrieves handle for a given process variable * \param _pv input: process variable * \return handle else 0 if no handle exists */ unsigned int HandleHelper::getHandleFromPV(const char * _pv) { #define __METHOD__ "HandleHelper::getHandleFromPV(const char * _pv)" ca_client_context * ccc = ca_current_context(); return getHandleFromPV(_pv,ccc); #undef __METHOD__ } /** * \brief Retrieves handle for a given process variable * \param _pv input: process variable * \return handle else 0 if no handle exists */ unsigned int HandleHelper::getHandleFromPVAlias(const char * _pv) { #define __METHOD__ "HandleHelper::getHandleFromPVAlias(const char * _pv)" ca_client_context * ccc = ca_current_context(); return getHandleFromPVAlias(_pv,ccc); #undef __METHOD__ } /** * \brief Retrieves handle for a given process variable * \param _pv input: process variable * \param ccc input: ca_client_context * \return handle else 0 if no handle exists */ unsigned int HandleHelper::getHandleFromPV(const char * _pv, ca_client_context * ccc) { #define __METHOD__ "HandleHelper::getHandleFromPV(const char * _pv, ca_client_context * ccc)" cafeConduit_set_by_pv & pv_index = cs.get (); cafeConduit_set_by_pv::iterator it_pv; char pv[PVNAME_SIZE]; removeLeadingAndTrailingSpaces(_pv, pv); it_pv = pv_index.find(pv); // Three possibilities of getting a match! if (it_pv != pv_index.end()) { // Examine ca_client_context noting that channels within a group don't count! if (ccc == (*it_pv).getClientContext() && (*it_pv).getGroupHandle()==0 ) { //std::cout << "One: " << (*it_pv).handle << std::endl; return (*it_pv).handle; } else { // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()>0) { continue; // Channels within a group don't count! } if (!strcmp((*itcs).getPV(), _pv) && (*itcs).getClientContext()== ccc) { //std::cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << std::endl; //std::cout << " INFORMATION to author: MATCHed Handle= " << (*itcs).handle << " to PV= " << _pv << std::endl; //std::cout << " by looping through tcs::iterator, even though pv::iterator was found! " << std::endl; return (*itcs).handle; } } } } else { // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()>0) { continue; // Channels within a group don't count! } if (!strcmp((*itcs).getPV(), _pv) && (*itcs).getClientContext() == ccc) { //std::cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << std::endl; //std::cout << " INFORMATION to author: MATCHed Handle= " << (*itcs).handle << " to PV= " << _pv << std::endl; //std::cout << " by looping through tcs::iterator, while the pv::iterator was NOT found! " << std::endl; return (*itcs).handle; } } } return getHandleFromPVAlias(_pv, ccc); #undef __METHOD__ } /** * \brief Retrieves handle for a given process variable alias * \param _pv input: process variable alias * \param ccc input: ca_client_context * \return handle else 0 if no handle exists */ unsigned int HandleHelper::getHandleFromPVAlias(const char * _pv, ca_client_context * ccc) { #define __METHOD__ "HandleHelper::getHandleFromPVAlias(const char * _pv, ca_client_context * ccc)" cafeConduit_set_by_pvAlias & pv_index = cs.get (); cafeConduit_set_by_pvAlias::iterator it_pv; char pv[PVNAME_SIZE]; removeLeadingAndTrailingSpaces(_pv, pv); it_pv = pv_index.find(pv); // Three possibilities of getting a match! if (it_pv != pv_index.end()) { // Examine ca_client_context noting that channels within a group don't count! if (ccc == (*it_pv).getClientContext() && (*it_pv).getGroupHandle()==0 ) { return (*it_pv).handle; } else { // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()>0) { continue; // Channels within a group don't count! } if (!strcmp((*itcs).getPVAlias(), _pv) && (*itcs).getClientContext()== ccc) { //cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; //cout << " INFORMATION to author: MATCHed Handle= " << (*itcs).handle << " to PVAlias= " << _pv << endl; //cout << " by looping through tcs::iterator, even though pvAlias::iterator was found! " << endl; return (*itcs).handle; } } } } else { // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()>0) { continue; // Channels within a group don't count! } if (!strcmp((*itcs).getPVAlias(), _pv) && (*itcs).getClientContext() == ccc) { //cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; //cout << " INFORMATION to author: MATCHed Handle= " << (*itcs).handle << " to PVAlias= " << _pv << endl; //cout << " by looping through itcs::iterator, while the pvAlias::iterator was NOT found! " << endl; return (*itcs).handle; } } } return 0; #undef __METHOD__ } /** * \brief Retrieves the process variable from a given handle * \param handle input: handle * \return pv else NULL if no handle exists */ const char * HandleHelper::getPVAlias(unsigned int handle) { #define __METHOD__ "HandleHelper::getPVAlias(unsigned int handle)" ca_client_context * ccc = ca_current_context(); return getPVAlias(handle,ccc); #undef __METHOD__ } /** * \brief Retrieves the process variable from a given handle * \param handle input: handle * \param ccc input: ca_client_context * \return pv else NULL if no handle exists */ const char * HandleHelper::getPVAlias(unsigned int handle, ca_client_context * ccc) { #define __METHOD__ "HandleHelper::getPVAlkias(unsigned int handle, ca_client_context * ccc)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { return (*it_handle).getPVAlias(); } else { // Loop through all elements and search for handle/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()>0) { continue; // Channels within a group don't count! } if ( (*itcs).getHandle()==handle && (*itcs).getClientContext() == ccc) { //cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; //cout << " INFORMATION to author: MATCHed Handle= " << handle << " to PV= " << (*itcs).getPV() << endl; //cout << " by looping through tcs::iterator, while the by_handle::iterator was NOT found! " << endl; return (*itcs).getPVAlias(); } } } if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cout << "PVAlias for Handle=" << handle << " not found " << endl; } return ""; #undef __METHOD__ } cafeConduit_set_by_handle::iterator HandleHelper::getIterFromHandle(unsigned int handle) { #define __METHOD__ "HandleHelper::getIterFromHandle(unsigned int handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { //std::cout << __METHOD__ << " pv " << (*it_handle).getPV() << " // " << (*it_handle).handle << std::endl; return it_handle; } else {return it_handle;} #undef __METHOD__ } cafeConduit_set_by_handle & HandleHelper::getcsHandleIndex() { #define __METHOD__ "HandleHelper::getcsHandleIndex()" return cs.get(); #undef __METHOD__ } int HandleHelper::modifyHandleIndexStatus(unsigned int handle, long status) { #define __METHOD__ "HandleHelper::modifyHandleIndexStatus()" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_status(status)); } else { std::cout << "Handle=" << handle << " either never existed or no longer exists " << std::endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } int HandleHelper::modifyChannelTimeoutPolicyGet(unsigned int handle, ChannelTimeoutPolicy channelTimeoutPolicyGet) { #define __METHOD__ "HandleHelper::modifyChannelTimeoutPolicyGet()" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_channelTimeoutPolicyGet(channelTimeoutPolicyGet)); } else { std::cout << "Handle=" << handle << " either never existed or no longer exists " << std::endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } int HandleHelper::modifyChannelRequestStatusGet(unsigned int handle, ChannelRequestStatus channelRequestStatusGet) { #define __METHOD__ "HandleHelper::modifyChannelRequestStatusGet()" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_channelRequestStatusGet(channelRequestStatusGet)); } else { std::cout << "Handle=" << handle << " either never existed or no longer exists " << std::endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } int HandleHelper::modifyChannelRequestMetaDataClient(unsigned int handle, ChannelRequestMetaDataClient channelRequestMetaDataClient) { #define __METHOD__ "HandleHelper::modifyChannelRequestMetaDataClient()" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_channelRequestMetaDataClient(channelRequestMetaDataClient)); } else { std::cout << "Handle=" << handle << " either never existed or no longer exists " << std::endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves the process variable from a given handle * \param handle input: handle * \return pv else NULL if no handle exists */ const char * HandleHelper::getPVFromHandle(unsigned int handle) { #define __METHOD__ "HandleHelper::getPVFromHandle(unsigned int handle)" ca_client_context * ccc = ca_current_context(); return getPVFromHandle(handle,ccc); #undef __METHOD__ } /** * \brief Retrieves the process variable from a given handle * \param handle input: handle * \param ccc input: ca_client_context * \return pv else NULL if no handle exists */ const char * HandleHelper::getPVFromHandle(unsigned int handle, ca_client_context * ccc) { #define __METHOD__ "HandleHelper::getPVFromHandle(unsigned int handle, ca_client_context * ccc)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); //std::cout << __METHOD__ << "handle_index ==> " << &handle_index << std::endl; //std::cout << __METHOD__ << "handle_index ==> " << &handle_index << std::endl; //std::cout << __METHOD__ << "cs " << &cs << std::endl; if (it_handle != handle_index.end()) { //std::cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << std::endl; //std::cout << "Client context: " << ccc << std::endl; return (*it_handle).getPV(); } else { // Loop through all elements and search for handle/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()>0) { continue; // Channels within a group don't count! } if ( (*itcs).getHandle()==handle && (*itcs).getClientContext() == ccc) { cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; cout << " INFORMATION to author: MATCHed Handle= " << handle << " to PV= " << (*itcs).getPV() << endl; cout << " by looping through tcs::iterator, while the by_handle::iterator was NOT found! " << endl; return (*itcs).getPV(); } } } if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cout << "PV for Handle=" << handle << " not found " << endl; } return ""; #undef __METHOD__ } /** * \brief Retrieves handle for a given process variable with a CAFE group * \param _pv input: process variable * \param gh input: groupHandle * \return handle else 0 if no handle exists */ unsigned int HandleHelper::getHandleFromPVWithinGroup(const char * _pv, unsigned int gh) { #define __METHOD__ "HandleHelper::getHandleFromPVWithinGroup(const char * _pv, unsigned int gh)" ca_client_context * ccc = ca_current_context(); return getHandleFromPVWithinGroup(_pv,ccc, gh); #undef __METHOD__ } /** * \brief Retrieves handle for a given process variable with a CAFE group within a give ca context * \param _pv input: process variable * \param ccc input: ca_client_context * \param gh input: groupHandle * \return handle else 0 if no handle exists */ unsigned int HandleHelper::getHandleFromPVWithinGroup(const char * _pv, ca_client_context * ccc, unsigned int gh) { #define __METHOD__ \ "HandleHelper::getHandleFromPVWithinGroup(const char * _pv, ca_client_context * ccc, unsigned int gh)" cafeConduit_set_by_pv & pv_index = cs.get (); cafeConduit_set_by_pv::iterator it_pv; char pv[PVNAME_SIZE]; removeLeadingAndTrailingSpaces(_pv, pv); it_pv = pv_index.find(pv); // Three possibilities of getting a match! if (it_pv != pv_index.end()) { // Examine ca_client_context noting that channels within a group don't count! if (ccc == (*it_pv).getClientContext() && (*it_pv).getGroupHandle()==gh ) { return (*it_pv).handle; } else { // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()!=gh) { continue; // Channels within a group don't count! } if (!strcmp((*itcs).getPV(), _pv) && (*itcs).getClientContext()== ccc) { //cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; //cout << " INFORMATION to author: MATCHed Handle= " << (*itcs).handle << " to PV= " << _pv << endl; //cout << " by looping through tcs::iterator, even though pv::iterator was found! " << endl; return (*itcs).handle; } //Maybe called from within thread with null context else if (!strcmp((*itcs).getPV(), _pv) && 0 == ccc) { return (*itcs).handle; } } } } else { // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if((*itcs).getGroupHandle()!=gh) { continue; // Channels within a group don't count! } if (!strcmp((*itcs).getPV(), _pv) && (*itcs).getClientContext() == ccc) { //cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; //cout << " INFORMATION to author: MATCHed Handle= " << (*itcs).handle << " to PV= " << _pv << endl; //cout << " by looping through tcs::iterator, while the pv::iterator was NOT found! " << endl; return (*itcs).handle; } } } return 0; //getHandleFromPVAliasWithinGroup(_pv, ccc); #undef __METHOD__ } /** * \brief Retrieves all handles belonging to a group referenced by its groupHandle * \param _groupHandle input: groupHandle * \return vector of handles within Group */ vector HandleHelper::getHandlesFromWithinGroupV(unsigned int _groupHandle) { #define __METHOD__ "HandleHelper::getHandlesFromWithinGroupV" cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_groupHandle); vector vhg; if (it_groupHandle != groupHandle_index.end()) { vhg.reserve( (*it_groupHandle).getNMember()); for (unsigned int i=0; i <(*it_groupHandle).getNMember(); ++i ) { vhg.push_back((*it_groupHandle).mHandle[i]); } return vhg; } else { // Loop through all elements and search for grouphandle match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { if ((*itgs).getGroupHandle() == _groupHandle ) { vhg.reserve( (*itgs).getNMember()); for (unsigned int i=0; i <(*itgs).getNMember(); ++i ) { vhg.push_back((*itgs).mHandle[i]); } return vhg; } } } cafeStatus.report(ECAFE_UNKNOWN_GROUP); return vhg; #undef __METHOD__ } /** * \brief Retrieves all handles belonging to a group referenced by its groupHandle * \param _groupHandle input: groupHandle * \return array of handles within Group */ unsigned int * HandleHelper::getHandlesFromWithinGroup(unsigned int _groupHandle) { #define __METHOD__ "HandleHelper::getHandlesFromWithinGroup" cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_groupHandle); if (it_groupHandle != groupHandle_index.end()) { return (*it_groupHandle).mHandle; } else { // Loop through all elements and search for grouphandle match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { //ConduitGroup cg = *itgs; if ((*itgs).getGroupHandle() == _groupHandle ) { return (*itgs).mHandle; // cout << " MATCH FOUND Handle Number is= " << (cg).groupHandle << endl; } } } cafeStatus.report(ECAFE_UNKNOWN_GROUP); // Find number of members // Declare vector // Loop round all members // Find pv // find handle // add to vector return (unsigned int *) NULL; #undef __METHOD__ } /** * \brief Retrieves all handles belonging to a group referenced by its groupHandle * \param _groupHandle input: groupHandle * \return vector of handles within Group */ vector HandleHelper::getDisconnectedHandlesFromWithinGroupV(unsigned int _groupHandle) { #define __METHOD__ "HandleHelper::getDisconnectedHandlesFromWithinGroupV" cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_groupHandle); vector vhg; if (it_groupHandle != groupHandle_index.end()) { vhg.reserve( (*it_groupHandle).getNMember()); cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; for (unsigned int i=0; i <(*it_groupHandle).getNMember(); ++i ) { it_handle = handle_index.find((*it_groupHandle).mHandle[i]); if (it_handle != handle_index.end()) { if ( ! ((*it_handle).isConnected()) ) { vhg.push_back((*it_groupHandle).mHandle[i]); } } } return vhg; } else { // Loop through all elements and search for grouphandle match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { if ((*itgs).getGroupHandle() == _groupHandle ) { vhg.reserve( (*itgs).getNMember()); cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; for (unsigned int i=0; i <(*itgs).getNMember(); ++i ) { it_handle = handle_index.find((*itgs).mHandle[i]); if (it_handle != handle_index.end()) { if ( !((*it_handle).isConnected() ) ) { vhg.push_back((*itgs).mHandle[i]); } } } return vhg; } } } cafeStatus.report(ECAFE_UNKNOWN_GROUP); return vhg; #undef __METHOD__ } /** * \brief Method returns true if channel is connected, else false * \param handle input: handle * \return bool */ bool HandleHelper::isChannelConnected(unsigned int handle) { #define __METHOD__ "HandleHelper::isChannelConnected" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(handle); if (it_handle != handle_index.end()) { return (*it_handle).isConnected(); } else { //if (printErrorPolicy.getInvalidHandle()) { std::cout << __METHOD__ << " Input handle " << handle << " does not exist! " << std::endl; //} return false; } #undef __METHOD__ } /** * \brief Method returns true if all given channels are connected, else false * \parameter handleArray input: array of handles to test connection state of * \parameter nHandles input: no of handles in array * \return bool */ bool HandleHelper::areChannelsConnected(unsigned int * handleArray, const unsigned int nHandles) { #define __METHOD__ "HandleHelper::areChannelsConnected" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; for (int i=0; i < nHandles; ++i) { it_handle = handle_index.find(handleArray[i]); if (it_handle != handle_index.end()) { if (!(*it_handle).isConnected()) { return false; } } else { //if (printErrorPolicy.getInvalidHandle()) { std::cout << __METHOD__ << " Input handle " << handleArray[i] << " does not exist! " << std::endl; //} return false; } } return true; #undef __METHOD__ } /** * \brief Method returns true if all given channels are connected, else false * \parameter handleV input: vector of handles to test connection state of * \return bool */ bool HandleHelper::areChannelsConnectedV(std::vector handleV) { #define __METHOD__ "HandleHelper::areChannelsConnectedV" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; for (int i=0; i < handleV.size(); ++i) { it_handle = handle_index.find(handleV[i]); if (it_handle != handle_index.end()) { if (!(*it_handle).isConnected()) { return false; } } else { //if (printErrorPolicy.getInvalidHandle()) { std::cout << __METHOD__ << " Input handle " << handleV[i] << " does not exist! " << std::endl; //} return false; } } return true; #undef __METHOD__ } /** * \brief Method returns true if all channels are connected, else false * \return bool */ bool HandleHelper::allChannelsConnected() { #define __METHOD__ "HandleHelper::allChannelsConnected" ca_client_context * ccc = ca_current_context(); // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if (!(*itcs).isConnected() && (ccc ==(*itcs).getClientContext()) ) { return false; } } return true; #undef __METHOD__ } /** * \brief Method returns true if all channels are connected, else false * \return bool */ bool HandleHelper::allChannelsWithinGroupConnected() { #define __METHOD__ "HandleHelper::allChannelsWithinGroupConnected" ca_client_context * ccc = ca_current_context(); // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if (!(*itcs).isConnected() && (ccc ==(*itcs).getClientContext()) && (*itcs).getGroupHandle()>0 ) { return false; } } return true; #undef __METHOD__ } /** * \brief Method returns true if all channels within the given vector of groups handles are connected, else false * \param grpID input: vector of group handles * \return bool */ bool HandleHelper::allChannelsWithinGroupConnectedV(std::vector grpID) { #define __METHOD__ "HandleHelper::allChannelsWithinGroupConnectedV" if (grpID.size()==0) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cout << "Input vector listing group handles is of zero size " << endl; } for (size_t i=0; i 0) { //cout << "group handle " << grpID[i] << " NOT all members connected " << endl; return false; } //cout << "group handle " << grpID[i] << " has all members connected " << endl; } return true; #undef __METHOD__ } /** * \brief Retrieves last cached status information for given handle * \param _handle input: handle * \return status */ int HandleHelper::getStatus(unsigned int _handle) { #define __METHOD__ "HandleHelper::getStatus(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { return (*it_handle).getStatus(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } #undef __METHOD__ } /** * \brief Retrieves last cached timestamp information for given handle * \param _handle input: handle * \param ts output: epicsTimeStamp * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int HandleHelper::getTimeStamp(unsigned int _handle, epicsTimeStamp &ts) { #define __METHOD__ "HandleHelper::getTimeStamp(unsigned int _handle, epicsTimeStamp &ts)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); ts.secPastEpoch=0; ts.nsec=0; if (it_handle != handle_index.end()) { ts= (*it_handle).getTimeStamp(); return ICAFE_NORMAL; } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } #undef __METHOD__ } /** * \brief Checks for nan values in HIHI HIGH LOW LOLO fields. * \param _handle input: handle * \return true if one of HIHI|HIGH|LOW|LOLO is not nan, else false if all are nan */ bool HandleHelper::hasAlarmStatusSeverity(unsigned int _handle) { #define __METHOD__ "HandleHelper::hasAlarmStatusSeverity(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); //Only these have alarm/severity std::vectoralarmSeverityRecordTypes; alarmSeverityRecordTypes.reserve(10); alarmSeverityRecordTypes.push_back( std::string ( "ai")); alarmSeverityRecordTypes.push_back( std::string ( "ao")); alarmSeverityRecordTypes.push_back( std::string ( "calc")); alarmSeverityRecordTypes.push_back( std::string ( "dfanout")); alarmSeverityRecordTypes.push_back( std::string ( "longin")); alarmSeverityRecordTypes.push_back( std::string ( "longout")); alarmSeverityRecordTypes.push_back( std::string ( "pid")); alarmSeverityRecordTypes.push_back( std::string ( "sel")); alarmSeverityRecordTypes.push_back( std::string ( "steppermotor")); alarmSeverityRecordTypes.push_back( std::string ( "sub")); if (it_handle != handle_index.end()) { //Never connected so do not know if (!(*it_handle).isConnected() && (*it_handle).getStatus() == ICAFE_CS_NEVER_CONN ) { return false; } PVDataHolder _pvd; unsigned int nelem=getNelemRequest(_handle); if (nelem >1) { setNelemToRetrieveFromCache(_handle,1); } _pvd.setNelem(nelem); //return to previous if (nelem != 1) { setNelemToRetrieveFromCtrlCache(_handle,nelem); } bool returnFlag = false; int _status = (*it_handle).getPVDataHolder(_pvd) ; if (_status == ICAFE_NORMAL) { if (_pvd.getAlarmSeverity() == EPICS_GLOBAL_ALARM_SEVERITY::SEV_MAJOR || _pvd.getAlarmSeverity() == EPICS_GLOBAL_ALARM_SEVERITY::SEV_MINOR) { returnFlag = true; } } //return to previous if (nelem != 1) { setNelemToRetrieveFromCache(_handle,nelem); } if (returnFlag == true) { return true; } std::string className= (std::string) (*it_handle).getClassName(); std::vector::const_iterator it = std::find(alarmSeverityRecordTypes.begin(), alarmSeverityRecordTypes.end(), className); // if never connected getStatus is 600 ICAFE_CS_NEVER_CONN // std::cout << (*it_handle).getPV() << " is Connected " << (*it_handle).isConnected() << std::endl; // std::cout << "getStatus " << (*it_handle).getStatus() << std::endl; // Check if handle has already been supplemented if ((*it_handle).hasAlarmSeverityStruct()) { std::cout << __METHOD__ << " is true " << std::endl; return (*it_handle).hasAlarmSeverity(); } if (it == alarmSeverityRecordTypes.end()) { return false; } PVCtrlHolder _pvc; nelem=getNelemRequestCtrl(_handle); if (nelem >1) { setNelemToRetrieveFromCtrlCache(_handle,1); } _pvc.setNelem(nelem); int _stat = (*it_handle).getPVCtrlHolder(_pvc) ; // Should already have been caught by first check above if (!(*it_handle).isConnected() && _pvc.getStatus() == ICAFE_CS_NEVER_CONN ) { return false; } // if Never connected getStatus is 600 ICAFE_CS_NEVER_CONN // std::cout << "status from getPVCtrlHolder // " << _stat << std::endl; // std::cout << "status from getPVCtrlHolder // " << _pvc.getStatus() << std::endl; //_pvc.print(); //return to previous if (nelem!=1) { setNelemToRetrieveFromCtrlCache(_handle,nelem); } if (_stat==ICAFE_NORMAL) { //Special test for ENUM value - should never reach here as is mbbi/o record //if (_pvc.getNoEnumStrings()>0 ) //{ // return false; //} //enums can have alarms states!!! if (!((boost::math::isnan)(_pvc.getLowerAlarmLimit_AsDouble()))) { if (_pvc.getLowerAlarmLimit_AsDouble() != 0) { return true; } } else if (!((boost::math::isnan)(_pvc.getLowerWarningLimit_AsDouble()))) { if (_pvc.getLowerWarningLimit_AsDouble() != 0) { return true; } } else if (!((boost::math::isnan)(_pvc.getUpperWarningLimit_AsDouble()))) { if (_pvc.getUpperWarningLimit_AsDouble() != 0) { return true; } } else if (!((boost::math::isnan)(_pvc.getUpperAlarmLimit_AsDouble()))) { if (_pvc.getUpperAlarmLimit_AsDouble() != 0) { return true; } } return false; } else { return false; } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return false; } #undef __METHOD__ } /** * \brief Retrieves last cached status information for given handle * \param _handle input: handle * \param as output: alarmStatus [0] and alarmSeverity [1] in array of dbr_short_t[2] * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int HandleHelper::getAlarmStatusSeverity(unsigned int _handle, dbr_short_t as[2]) { #define __METHOD__ "HandleHelper::getAlarmStatusSeverity(unsigned int _handle, short & *as)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { as[0]= (*it_handle).getAlarmStatus(); as[1]= (*it_handle).getAlarmSeverity(); return ICAFE_NORMAL; } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } #undef __METHOD__ } /** * \brief Retrieves last cached status information for given handle * \param _handle input: handle * \param asas output: alarmStatus [0] and alarmSeverity [1] in array of dbr_short_t[2] * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int HandleHelper::getAlarmStatusSeverityAsString(unsigned int _handle, std::string asas[2]) { #define __METHOD__ "HandleHelper::getAlarmStatusSeverityAsString(unsigned int _handle, string & *asas)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { asas[0]= (*it_handle).getAlarmStatusAsString(); asas[1]= (*it_handle).getAlarmSeverityAsString(); return ICAFE_NORMAL; } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return ECAFE_INVALID_HANDLE; } #undef __METHOD__ } /** * \brief Rerieves vector of handles for given vector of PVs * \param pvV input: vector of PVS * \return vector of handles */ std::vector HandleHelper::getHandlesFromPVs(std::vector pvV) { ca_client_context * ccc = ca_current_context(); return getHandlesFromPVs(pvV,ccc); } /** * \brief Rerieves vector of handles for given vector of PVs * \param pvV input: vector of PVS * \param ccc input: ca_client_context * * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ std::vector HandleHelper::getHandlesFromPVs(std::vector pvV, ca_client_context * ccc) { #define __METHOD__ "HandleHelper::getHandlesFromPVs()" vector handleV; handleV.reserve(pvV.size()); cafeConduit_set_by_pv & pv_index = cs.get (); cafeConduit_set_by_pv::iterator it_pv; for (unsigned int i=0; i0) { continue; // Channels within a group don't count! } if (!strcmp((*itcs).getPV(), pvV[i].c_str()) && (*itcs).getClientContext()== ccc) { handleV.push_back((*itcs).handle); break; } } handleV.push_back(0); } } //for return handleV; #undef __METHOD__ } /** * \brief Prints Conduit member values for all given handles * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::printHandlesV(std::vector handleV) { #define __METHOD__ "HandleHelper::printHandle(unsigned int)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; long lStatus=ICAFE_NORMAL; for (unsigned int i=0; i0) { cout << "groupHandle= " << (*it_handle).getGroupHandle() << endl; } else { cout << endl; } cout << "PV Name: " << (*it_handle).getPV() << endl; if ( strcmp((*it_handle).getPV(),(*it_handle).getPVAlias()) ) { cout << "PV Alias= " << (*it_handle).getPVAlias() << endl; } cout << "Data Type: " << cafeDataTypeCode.message((*it_handle).getChannelRegalia().dataType).c_str() << endl; cout << "Class Name: " << (*it_handle).getChannelRegalia().className << endl; cout << "cxt/chid: " << (*it_handle).getClientContext() <<"/"<<(*it_handle).getChannelID()<< endl; // "/"<< (*it_handle).uniqueID << endl; // Returns normal completion // cout << "status= " << cafeStatus.csi.message(cc.getStatus()) << endl; double p,g; PolicyHelper ph; ph.getTimeout((*it_handle).getHandle(),p,g); cout << "Timeouts put/get: " << p << "/" << g << " sec. " << endl; if ((*it_handle).getGroupHandle()>0) { cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find((*it_handle).getGroupHandle()); if (it_groupHandle != groupHandle_index.end()) { ph.getSGTimeout((*it_groupHandle).getGroupHandle(),p,g); cout << "Syn. Grp put/get: " << p << "/" << g << " sec. " << endl; } } cout << "isConnected?: " ; if ((*it_handle).isConnected()) { cout << "Yes" << endl; } else { cout << "No" << endl; } cout << "--------------------------------------------------" << endl; vector mids=getMonitorIDs((*it_handle).getHandle()); if (mids.size()>0) { cout << "Monitor ID: " ; for (unsigned int i=0; i< mids.size(); ++i) { cout << mids[i] << " " ; } cout << endl; } vector midsiw=getMonitorIDsInWaiting((*it_handle).getHandle()); if (midsiw.size()>0) { cout << "Monitors to start: " << midsiw.size() << endl; } } else { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << handleV[i] << " either never existed or no longer exists " << endl; lStatus=ECAFE_INVALID_HANDLE; } }//for return lStatus; #undef __METHOD__ } /** * \brief Prints Conduit member values for all given handles * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::printHandles(unsigned int * handleArray, unsigned int nHandles) { #define __METHOD__ "HandleHelper::printHandle(unsigned int)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; long lStatus=ICAFE_NORMAL; for (unsigned int i=0; i0) { cout << "groupHandle= " << (*it_handle).getGroupHandle() << endl; } else { cout << endl; } cout << "PV Name: " << (*it_handle).getPV() << endl; if ( strcmp((*it_handle).getPV(),(*it_handle).getPVAlias()) ) { cout << "PV Alias= " << (*it_handle).getPVAlias() << endl; } cout << "Data Type: " << cafeDataTypeCode.message((*it_handle).getChannelRegalia().dataType).c_str() << endl; cout << "Class Name: " << (*it_handle).getChannelRegalia().className << endl; cout << "cxt/chid: " << (*it_handle).getClientContext() <<"/"<<(*it_handle).getChannelID()<< endl; // "/"<< (*it_handle).uniqueID << endl; // Returns normal completion // cout << "status= " << cafeStatus.csi.message(cc.getStatus()) << endl; double p,g; PolicyHelper ph; ph.getTimeout((*it_handle).getHandle(),p,g); cout << "Timeouts put/get: " << p << "/" << g << " sec. " << endl; if ((*it_handle).getGroupHandle()>0) { cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find((*it_handle).getGroupHandle()); if (it_groupHandle != groupHandle_index.end()) { ph.getSGTimeout((*it_groupHandle).getGroupHandle(),p,g); cout << "Syn. Grp put/get: " << p << "/" << g << " sec. " << endl; } } //Find Group cout << "isConnected?: " ; if ((*it_handle).isConnected()) { cout << "Yes" << endl; } else { cout << "No" << endl; } vector mids=getMonitorIDs((*it_handle).getHandle()); if (mids.size()>0) { cout << "Monitor ID: " ; for (unsigned int i=0; i< mids.size(); ++i) { cout << mids[i] << " " ; } cout << endl; } vector midsiw=getMonitorIDsInWaiting((*it_handle).getHandle()); if (midsiw.size()>0) { cout << "Monitors to start: " << midsiw.size() << endl; } cout << "--------------------------------------------------" << endl; } else { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << handleArray[i] << " either never existed or no longer exists " << endl; lStatus=ECAFE_INVALID_HANDLE; } }//for return lStatus; #undef __METHOD__ } /** * \brief Prints Conduit member values for all given handle * \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE */ int HandleHelper::printHandle(unsigned int _handle) { #define __METHOD__ "HandleHelper::printHandle(unsigned int)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { cout << "--------------------------------------------------" << endl; cout << "HANDLE= " << (*it_handle).handle << " " ; if ((*it_handle).getGroupHandle()>0) { cout << "groupHandle= " << (*it_handle).getGroupHandle() << endl; } else { cout << endl; } cout << "PV Name: " << (*it_handle).getPV() << endl; if ( strcmp((*it_handle).getPV(),(*it_handle).getPVAlias()) ) { cout << "PV Alias= " << (*it_handle).getPVAlias() << endl; } cout << "Data Type: " << cafeDataTypeCode.message((*it_handle).getChannelRegalia().dataType).c_str() << endl; cout << "Class Name: " << (*it_handle).getChannelRegalia().className << endl; cout << "cxt/chid: " << (*it_handle).getClientContext() <<"/"<<(*it_handle).getChannelID()<< endl; // "/"<< (*it_handle).uniqueID << endl; // Returns normal completion // cout << "status= " << cafeStatus.csi.message(cc.getStatus()) << endl; double p,g; PolicyHelper ph; ph.getTimeout((*it_handle).getHandle(),p,g); cout << "Timeouts put/get: " << p << "/" << g << " sec. " << endl; if ((*it_handle).getGroupHandle()>0) { cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find((*it_handle).getGroupHandle()); if (it_groupHandle != groupHandle_index.end()) { ph.getSGTimeout((*it_groupHandle).getGroupHandle(),p,g); cout << "Syn. Grp put/get: " << p << "/" << g << " sec. " << endl; } } cout << "isConnected?: " ; if ((*it_handle).isConnected()) { cout << "Yes" << endl; } else { cout << "No" << endl; } vector mids=getMonitorIDs((*it_handle).getHandle()); if (mids.size()>0) { cout << "Monitor ID: " ; for (unsigned int i=0; i< mids.size(); ++i) { cout << mids[i] << " " ; } cout << endl; } vector midsiw=getMonitorIDsInWaiting((*it_handle).getHandle()); if (midsiw.size()>0) { cout << "Monitors to start: " << midsiw.size() << endl; } cout << "--------------------------------------------------" << endl; return ICAFE_NORMAL; } else { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } #undef __METHOD__ } /** * \brief Prints Conduit member values for all Conduit objects (handles) * \return Total number of handles; */ unsigned int HandleHelper::printHandles() { #define __METHOD__ "HandleHelper::printHandles" unsigned int noHandles = 0; // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if (noHandles==0) { cout << endl << "--------------------------------------------------" << endl; cout << " PRINTING ALL HANDLES " << endl; cout << "--------------------------------------------------" << endl; } cout << "--------------------------------------------------" << endl; cout << "HANDLE= " << (*itcs).handle << " " ; if ((*itcs).getGroupHandle()>0) { cout << "groupHandle= " << (*itcs).getGroupHandle() << endl; } else { cout << endl; } cout << "PV Name= " << (*itcs).getPV() << endl; if ( strcmp((*itcs).getPV(),(*itcs).getPVAlias()) ) { cout << "PV Alias= " << (*itcs).getPVAlias() << endl; } cout << "Data Type = " << cafeDataTypeCode.message((*itcs).getChannelRegalia().dataType).c_str() << endl; cout << "Class Name= " << (*itcs).getChannelRegalia().className << endl; cout << "cxt/chid: " << (*itcs).getClientContext() <<"/"<<(*itcs).getChannelID()<< endl; //"/"<< (*itcs).uniqueID << endl; // Returns normal completion // cout << "status= " << cafeStatus.csi.message(cc.getStatus()) << endl; double p,g; PolicyHelper ph; ph.getTimeout((*itcs).getHandle(),p,g); cout << "Timeouts put/get= " << p << "/" << g << " sec. " << endl; if ((*itcs).getGroupHandle()>0) { cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find((*itcs).getGroupHandle()); if (it_groupHandle != groupHandle_index.end()) { ph.getSGTimeout((*it_groupHandle).getGroupHandle(),p,g); cout << "Syc. Grp timeouts put/get: " << p << "/" << g << " sec. " << endl; } } cout << "isConnected?: " ; if ((*itcs).isConnected()) { cout << "Yes" << endl; } else { cout << "No" << endl; } vector mids=getMonitorIDs((*itcs).getHandle()); if (mids.size()>0) { cout << "Monitor ID: " ; for (unsigned int i=0; i< mids.size(); ++i) { cout << mids[i] << " "; } cout << endl; } vector midsiw=getMonitorIDsInWaiting((*itcs).getHandle()); if (midsiw.size()>0) { cout << "Monitors to start: " << midsiw.size() << endl; } cout << "--------------------------------------------------" << endl; ++noHandles; } if (noHandles==0) { cout << "--------------------------------------------------" << endl; cout << " THERE ARE NO HANDLES TO PRINT " << endl; cout << "--------------------------------------------------" << endl; } else { cout << "--------------------------------------------------" << endl; cout << " END PRINTING ALL HANDLES " << endl; cout << "--------------------------------------------------" << endl << endl; } std::cout.flush(); return noHandles; #undef __METHOD__ } /** * \brief Return a vector of handles that have monitors * If a handle has n monitors it appears n time in the return vector. * Monitors in waiting are als included in the count. * \return Total number of handles with monitors (whether started or in waiting); */ vector HandleHelper::getHandlesWithMonitors() { #define __METHOD__ "HandleHelper::getHandlesWithMonitors" vector handleV; handleV.clear(); handleV.reserve(cs.size()); // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { vector mids=getMonitorIDs((*itcs).getHandle()); vector midsiw=getMonitorIDsInWaiting((*itcs).getHandle()); if (mids.size()==0 && midsiw.size()==0) { continue; } for (unsigned int i=0; i mids=getMonitorIDs((*itcs).getHandle()); vector midsiw=getMonitorIDsInWaiting((*itcs).getHandle()); if (mids.size()==0 && midsiw.size()==0) { continue; } if (noHandles==0) { cout << endl << "--------------------------------------------------" << endl; cout << " PRINTING ALL HANDLES WITH MONITORS " << endl; cout << "--------------------------------------------------" << endl; } cout << "--------------------------------------------------" << endl; cout << "HANDLE= " << (*itcs).handle << " " ; if ((*itcs).getGroupHandle()>0) { cout << "groupHandle= " << (*itcs).getGroupHandle() << endl; } else { cout << endl; } cout << "PV Name= " << (*itcs).getPV() << endl; if ( strcmp((*itcs).getPV(),(*itcs).getPVAlias()) ) { cout << "PV Alias= " << (*itcs).getPVAlias() << endl; } cout << "Data Type = " << cafeDataTypeCode.message((*itcs).getChannelRegalia().dataType).c_str() << endl; cout << "Class Name= " << (*itcs).getChannelRegalia().className << endl; cout << "cxt/chid: " << (*itcs).getClientContext() <<"/"<<(*itcs).getChannelID()<< endl; //"/"<< (*itcs).uniqueID << endl; // Returns normal completion // cout << "status= " << cafeStatus.csi.message(cc.getStatus()) << endl; double p,g; PolicyHelper ph; ph.getTimeout((*itcs).getHandle(),p,g); cout << "Timeouts put/get= " << p << "/" << g << " sec. " << endl; cout << "isConnected?: " ; if ((*itcs).isConnected()) { cout << "Yes" << endl; } else { cout << "No" << endl; } cout << "Monitor ID: " ; for (unsigned int i=0; i< mids.size(); ++i) { cout << mids[i] << " "; } cout << endl; if (midsiw.size()>0) { cout << "Monitors to start: " << midsiw.size() << endl; } cout << "--------------------------------------------------" << endl; ++noHandles; } if (noHandles==0) { cout << "--------------------------------------------------" << endl; cout << " THERE ARE NO HANDLES TO PRINT " << endl; cout << "--------------------------------------------------" << endl; } else { cout << "--------------------------------------------------" << endl; cout << " END PRINTING ALL HANDLES " << endl; cout << "--------------------------------------------------" << endl << endl; } return noHandles; #undef __METHOD__ } /** * \brief Retrieves a list of handles and PVs, whether connected or disconnected * \param dhV output: Vector of all handles * \param pvV output: Vector of corresponding PVs * \return No of disconnected handles */ unsigned int HandleHelper::getHandles(std::vector &dhV, std::vector &pvV) { #define __METHOD__ "HandleHelper::getHandles(vector &dhV, vector &pvV)" dhV.clear(); pvV.clear(); dhV.reserve(cs.size()); pvV.reserve(cs.size()); // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { dhV.push_back((*itcs).handle); pvV.push_back((*itcs).getPV()); } return dhV.size(); #undef __METHOD__ } /** * \brief Retrieves a list of handles and PVs, whether connected or disconnected * \param dhV output: Vector of all handles * \param pvV output: Vector of corresponding PVs * \param connV output: Vector of connection states * \return No of disconnected handles */ unsigned int HandleHelper::getHandleStates(std::vector &dhV, std::vector &pvV, std::vector &connV) { #define __METHOD__ "HandleHelper::getHandleStates(vector &dhV, vector &pvV, vector &connV)" dhV.clear(); pvV.clear(); connV.clear(); dhV.reserve(cs.size()); pvV.reserve(cs.size()); connV.reserve(cs.size()); // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { dhV.push_back((*itcs).handle); pvV.push_back((*itcs).getPV()); connV.push_back( (unsigned short) (*itcs).isConnected()); } return dhV.size(); #undef __METHOD__ } /** * \brief Retrieves a list of connected PVs and their handles * \param dhV output: Vector of disconnected handles * \param pvV output: Vector of corresponding disconnected PVs * \return No of disconnected handles */ unsigned int HandleHelper::getConnectedHandles(std::vector &dhV, std::vector &pvV) { #define __METHOD__ "HandleHelper::getConnectedHandles()" dhV.clear(); pvV.clear(); dhV.reserve(cs.size()); pvV.reserve(cs.size()); // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if (!(*itcs).isConnected()) { continue; }; dhV.push_back((*itcs).handle); pvV.push_back((*itcs).getPV()); } return dhV.size(); #undef __METHOD__ } /** * \brief Retrieves a list of disconnected PVs and their handles * \param dhV output: Vector of disconnected handles * \param pvV output: Vector of corresponding disconnected PVs * \return No of disconnected handles */ unsigned int HandleHelper::getDisconnectedHandles(std::vector &dhV, std::vector &pvV) { #define __METHOD__ "HandleHelper::getDisconnectedHandles()" dhV.clear(); pvV.clear(); dhV.reserve(cs.size()); pvV.reserve(cs.size()); // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if ((*itcs).isConnected()) { continue; }; dhV.push_back((*itcs).handle); pvV.push_back((*itcs).getPV()); } return dhV.size(); #undef __METHOD__ } /** * \brief Prints Conduit member values for all disconnected CAFEConduit objects (handles) * \return Total number of disconnected handles; */ unsigned int HandleHelper::printDisconnectedHandles() { #define __METHOD__ "HandleHelper::printDisconnectedHandles" unsigned int noDisconnectedHandles = 0; // Loop through all elements and search for pv/ca_client_context match for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if ((*itcs).isConnected()) { continue; }; if (noDisconnectedHandles==0) { cout << endl << "--------------------------------------------------" << endl; cout << " DISCONNECTED HANDLES " << endl; cout << "--------------------------------------------------" << endl; } cout << "--------------------------------------------------" << endl; cout << "HANDLE= " << (*itcs).handle << " "; if ((*itcs).getGroupHandle()>0) { cout << "groupHandle= " << (*itcs).getGroupHandle() << endl; } else { cout << endl; } cout << "PV Name= " << (*itcs).getPV() << endl; if ( strcmp((*itcs).getPV(),(*itcs).getPVAlias()) ) { cout << "PV Alias= " << (*itcs).getPVAlias() << endl; } cout << "cxt/chid: " << (*itcs).getClientContext() <<"/"<<(*itcs).getChannelID()<< endl; //"/"<< (*itcs).uniqueID<< endl; // Returns normal completion // cout << "status= " << cafeStatus.csi.message((*itcs).getStatus()) << endl; cout << "isConnected?: " ; if ((*itcs).isConnected()) { cout << "Yes" << endl; } else { cout << "No" << endl; } vector mids=getMonitorIDs((*itcs).getHandle()); if (mids.size()>0) { cout << "Monitor ID: " ; for (unsigned int i=0; i< mids.size(); ++i) { cout << mids[i] << " " << endl; } } cout << "--------------------------------------------------" << endl; ++noDisconnectedHandles; } if (noDisconnectedHandles==0) { cout << "--------------------------------------------------" << endl; cout << " GOOD NEWS: THERE ARE NO DISCONNECTED HANDLES " << endl; cout << "--------------------------------------------------" << endl; } else { cout << "--------------------------------------------------" << endl; cout << " END DISCONNECTED HANDLES " << endl; cout << "--------------------------------------------------" << endl << endl; } return noDisconnectedHandles; #undef __METHOD__ } ////////////////////////////////////////////////////////////////////////////////////////////////// /** * \brief Sets the alarm, severity ts in conduit (used by get method WITH_CALLBACK) * \param _handle input: Conduit object reference * \param a input: alarm * \param s input: severity * \param ets input: epicsTimeStamp * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::setSTS(unsigned int _handle, dbr_short_t a, dbr_short_t s, epicsTimeStamp ets) { #define __METHOD__ "HandleHelper::setTS(unsigned int _handle, dbr_short_t a, dbr_short_t s, epicsTimeStamp ets)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_alarmStatus(a)); handle_index.modify(it_handle, change_alarmSeverity(s)); handle_index.modify(it_handle, change_epicsTimeStamp(ets)); if(MUTEX) { cafeMutex.unlock(); } } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return status; #undef __METHOD__ } /** * \brief Sets the cafeDbrType (e.g. DBR_TIME) and associated dbrDataTpe (e.g. DBR_TIME_zzz) * \param _handleV input: vector Conduit object references * \param cdt input: CAFENUM::DBR_TYPE * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::setCafeDbrTypeV(std::vector _handleV, CAFENUM::DBR_TYPE cdt ) { #define __METHOD__ "HandleHelper::setCafeDbrType(vector _handle, CAFENUM::DBR_TYPE cdt)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; int status=ICAFE_NORMAL; for (unsigned int i=0; i<_handleV.size(); ++i ) { it_handle = handle_index.find(_handleV[i]); if (it_handle != handle_index.end()) { channelRequestMetaDataClient=(*it_handle).getChannelRequestMetaDataClient(); channelRequestMetaDataClient.setDbrTypesFromCafeDbrType(cdt); channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); channelRequestMetaData.setDbrTypesFromCafeDbrType(cdt); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaDataClient( channelRequestMetaDataClient)); handle_index.modify(it_handle, change_channelRequestMetaData( channelRequestMetaData)); if(MUTEX) { cafeMutex.unlock(); } } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(status); cout << "Handle=" << _handleV[i] << " either never existed or no longer exists " << endl; } } } return status; #undef __METHOD__ } /** * \brief Sets the cafeDbrType (e.g. DBR_TIME) and associated dbrDataTpe (e.g. DBR_TIME_zzz) * \param _handle input: Conduit object reference * \param cdt input: CAFENUM::DBR_TYPE * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::setCafeDbrType(unsigned int _handle, CAFENUM::DBR_TYPE cdt ) { #define __METHOD__ "HandleHelper::setCafeDbrType(unsigned int _handle, CAFENUM::DBR_TYPE cdt)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { channelRequestMetaDataClient=(*it_handle).getChannelRequestMetaDataClient(); channelRequestMetaDataClient.setDbrTypesFromCafeDbrType(cdt); channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); channelRequestMetaData.setDbrTypesFromCafeDbrType(cdt); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaDataClient( channelRequestMetaDataClient)); handle_index.modify(it_handle, change_channelRequestMetaData( channelRequestMetaData)); if(MUTEX) { cafeMutex.unlock(); } } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return status; #undef __METHOD__ } /** * \brief Gets the cafeDbrType (e.g. DBR_TIME) * \param _handle input: Conduit object reference * \param cdt output: CAFENUM::DBR_TYPE * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::getCafeDbrType(unsigned int _handle, CAFENUM::DBR_TYPE &cdt ) { #define __METHOD__ "HandleHelper::getCafeDbrType(unsigned int _handle, CAFENUM::DBR_TYPE &cdt)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); cdt=channelRequestMetaData.getCafeDbrType(); } else { status=ECAFE_INVALID_HANDLE; cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } return status; #undef __METHOD__ } /** * \brief Gets the dataType requested (e.g. DBR_STRING etc.) * \param _handle input: Conduit object reference * \param rdt output: DBR_XXX * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::getDataTypeRequest(unsigned int _handle, chtype &rdt ) { #define __METHOD__ "HandleHelper::getDataTypeRequest(unsigned int _handle, chtype &rdt)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); rdt=channelRequestMetaData.getDataType(); } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return status; #undef __METHOD__ } /** * * \brief HandleHelper::addMonitorAction \n * * \param _handle input: handle identifying Conduit object * \param monitorAction input: string giviing the monitor action * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::addMonitorAction(unsigned int _handle, std::string monitorAction) { #define __METHOD__ "HandleHelper::addMonitorAction(unsigned int _handle, string monitorAction" cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_monitorAction(monitorAction)); } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * * \brief HandleHelper::clearMonitorAction for all handles \n * * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::clearMonitorAction() { #define __METHOD__ "HandleHelper::clearMonitorAction()" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus=clearMonitorAction( (*itcs).getHandle()); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * * \brief HandleHelper::clearMonitorAction \n * * \param _handle input: handle identifying Conduit object * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::clearMonitorAction(unsigned int _handle) { #define __METHOD__ "HandleHelper::clearMonitorAction(unsigned int _handle)" cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { handle_index.modify(it_handle, change_monitorActionClear()); } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * * \brief HandleHelper::eraseMonitorAction \n * * \param _handle input: handle identifying Conduit object * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::eraseMonitorAction(unsigned int _handle) { #define __METHOD__ "HandleHelper::eraseMonitorAction(unsigned int _handle)" vector msV; msV.clear(); msV.reserve(2); cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { msV=(*it_handle).getMonitorAction(); for (unsigned int i=0; i giving the monitor actions * \return ICAFE_NORMAL if OK else ECAFE_INVALID_HANDLE */ int HandleHelper::getMonitorAction(unsigned int _handle, std::vector & msV) { #define __METHOD__ "HandleHelper::getMonitorAction(unsigned int _handle, vector msV" msV.clear(); msV.reserve(2); cafeConduit_set_by_handle & handle_index = cs.get (); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { msV=(*it_handle).getMonitorAction(); return ICAFE_NORMAL; } else { cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; return ECAFE_INVALID_HANDLE; } #undef __METHOD__ } /** * * \brief HandleHelper::getMonitorAction retrieves list of actions to perform on change of value \n * If input boolean is true; then only oustantanding actions are listed * \param onlyIfNewData input: boolean to * \return string of actions */ vector HandleHelper::getMonitorAction(bool onlyIfNewData) { #define __METHOD__ "HandleHelper::getMonitorAction()" vector msActionV; msActionV.clear(); unsigned int nReserve=min( (unsigned int) cs.size(), (unsigned int) 50); msActionV.reserve(nReserve); //conservative std::vector::iterator pos; vector msLocal; // Loop through all elements and search for handles for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if ( ((*itcs).getHasNewData() && onlyIfNewData) || !onlyIfNewData) { msLocal.clear(); msLocal.reserve(2); msLocal=(*itcs).getMonitorAction(); //Add to global vector for (size_t i=0; i< msLocal.size(); ++i) { pos = find(msActionV.begin(), msActionV.end(), msLocal.begin()[i]); //No duplicates! if(pos==msActionV.end()) { msActionV.push_back(msLocal.begin()[i]); } } cafeConduit_set_by_handle & handle_index = cs.get (); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(itcs, change_hasNewData(false)); if(MUTEX) { cafeMutex.unlock(); } } } return msActionV; #undef __METHOD__ } /** * * \brief HandleHelper::getMonitorHandlesAndActions retrieves list of handles and * their actions to perform on change of value \n * \param handleV output: Vector of handles * \param actionV output: Vector of monitor actios * \return ICAFE_NORMAL */ int HandleHelper::getMonitorHandlesAndActions(std::vector & handleV, std::vector & actionV) { #define __METHOD__ "HandleHelper::getMonitorHandlesAndActions(&handleV, &actionV)" actionV.clear(); handleV.clear(); unsigned int nReserve=min( (unsigned int) cs.size(), (unsigned int) 50); actionV.reserve(nReserve); //conservative handleV.reserve(nReserve); //conservative // Loop through all elements and search for handles for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { //if Monitor check action vector mids=getMonitorIDs((*itcs).getHandle()); vector midsiw=getMonitorIDsInWaiting((*itcs).getHandle()); if (mids.size()==0 && midsiw.size()==0) { continue; } vector msV; HandleHelper::getMonitorAction((*itcs).getHandle(), msV); for (unsigned int i=0; imsV.size()) { handleV.push_back((*itcs).handle); actionV.push_back(""); } } return ICAFE_NORMAL; #undef __METHOD__ } int HandleHelper::updateMonitorPolicyDeltaMS(unsigned int _handle, unsigned int _monid, unsigned short _deltaMS) { cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { MonitorPolicy mp = (*it_handle).getMonitorPolicy(_monid); mp.setNotifyDeltaMilliSeconds(_deltaMS); if(MUTEX) { cafeMutex.lock();} handle_index.modify(it_handle, change_monitorPolicy(mp)); if(MUTEX) { cafeMutex.unlock();} } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return status; } /** * \brief Gets vector of MonitorIDs in waiting (value=0), i.e., waiting for channel connection * \param _handle input : Conduit object reference * \return returns vector of MonitorIDsInWaiting; length 0 is none or invalid handle */ vector HandleHelper::getMonitorIDsInWaiting(unsigned int _handle) { vector mpVec; mpVec.clear(); getMonitorPolicyInWaitingVector(_handle, mpVec); vector monidList; monidList.clear(); monidList.reserve(mpVec.size()); for (unsigned int i=0; i HandleHelper::getMonitorIDs(unsigned int _handle) { vector mpVec; mpVec.clear(); getMonitorPolicyVector(_handle, mpVec); vector monidList; monidList.clear(); monidList.reserve(mpVec.size()); for (unsigned int i=0; i mpVec; mpVec.clear(); getMonitorPolicyVector(_handle, mpVec); return mpVec.size(); } /** * \brief Gets Number of MonitorPolicyVectors for <= DBR_TIME type * \param _handle input : Conduit object reference * \return nmon output: No. of <= DBR_TIME type monitors * \return ICAFE_NORMAL else ECAFE_INVILID_HANDLE */ int HandleHelper::getNmonitorData(unsigned int _handle) { vector mpVec; mpVec.clear(); getMonitorPolicyVector(_handle, mpVec); unsigned int nmonData=0; //Loop mpVec for (unsigned int i=0; i mpVec; mpVec.clear(); getMonitorPolicyVector(_handle, mpVec); unsigned int nmonCtrl=0; //Loop mpVec for (unsigned int i=0; i= CAFENUM::DBR_GR && mpVec[i].getCafeDbrType()<= CAFENUM::DBR_CTRL) { ++nmonCtrl; } } return nmonCtrl; } /** * \brief Gets the MonitorPolicyVector * \param _handle input : Conduit object reference * \param mpV output: vector * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::getMonitorPolicyVector(unsigned int _handle, std::vector &mpV) { #define __METHOD__ \ "HandleHelper::getMonitorPolicyVector(unsigned int _handle, vector &mpV" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { mpV=(*it_handle).getMonitorPolicyVector(); } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return status; #undef __METHOD__ } /** * \brief Gets the MonitorPolicyVector * \param _handle input : Conduit object reference * \param mpV output: vector * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::getMonitorPolicyInWaitingVector(unsigned int _handle, std::vector &mpV) { #define __METHOD__ \ "HandleHelper::getMonitorPolicyInWaitingVector(unsigned int _handle, vector &mpV" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); int status=ICAFE_NORMAL; if (it_handle != handle_index.end()) { mpV=(*it_handle).getMonitorPolicyInWaitingVector(); } else { status=ECAFE_INVALID_HANDLE; if (printErrorPolicy.getInvalidHandle()) { cafeStatus.report(status); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return status; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an array, e.g. waveform, to native value for all handles * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int HandleHelper::setNelem() { #define __METHOD__ "HandleHelper::setNelem()" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus=setNelem( (*itcs).getHandle()); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an array, e.g. waveform, to native value * \param _handle input: Conduit object reference * \return no of elements else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::setNelem(unsigned int _handle) { #define __METHOD__ "HandleHelper::setNelem(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer=(*it_handle).getChannelRegalia().getNelem() ; nelemForDataTransfer= max(nelemForDataTransfer, (unsigned int) 1); // Should not really be needed channelRequestMetaDataClient=(*it_handle).getChannelRequestMetaDataClient(); channelRequestMetaDataClient.setNelem( nelemForDataTransfer ); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaDataClient( channelRequestMetaDataClient)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an array, e.g. waveform * \param _handle input: Conduit object reference * \param _nelem input: No of elements for ca data transfer * \return no of elements set = min( (*it_handle).getChannelRegalia().getNelem(),_nelem) * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::setNelem(unsigned int _handle, unsigned int _nelem) { #define __METHOD__ "HandleHelper::setNelem(unsigned int _handle, unsigned int _nelem)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= min( (*it_handle).getChannelRegalia().getNelem(),_nelem); nelemForDataTransfer= max(nelemForDataTransfer, (unsigned int) 1); channelRequestMetaDataClient=(*it_handle).getChannelRequestMetaDataClient(); channelRequestMetaDataClient.setNelem( nelemForDataTransfer ); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaDataClient( channelRequestMetaDataClient)); if(MUTEX) { cafeMutex.unlock(); } /* cout << __FILE__ << "//" << __METHOD__ << endl; cout << "handle " << _handle << endl; cout << "nelemForDataTransfer " << nelemForDataTransfer << endl; cout << "nelemClient" << getNelemClient (_handle) << endl; cout << "nelemNative" << getNelemNative (_handle) << endl; cout << "nelemRequest" << getNelemRequest(_handle) << endl; */ //Check on getNelemCache in channelRequestMetaData //Can't use this as this method is also used by set! //A set to a WF for one element then sets nelemCache to 1! /* channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); if (nelemForDataTransfer < channelRequestMetaData.getNelemCache() ) { channelRequestMetaData.setNelemCache( nelemForDataTransfer ); if(MUTEX){cafeMutex.lock();} handle_index.modify(it_handle, change_channelRequestMetaData( channelRequestMetaData)); if(MUTEX){cafeMutex.unlock();} } */ } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an cached array to native value, e.g. waveform * \param _handle input: Conduit object reference * \return no of elements (*it_handle).getChannelRegalia().getNelem() * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::setNelemToRetrieveFromCache (unsigned int _handle) { #define __METHOD__ "HandleHelper::setNelemToRetrieveFromCache(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= (*it_handle).getChannelRegalia().getNelem(); nelemForDataTransfer= max(nelemForDataTransfer, (unsigned int) 1); channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); //lessen the number if less in buffer nelemForDataTransfer= min(nelemForDataTransfer, channelRequestMetaData.getNelem()-channelRequestMetaData.getOffset()); channelRequestMetaData.setNelemCache( nelemForDataTransfer ); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaData( channelRequestMetaData)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an cached array, e.g. waveform * \param _handle input: Conduit object reference * \param _nelem input: No of elements for data transfer from cache * \return no of elements set = min( (*it_handle).getChannelRegalia().getNelem(),_nelem) * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::setNelemToRetrieveFromCache (unsigned int _handle, unsigned int _nelem) { #define __METHOD__ "HandleHelper::setNelemToRetrieveFromCache(unsigned int _handle, unsigned int _nelem)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= min( (*it_handle).getChannelRegalia().getNelem(),_nelem); nelemForDataTransfer= max(nelemForDataTransfer, (unsigned int) 1); channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); //lessen the number if less in buffer nelemForDataTransfer= min(nelemForDataTransfer,channelRequestMetaData.getNelem()-channelRequestMetaData.getOffset() ); channelRequestMetaData.setNelemCache( nelemForDataTransfer ); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaData( channelRequestMetaData)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an cached array to min(native, ) value, e.g. waveform * \param _handle input: Conduit object reference * \return no of elements (*it_handle).getChannelRegalia().getNelem() * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::setNelemToRetrieveFromCtrlCache (unsigned int _handle) { #define __METHOD__ "HandleHelper::setNelemToRetrieveFromCtrlCache(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= min(nelemForDataTransfer, MAX_NELEM_FOR_CTRL_BUFFER); nelemForDataTransfer= max(nelemForDataTransfer, (unsigned int) 1); channelRequestMetaCtrl=(*it_handle).getChannelRequestMetaCtrl(); //lessen the number if less in buffer nelemForDataTransfer= min(nelemForDataTransfer, channelRequestMetaCtrl.getNelem()-channelRequestMetaCtrl.getOffset()); channelRequestMetaCtrl.setNelemCache( nelemForDataTransfer ); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaCtrl( channelRequestMetaCtrl)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an cached array, e.g. waveform * \param _handle input: Conduit object reference * \param _nelem input: No of elements for data transfer from cache * \return no of elements set = min( (*it_handle).getChannelRegalia().getNelem(),_nelem) * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::setNelemToRetrieveFromCtrlCache (unsigned int _handle, unsigned int _nelem) { #define __METHOD__ "HandleHelper::setNelemToRetrieveFromCtrlCache(unsigned int _handle, unsigned int _nelem)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= min( (*it_handle).getChannelRegalia().getNelem(),_nelem); nelemForDataTransfer= min(nelemForDataTransfer, MAX_NELEM_FOR_CTRL_BUFFER); nelemForDataTransfer= max(nelemForDataTransfer, (unsigned int) 1); channelRequestMetaCtrl=(*it_handle).getChannelRequestMetaCtrl(); //lessen the number if less in buffer nelemForDataTransfer= min(nelemForDataTransfer, channelRequestMetaCtrl.getNelem()-channelRequestMetaCtrl.getOffset()); channelRequestMetaCtrl.setNelemCache( nelemForDataTransfer ); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaCtrl( channelRequestMetaCtrl)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Gets the no of elements to be read out from a cached array, e.g. waveform * \param _handle input: Conduit object reference * \return no of elements from channelRequestMetaData.getNelemCache(); * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::getNelemToRetrieveFromCache (unsigned int _handle) { #define __METHOD__ "HandleHelper::getNelemToRetrieveFromCache(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemFromCache=0; if (it_handle != handle_index.end()) { channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); //There may be less in buffer than requested //cout <<__METHOD__ << __LINE__ << endl; //cout << channelRequestMetaData.getNelemCache() << " // " << channelRequestMetaData.getNelem() << endl; nelemFromCache=min(channelRequestMetaData.getNelemCache(),channelRequestMetaData.getNelem()-channelRequestMetaData.getOffset()) ; } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemFromCache; #undef __METHOD__ } /** * \brief Gets the no of elements to be read out from a cached array, e.g. waveform * \param _handle input: Conduit object reference * \return no of elements set = min( (*it_handle).getChannelRegalia().getNelem(),_nelem) * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::getNelemToRetrieveFromCtrlCache (unsigned int _handle) { #define __METHOD__ "HandleHelper::getNelemToRetrieveFromCtrlCache(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemFromCache=0; if (it_handle != handle_index.end()) { channelRequestMetaCtrl=(*it_handle).getChannelRequestMetaCtrl(); //There may be less in buffer than requested nelemFromCache=min(channelRequestMetaCtrl.getNelemCache(),channelRequestMetaCtrl.getNelem()-channelRequestMetaCtrl.getOffset()) ; //nelemFromCache=channelRequestMetaCtrl.getNelemCache(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists " << endl; } } return nelemFromCache; #undef __METHOD__ } /** * \brief Retrieves the no of elements to read out from an array, e.g. waveform as requested by client * \param _handle input: Conduit object reference * \return no of elements from (*it_handle).getChannelRequestMetaDataClient().getNelem() * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::getNelemClient(unsigned int _handle) { #define __METHOD__ "HandleHelper::getNelem(unsigned int _handle, unsigned int _nelem)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= (*it_handle).getChannelRequestMetaDataClient().getNelem(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Retrieves the no of elements to read out from an array, e.g. waveform as delivered to ca * \param _handle input: Conduit object reference * \return no of elements from (*it_handle).getChannelRequestMetaData().getNelem() * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::getNelemRequest(unsigned int _handle) { #define __METHOD__ "HandleHelper::getNelemRequest(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= (*it_handle).getChannelRequestMetaData().getNelem(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Retrieves the no of native elements * \param _handle input: Conduit object reference * \return no of elements from (*it_handle).getChannelRegalia().getNelem() * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::getNelemNative(unsigned int _handle) { #define __METHOD__ "HandleHelper::getNelemNative(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= (*it_handle).getChannelRegalia().getNelem(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Retrieves the no of elements as initiated by client, no of native elements, * no of elements requested to ca * \param _handle input: Conduit object reference * \param c output: no of elements as stated by client * \param n output: no of native elements * \param r output: no of elements as requested to ca * \return ICAFE_NORMAL else ECAFE_INVALID_HANDLE */ int HandleHelper::getNelem(unsigned int _handle, unsigned int &c, unsigned int &n, unsigned int &r) { #define __METHOD__ "HandleHelper::getNelem(unsigned int _handle, client, native, request)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { c= (*it_handle).getChannelRequestMetaDataClient().getNelem(); n= (*it_handle).getChannelRegalia().getNelem(); r= (*it_handle).getChannelRequestMetaData().getNelem(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Retrieves the no of elements read out from an array * e.g. waveform, as delivered to ca through DBR_CTRL * \param _handle input: Conduit object reference * \return no of elements from (*it_handle).getChannelRequestMetaCtrl().getNelem() * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::getNelemRequestCtrl(unsigned int _handle) { #define __METHOD__ "HandleHelper::getNelemRequestCtrl(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= (*it_handle).getChannelRequestMetaCtrl().getNelem(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Retrieves the no of elements read out from an array * e.g. waveform, as delivered to ca through DBR_CTRL * \param _handle input: Conduit object reference * \return no of elements from (*it_handle).getChannelRequestMetaCtrl().getNelem() * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::getNelemClientCtrl(unsigned int _handle) { #define __METHOD__ "HandleHelper::getNelemClientCtrl(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= (*it_handle).getChannelRequestMetaCtrlClient().getNelem(); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Sets the no of elements to read out from an array, e.g. waveform, via DBR_CTRL * \param _handle input: Conduit object reference * \param _nelem input: No of elements for ca data transfer * \return no of elements set = min( (*it_handle).getChannelRegalia().getNelem(),_nelem) * else 0 if ECAFE_INVALID_HANDLE */ unsigned int HandleHelper::setNelemCtrl(unsigned int _handle, unsigned int _nelem) { #define __METHOD__ "HandleHelper::setNelemCtrl(unsigned int _handle, unsigned int _nelem)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int nelemForDataTransfer=0; if (it_handle != handle_index.end()) { nelemForDataTransfer= min( (*it_handle).getChannelRegalia().getNelem(),_nelem); nelemForDataTransfer= min(nelemForDataTransfer, MAX_NELEM_FOR_CTRL_BUFFER); nelemForDataTransfer= max(nelemForDataTransfer, (unsigned int) 1); //precaution channelRequestMetaCtrlClient=(*it_handle).getChannelRequestMetaCtrlClient(); channelRequestMetaCtrlClient.setNelem( nelemForDataTransfer ); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaCtrlClient( channelRequestMetaCtrlClient)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return nelemForDataTransfer; #undef __METHOD__ } /** * \brief Sets the offset; give element no from which data should be returned * \param _handle input: Conduit object reference * \param _offset input: Offset value * \return offset: min( (*it_handle).getChannelRegalia().getNelem()-1, _offset)) */ unsigned int HandleHelper::setOffset(unsigned int _handle, unsigned int _offset) { #define __METHOD__ "HandleHelper::setOffset(unsigned int _handle, unsigned int _offset)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int offsetForDataTransfer=0; if (it_handle != handle_index.end()) { offsetForDataTransfer= min( (*it_handle).getChannelRegalia().getNelem()-1, _offset); channelRequestMetaDataClient=(*it_handle).getChannelRequestMetaDataClient(); channelRequestMetaDataClient.setOffset( offsetForDataTransfer); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestMetaDataClient( channelRequestMetaDataClient)); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return offsetForDataTransfer; #undef __METHOD__ } /** * \brief Retrieves the offset; gives element no from which data should be returned * \param _handle input: Conduit object reference * \return offset: Offset valu */ unsigned int HandleHelper::getOffset(unsigned int _handle) { #define __METHOD__ "HandleHelper::getOffset(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int offsetForDataTransfer=0; if (it_handle != handle_index.end()) { channelRequestMetaDataClient=(*it_handle).getChannelRequestMetaDataClient(); offsetForDataTransfer=channelRequestMetaDataClient.getOffset( ); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return offsetForDataTransfer; #undef __METHOD__ } /** * \brief Retrieves the last offset; gives element no from which data was actually returned * \param _handle input: Conduit object reference * \return offset: Offset valu */ unsigned int HandleHelper::getOffsetLast(unsigned int _handle) { #define __METHOD__ "HandleHelper::getOffsetLast(unsigned int _handle)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); unsigned int offsetForDataTransfer=0; if (it_handle != handle_index.end()) { channelRequestMetaData=(*it_handle).getChannelRequestMetaData(); offsetForDataTransfer=channelRequestMetaData.getOffset( ); } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; } } return offsetForDataTransfer; #undef __METHOD__ } /** * \brief Retrieves groupHandle from groupName from within a given ca context * \param _groupName input: group Name * \param ccc input: ca client context * \return groupHandle else 0 if group not found */ unsigned int HandleHelper::getGroupHandleFromGroupName(const char * _groupName, ca_client_context * ccc) { #define __METHOD__ "HandleHelper::getGroupHandleFromGroupName" cafeGroup_set_by_groupName & groupName_index = gs.get (); cafeGroup_set_by_groupName::iterator it_groupName; it_groupName = groupName_index.find(_groupName); if (it_groupName != groupName_index.end()) { //std::cout << __METHOD__ << std::endl; //std::cout << ccc << " " << (*it_groupName).getClientContext() << std::endl; if (ccc == (*it_groupName).getClientContext()) { return (*it_groupName).groupHandle; } else { // Loop through all elements and search for pv/ca_client_context match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { //std::cout << __METHOD__ << std::endl; // std::cout << "overload-1 " << *itgs << " " << std:: endl; //std::cout << (*itgs).getClientContext() << std::endl; if (!strcmp((*itgs).getGroupName(), _groupName) && (*itgs).getClientContext() == ccc) { return (*itgs).groupHandle; } //Should we be closing from a thread (!!) else if (!strcmp((*itgs).getGroupName(), _groupName) && 0 == ccc) { return (*itgs).groupHandle; } } } } else { // Loop through all elements and search for pv/ca_client_context match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { if ((strcmp((*itgs).getGroupName(), _groupName) == 0) && ((*itgs).getClientContext() == ccc)) { cout << " MATCH FOUND Handle Number is= " << (*itgs).groupHandle << endl; return (*itgs).groupHandle; } } } return 0; //Handle Not found #undef __METHOD__ } /** * \brief Retrieves groupName from grouphanlde * \param _groupHandle input: handle to groupConduit object * \return groupName else "" if groupHandle not found */ std::string HandleHelper::getGroupNameFromGroupHandle(unsigned int _groupHandle) { #define __METHOD__ "HandleHelper::getGroupNameFromGroupHandle" cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_groupHandle); if (it_groupHandle != groupHandle_index.end()) { return (*it_groupHandle).groupName; } else { // Loop through all elements and search for grouphandle match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { //ConduitGroup cg = *itgs; if ((*itgs).getGroupHandle() == _groupHandle ) { // cout << " MATCH FOUND Handle Number is= " << (cg).groupHandle << endl; return (*itgs).groupName; } } } cafeStatus.report(ECAFE_UNKNOWN_GROUP); return ""; //GroupName Not found #undef __METHOD__ } /** * \brief Retrieves number of process variables within a group as identified by the groupHandle * \param _groupHandle input: handle to groupConduit object * \return number of PVs within group */ unsigned int HandleHelper::getGroupNPV(unsigned int _groupHandle) { #define __METHOD__ "HandleHelper::getGroupNPV(unsigned int)" cafeGroup_set_by_groupHandle & groupHandle_index = gs.get (); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_groupHandle); if (it_groupHandle != groupHandle_index.end()) { return (*it_groupHandle).getNMember(); } else { // Loop through all elements and search for grouphandle match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { if ((*itgs).getGroupHandle() == _groupHandle ) { // cout << " MATCH FOUND Handle Number is= " << (cg).groupHandle << endl; return (*itgs).getNMember(); } } } cafeStatus.report(ECAFE_UNKNOWN_GROUP); return 0; //GroupHandle Not found #undef __METHOD__ } /** * \brief Retrieves number of process variables within a group for a given ca client context * \param _groupName input: name of CAFAE PVGroup * \param ccc input: ca_client_context * \return number of PVs within group */ unsigned int HandleHelper::getGroupNPV(const char * _groupName, ca_client_context * ccc) { #define __METHOD__ "HandleHelper::getGroupNPV" cafeGroup_set_by_groupName & groupName_index = gs.get (); cafeGroup_set_by_groupName::iterator it_groupName; it_groupName = groupName_index.find(_groupName); if (it_groupName != groupName_index.end()) { if (ccc == (*it_groupName).getClientContext()) { return (*it_groupName).getNMember(); } else { // Loop through all elements and search for pv/ca_client_context match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { //cout << "overload-1 " << *itgs << " " << (*itgs).getClientContext() << endl; if (!strcmp((*itgs).getGroupName(), _groupName) && (*itgs).getClientContext() == ccc) { return (*itgs).getNMember(); } } } } else { // Loop through all elements and search for pv/ca_client_context match for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { if ((strcmp((*itgs).getGroupName(), _groupName) == 0) && ((*itgs).getClientContext() == ccc)) { // cout << " MATCH FOUND Handle Number is= " << (*itgs).groupHandle << endl; return (*itgs).getNMember(); } } } return 0; //Handle Not found #undef __METHOD__ } /** * \brief Sets the buffer size for map for use in cafe bsread for all handles * \param _bufferSize input: bufferSize value * \return ICAFE_NORMAL */ int HandleHelper::setMapPulseIDBufferSizeAll(unsigned short _bufferSize) { #define __METHOD__ "HandleHelper::setMapPulseIDBufferSize(unsigned short _bufferSize)" cafeConduit_set_by_handle & handle_index=cs.get(); // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if(MUTEX) { cafeMutex.lock(); } handle_index.modify(itcs, change_mapPulseIDBufferSize( std::max(1,(int)_bufferSize))); if(MUTEX) { cafeMutex.unlock(); } } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Sets the buffer size for map for use in cafe bsread * \param _handle input: Conduit object reference * \param _bufferSize input: bufferSize value * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int HandleHelper::setMapPulseIDBufferSize(unsigned int _handle, unsigned short _bufferSize) { #define __METHOD__ "HandleHelper::setMapPulseIDBufferSize(unsigned int _handle, unsigned short _bufferSize)" cafeConduit_set_by_handle & handle_index=cs.get(); cafeConduit_set_by_handle::iterator it_handle; it_handle = handle_index.find(_handle); if (it_handle != handle_index.end()) { if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_mapPulseIDBufferSize( std::max(1,(int)_bufferSize))); if(MUTEX) { cafeMutex.unlock(); } } else { if (printErrorPolicy.getInvalidHandle()) { cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl; cafeStatus.report(ECAFE_INVALID_HANDLE); cout << "Handle=" << _handle << " either never existed or no longer exists! " << endl; return ECAFE_INVALID_HANDLE; } } return ICAFE_NORMAL; #undef __METHOD__ }