/// /// \file policyHelper.cpp /// \author Jan Chrin, PSI /// \date Release: February 2015 /// \version CAFE 1.0.0 /// #include #include using namespace std; ////////////////////////////////// REQUEST POLICIES /////////////////////////////////////////////////////////// /** * \brief PolicyHelper::getChannelGetCacheWaitPolicy \n * Retrieves ChannelGetCacheWaitPolicy object whose method getWhenKind() \n * determines if ChannelGetCacheWaitPolicyKind CAFENUM::GET_CACHE_NO_WAIT * or CAFENUM::GET_CACHE_WAIT \n * \param _handle input: reference handle * \param cwp output: ChannelGetCacheWaitPolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::getChannelGetCacheWaitPolicy(unsigned int _handle, ChannelGetCacheWaitPolicy & cwp) { #define __METHOD__ "policyHelper::getChannelGetCacheWaitPolicy(handle, ChannelGetCacheWaitPolicy & cwp)" 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()) { cwp=(*it_handle).getChannelGetCacheWaitPolicy(); } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelGetCacheWaitPolicy \n * Sets ChannelGetCacheWaitPolicy object whose method getWhenKind() \n * determines if ChannelGetCacheWaitPolicyKind CAFENUM::GET_CACHE_NO_CHECK * CAFENUM::GET_CACHE_NO_WAIT or CAFENUM::GET_CACHE_WAIT \n * \param _handle input: reference handle * \param cwp input: ChannelGetCacheWaitPolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::setChannelGetCacheWaitPolicy(unsigned int _handle, ChannelGetCacheWaitPolicy cwp) { #define __METHOD__ "policyHelper:setChannelGetCacheWaitPolicy(handle, ChannelGetCacheWaitPolicy cwp)" 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 (cwp.getWaitKind() < CAFENUM::GET_CACHE_NO_CHECK || cwp.getWaitKind() > CAFENUM::GET_CACHE_WAIT) { cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; cout << "Handle= "<< (*it_handle).getHandle() << " PV= " << (*it_handle).getPV() << endl; cout << cwp.getWaitKind() << " is an unknown policy!" << endl; cout << "Valid types are GET_CACHE_NO_CHECK(0) GET_CACHE_NO_WAIT(1) or GET_CACHE_WAIT(2)" << endl; return ECAFE_INVALID_CAFENUM_POLICY_TYPE; } if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelGetCacheWaitPolicy(cwp)); if(MUTEX) { cafeMutex.unlock(); } } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelGetCacheWaitPolicy \n * Sets the ChannelGetCacheWaitPolicy object (for all handles) whose method getWhenKind() \n * determines if ChannelGetCacheWaitPolicyKind CAFENUM::GET_CACHE_NO_CEHCK * CAFENUM::GET_CACHE_NO_WAIT or CAFENUM::GET_CACHE_WAIT \n * \param cwp input: ChannelGetCacheWaitPolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::setChannelGetCacheWaitPolicy( ChannelGetCacheWaitPolicy cwp) { #define __METHOD__ "policyHelper:setChannelGetCacheWaitPolicy(ChannelGetCacheWaitPolicy cwp)" int localStatus=ICAFE_NORMAL; int gStatus=ICAFE_NORMAL; bool sflag=false; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus= setChannelGetCacheWaitPolicy ((*itcs).getHandle(), cwp); if (localStatus !=ICAFE_NORMAL && !sflag) { gStatus=localStatus; sflag=true; } } return gStatus; #undef __METHOD__ } /** * \brief PolicyHelper::getChannelGetActionWhenMonitorPolicy \n * Retrieves ChannelGetActionWhenMonitorPolicy object whose method getWhenKind() \n * determines if ChannelGetActionWhenMonitorPolicyKind CAFENUM::GET_FROM_CACHE * or CAFENUM::GET_FROM_IOC \n * \param _handle input: reference handle * \param awmp output: ChannelGetActionWhenMonitorPolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::getChannelGetActionWhenMonitorPolicy(unsigned int _handle, ChannelGetActionWhenMonitorPolicy & awmp) { #define __METHOD__ "policyHelper::getChannelGetActionWhenMonitorPolicy(handle, ChannelGetActionWhenMonitorPolicy & awmp)" 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()) { awmp=(*it_handle).getChannelGetActionWhenMonitorPolicy(); } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelGetActionWhenMonitorPolicy \n * Retrieves ChannelGetActionWhenMonitorPolicy object whose method getWhenKind() \n * determines if ChannelGetActionWhenMonitorPolicyKind CAFENUM::GET_FROM_CACHE * CAFENUM::GET_FROM_IOC \n * \param _handle input: reference handle * \param awmp input: ChannelGetActionWhenMonitorPolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::setChannelGetActionWhenMonitorPolicy(unsigned int _handle, ChannelGetActionWhenMonitorPolicy awmp) { #define __METHOD__ "policyHelper::setChannelGetActionWhenMonitorPolicy(handle, ChannelGetActionWhenMonitorPolicy awmp)" 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 (awmp.getActionKind()!=CAFENUM::GET_FROM_CACHE && awmp.getActionKind()!=CAFENUM::GET_FROM_IOC) { cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; cout << "Handle= "<< (*it_handle).getHandle() << " PV= " << (*it_handle).getPV() << endl; cout << awmp.getActionKind() << " is an unknown policy!" << endl; cout << "Valid types are: GET_FROM_CACHE (0) or GET_FROM_IOC (1)" << endl; return ECAFE_INVALID_CAFENUM_POLICY_TYPE; } if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelGetActionWhenMonitorPolicy(awmp)); if(MUTEX) { cafeMutex.unlock(); } } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelGetActionWhenMonitorPolicy \n * Retrieves ChannelGetActionWhenMonitorPolicy object (for all handles) whose method getWhenKind() \n * determines if ChannelGetActionWhenMonitorPolicyKind CAFENUM::GET_FROM_CACHE * or CAFENUM::GET_FROM_IOC \n * \param awmp input: ChannelGetActionWhenMonitorPolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::setChannelGetActionWhenMonitorPolicy(ChannelGetActionWhenMonitorPolicy awmp) { #define __METHOD__ "policyHelper::setChannelGetActionWhenMonitorPolicy(ChannelGetActionWhenMonitorPolicy awmp)" int localStatus=ICAFE_NORMAL; int gStatus=ICAFE_NORMAL; bool sflag=false; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus= setChannelGetActionWhenMonitorPolicy ((*itcs).getHandle(), awmp); if (localStatus !=ICAFE_NORMAL && !sflag) { gStatus=localStatus; sflag=true; } } return gStatus; #undef __METHOD__ } /** * \brief PolicyHelper::getChannelRequestDataTypePolicy \n * Retrieves ChannelRequestDataTypePolicy object whose method getRequestKind() \n * determines if ChannelRequestDataTypePolicyKind CAFENUM::NATIVE_DATATYPE * or CAFENUM::LOWEST_DATATYPE, \n * which is the smaller in byte size of type requested and native datatype, \n * is being used for get/set operations * \param _handle input: reference handle * \param crdtp output: ChannelRequestDataTypePolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::getChannelRequestDataTypePolicy(unsigned int _handle, ChannelRequestDataTypePolicy & crdtp) { #define __METHOD__ "policyHelper::getChannelRequestDataTypePolicy(handle, ChannelRequestDataTypePolicy & crdtp)" 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()) { crdtp=(*it_handle).getChannelRequestDataTypePolicy(); } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelRequestDataTypePolicy \n * * Sets ChannelRequestDataTypePolicy object (for all handles) whose \n * method setRequestKind(ChannelRequestDataTypePolicyKind) \n * determines if CAFENUM::NATIVE_DATATYPE or CAFENUM::LOWEST_DATATYPE, \n * which is the smaller in byte size of type requested and native datatype, \n * is being used for get/set operations * \param crdtp input: ChannelRequestDataTypePolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::setChannelRequestDataTypePolicy(ChannelRequestDataTypePolicy crdtp) { #define __METHOD__ "policyHelper::setChannelRequestDataTypePolicy(ChannelRequestDataTypePolicy crdtp)" int localStatus=ICAFE_NORMAL; int gStatus=ICAFE_NORMAL; bool sflag=false; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus= setChannelRequestDataTypePolicy ((*itcs).getHandle(), crdtp); if (localStatus !=ICAFE_NORMAL && !sflag) { gStatus=localStatus; sflag=true; } } return gStatus; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelRequestDataTypePolicy \n * * Sets ChannelRequestDataTypePolicy object whose method \n * setRequestKind(ChannelRequestDataTypePolicyKind) \n * determines if CAFENUM::NATIVE_DATATYPE or CAFENUM::LOWEST_DATATYPE, \n * which is the smaller in byte size of type requested and native datatype, \n * is being used for get/set operations * \param _handle input: reference handle * \param crdtp input: ChannelRequestDataTypePolicy object * \return status ICAFE_NORMAL else ECAFE_INVALID_HANDLE * */ int PolicyHelper::setChannelRequestDataTypePolicy(unsigned int _handle, ChannelRequestDataTypePolicy crdtp) { #define __METHOD__ "policyHelper::setChannelRequestDataTypePolicy(handle, ChannelRequestDataTypePolicy crdtp)" 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 (crdtp.getRequestKind()!=CAFENUM::NATIVE_DATATYPE && crdtp.getRequestKind()!=CAFENUM::LOWEST_DATATYPE) { cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; cout << "Handle= "<< (*it_handle).getHandle() << " PV= " << (*it_handle).getPV() << endl; cout << crdtp.getRequestKind() << " is an unknown policy!" << endl; cout << "Valid types are: NATIVE_DATATYPE (0) or LOWEST_DATATYPE (1)" << endl; return ECAFE_INVALID_CAFENUM_POLICY_TYPE; } if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestDataTypePolicy(crdtp)); if(MUTEX) { cafeMutex.unlock(); } } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::getChannelRequestPolicyGet \n * * Retrieves the Callback Policy for get operations * * \param _handle input: reference handle * \param crpg output: ChannelRequestPolicyGet object * \return status ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE * */ int PolicyHelper::getChannelRequestPolicyGet(unsigned int _handle, ChannelRequestPolicy & crpg) { #define __METHOD__ "policyHelper::getChannelRequestPolicyGet(unsigned int handle, ChannelRequestPolicy & crpg)" 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()) { crpg=(*it_handle).getChannelRequestPolicyGet(); } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelRequestPolicyGet \n * * Sets the Blocking Policy for get operations * * \param _handle input: reference handle * \param crpg input: Channel.RequestPolicyGet object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::setChannelRequestPolicyGet(unsigned int _handle, ChannelRequestPolicy crpg) { #define __METHOD__ "policyHelper::setChannelRequestPolicyGet(unsigned int handle, ChannelRequestPolicy crpg)" int status=ICAFE_NORMAL; 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 (crpg.getMethodKind()==WITH_CALLBACK_USER_SUPPLIED && crpg.getHandler()==NULL) { crpg.setMethodKind(WITH_CALLBACK_DEFAULT); status=ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT; cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << " Policy Conflict!" << endl; cout << "Handle= "<< (*it_handle).getHandle() << " PV= " << (*it_handle).getPV() << endl; cout << "Changing ChannelRequestPolicyGet methodKind from WITH_CALLBACK_USER_SUPPLIED " << endl; cout << "to WITH_CALLBACK_DEFAULT as user supplied handler is NULL!" << endl; } if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelRequestPolicyGet(crpg)); if(MUTEX) { cafeMutex.unlock(); } } else { return ECAFE_INVALID_HANDLE; } return status; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelRequestPolicyGet \n * * Sets the Blocking Policy for all handles within context * * \param crpg input: Channel.RequestPolicyGet object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::setChannelRequestPolicyGet(ChannelRequestPolicy crpg) { #define __METHOD__ "policyHelper::setChannelRequestPolicyGet(ChannelRequestPolicy crpg)" int status=ICAFE_NORMAL; cafeConduit_set_by_handle & handle_index = cs.get (); // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if (crpg.getMethodKind()==WITH_CALLBACK_USER_SUPPLIED && crpg.getHandler()==NULL) { crpg.setMethodKind(WITH_CALLBACK_DEFAULT); status=ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT; cout << "Handle= "<< (*itcs).getHandle() << " PV= " << (*itcs).getPV() << endl; cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << " Policy Conflict!" << endl; cout << "Changing ChannelRequestPolicyGet BlockingKind from WITH_CALLBACK_USER_SUPPLIED " << endl; cout << "to WITH_CALLBACK_DEFAULT as user supplied handler is NULL!" << endl; } if(MUTEX) { cafeMutex.lock(); } handle_index.modify(itcs, change_channelRequestPolicyGet(crpg)); if(MUTEX) { cafeMutex.unlock(); } } return status; #undef __METHOD__ } /** * \brief PolicyHelper::getChannelRequestPolicyPut \n * * Retrieves the Blocking Policy for put operations * * \param _handle input: reference handle * \param crpp output: ChannelRequestPolicyPut object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::getChannelRequestPolicyPut(unsigned int _handle, ChannelRequestPolicy & crpp) { #define __METHOD__ "PolicyHelper::getChannelRequestPolicyPut(unsigned int handle, ChannelRequestPolicy & crpp)" 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()) { crpp=(*it_handle).getChannelRequestPolicyPut(); } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelRequestPolicyPut \n * * Sets the Blocking Policy for put operations * * \param _handle input: reference handle * \param crpp input: ChannelRequestPolicyPut object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::setChannelRequestPolicyPut(unsigned int _handle, ChannelRequestPolicy crpp) { #define __METHOD__ "PolicyHelper::getChannelRequestPolicyPut(unsigned int handle, ChannelMethodRequesyPolicy crpp)" int status=ICAFE_NORMAL; 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 (crpp.getMethodKind()==WITH_CALLBACK_USER_SUPPLIED && crpp.getHandler()==NULL) { crpp.setMethodKind(WITH_CALLBACK_DEFAULT); status=ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT; cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << " Policy Conflict!" << endl; cout << "Handle= "<< (*itcs).getHandle() << " PV= " << (*itcs).getPV() << endl; cout << "Changing ChannelRequestPolicyPut BlockingKind from WITH_CALLBACK_USER_SUPPLIED " << endl; cout << "to WITH_CALLBACK_DEFAULT as user supplied handler is NULL!" << endl; } if(MUTEX)cafeMutex.lock(); handle_index.modify(it_handle, change_channelRequestPolicyPut(crpp)); if(MUTEX)cafeMutex.unlock(); } else { return ECAFE_INVALID_HANDLE; } return status; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelRequestPolicyPut\n * * Sets the Blocking Policy for put operations * * \param crpp input: ChannelRequestPolicyPut object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::setChannelRequestPolicyPut(ChannelRequestPolicy crpp) { #define __METHOD__ "PolicyHelper::getChannelRequestPolicyPut(ChannelMethodRequesyPolicy crpp)" cafeConduit_set_by_handle & handle_index = cs.get (); int status=ICAFE_NORMAL; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { if (crpp.getMethodKind()==WITH_CALLBACK_USER_SUPPLIED && crpp.getHandler()==NULL) { crpp.setMethodKind(WITH_CALLBACK_DEFAULT); status=ICAFE_CHANNEL_BLOCKING_POLICY_CONFLICT; cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << " Policy Conflict!" << endl; cout << "Handle= "<< (*itcs).getHandle() << " PV= " << (*itcs).getPV() << endl; cout << "Changing ChannelRequestPolicyPut BlockingKind from WITH_CALLBACK_USER_SUPPLIED " << endl; cout << "to WITH_CALLBACK_DEFAULT as user supplied handler is NULL!" << endl; } if(MUTEX)cafeMutex.lock(); handle_index.modify(itcs, change_channelRequestPolicyPut(crpp)); if(MUTEX)cafeMutex.unlock(); } return status; #undef __METHOD__ } ////////////////////////////////// TIMEOUTS /////////////////////////////////////////////////////////// /** * \brief PolicyHelper::getChannelTimeoutPolicyGet \n * * Retrieves the Timeout Policy for get operations * * \param _handle input: reference handle * \param ctpg output: ChannelTimeoutPolicyGet object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::getChannelTimeoutPolicyGet(unsigned int _handle, ChannelTimeoutPolicy & ctpg) { #define __METHOD__ "PolicyHelper::getChannelTimeoutPolicyGet(unsigned int handle, ChannelTimeoutPolicy & ctpg)" 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()) { ctpg=(*it_handle).getChannelTimeoutPolicyGet(); } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelTimeoutPolicyGet \n * * Sets the Timeout Policy for put operations * * \param _handle input: reference handle * \param ctpg input: ChannelTimeoutPolicyGet object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::setChannelTimeoutPolicyGet(unsigned int _handle, ChannelTimeoutPolicy ctpg) { #define __METHOD__ "PolicyHelper::getChannelTimeoutPolicyGet(unsigned int handle, ChannelTimeoutPolicy ctpg)" 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_channelTimeoutPolicyGet(ctpg)); if(MUTEX) { cafeMutex.unlock(); } } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::getChannelTimeoutPolicyPut \n * * Retrieves the Timeout Policy for put operations * * \param _handle input: reference handle * \param ctpp output: ChannelTimeoutPolicyPut object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::getChannelTimeoutPolicyPut(unsigned int _handle, ChannelTimeoutPolicy & ctpp) { #define __METHOD__ "PolicyHelper::getChannelTimeoutPolicyPut(unsigned int handle, ChannelTimeoutPolicy & cptp)" 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()) { ctpp=(*it_handle).getChannelTimeoutPolicyPut(); } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief PolicyHelper::setChannelTimeoutPolicyPut \n * * Sets the Timout Policy for put operations * * \param _handle input: reference handle * \param ctpp input: ChannelTimeoutPolicyPut object * \return status ICAFE_NORMAL if all OK * */ int PolicyHelper::setChannelTimeoutPolicyPut(unsigned int _handle, ChannelTimeoutPolicy ctpp) { #define __METHOD__ "PolicyHelper::setChannelTimeoutPolicyPut(unsigned int handle, ChannelTimeoutPolicy cptp)" 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_channelTimeoutPolicyPut(ctpp)); if(MUTEX) { cafeMutex.unlock(); } } else { return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /////////////////////////////////////// TIMOUT HELPERS ///////////////////////////////////////////// /** * \brief Allows user to set the policy that governs the corrective adaption of timeouts for put/get operations * for all handles * \param b input: bool * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSelfGoverningTimeout(bool b) { #define __METHOD__ "PolicyHelper::setSelfGoverningTimout(bool b)" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus=setSelfGoverningTimeout((*itcs).getHandle(),b); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * \brief Allows user to set the policy that governs the corrective adaption of timeouts for put/get operations * for a given handle * \param _handle input: Conduit object reference * \param b input: bool * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSelfGoverningTimeout(unsigned int _handle, bool b) { #define __METHOD__ "PolicyHelper::setSelfGoverningTimeout(unsigned int _handle, bool b)" 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()) { ChannelTimeoutPolicy ctp=(*it_handle).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*it_handle).getChannelTimeoutPolicyGet(); ctp.setSelfGoverningTimeout(b); ctg.setSelfGoverningTimeout(b); if(MUTEX)cafeMutex.lock(); handle_index.modify(it_handle, change_channelTimeoutPolicyPut(ctp)); handle_index.modify(it_handle, change_channelTimeoutPolicyGet(ctg)); if(MUTEX)cafeMutex.unlock(); } else { cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to rerieve the policy that governs the corrective adaption of timeouts for put/get operations * for a given handle * \param _handle input: Conduit object reference * \param p output: bool for put operations * \param g output: bool for get operations * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::getSelfGoverningTimeout(unsigned int _handle, bool &p, bool &g) { #define __METHOD__ "PolicyHelper::setSelfGoverningTimeout(unsigned int _handle, bool &p, bool &g)" 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()) { ChannelTimeoutPolicy ctp=(*it_handle).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*it_handle).getChannelTimeoutPolicyGet(); p=ctp.getSelfGoverningTimeout(); g=ctg.getSelfGoverningTimeout(); } else { p=false; g=false; cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to set the policy that governs the corrective adaption of timeouts for put operations * for a given handle * \param _handle input: Conduit object reference * \param b input: bool * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSelfGoverningTimeoutPut(unsigned int _handle, bool b) { #define __METHOD__ "PolicyHelper::setSelfGoverningTimeoutPut(unsigned int _handle, bool b)" 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()) { ChannelTimeoutPolicy ctp=(*it_handle).getChannelTimeoutPolicyPut(); ctp.setSelfGoverningTimeout(b); if(MUTEX)cafeMutex.lock(); handle_index.modify(it_handle, change_channelTimeoutPolicyPut(ctp)); if(MUTEX)cafeMutex.unlock(); } else { cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to set the policy that governs the corrective adaption of timeouts for get operations * for a given handle * \param _handle input: Conduit object reference * \param b input: bool * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSelfGoverningTimeoutGet(unsigned int _handle, bool b) { #define __METHOD__ "PolicyHelper::setSelfGoverningTimeoutGet(unsigned int _handle, bool b)" 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()) { ChannelTimeoutPolicy ctg=(*it_handle).getChannelTimeoutPolicyGet(); ctg.setSelfGoverningTimeout(b); if(MUTEX)cafeMutex.lock(); handle_index.modify(it_handle, change_channelTimeoutPolicyGet(ctg)); if(MUTEX)cafeMutex.unlock(); } else { cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to retrieve timeout for put/get operations \n * \param _handle input: Conduit object reference * \param p output: put timeout * \param g output: get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::getTimeout(unsigned int _handle, double & p, double & g) { #define __METHOD__ "PolicyHelper::getTimeout(unsigned int _handle, double &p, double &g)" 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()) { ChannelTimeoutPolicy ctp=(*it_handle).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*it_handle).getChannelTimeoutPolicyGet(); p=ctp.getTimeout(); g=ctg.getTimeout(); } else { cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to retrieve minimum timeout for put/get operations * \param p: output: put timeout * \param g: output: get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::getTimeoutMin(double & p, double & g) { #define __METHOD__ "PolicyHelper::getTimeoutMin(double &p, double &g)" double a=TIMEOUT_PEND_IO_MAX ; double b=TIMEOUT_PEND_IO_MAX ; bool isFound=false; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { ChannelTimeoutPolicy ctp=(*itcs).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*itcs).getChannelTimeoutPolicyGet(); a=std::min(a,ctp.getTimeout()); b=std::min(b,ctg.getTimeout()); isFound=true; } if (isFound) { p=a; g=b; } else { p=DEFAULT_TIMEOUT_PEND_IO; g=DEFAULT_TIMEOUT_PEND_IO; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to retrieve minimum timeout for put/get operations * \param p: output: put timeout * \param g: output: get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::getTimeoutMax(double & p, double & g) { #define __METHOD__ "PolicyHelper::getTimeoutMin(double &p, double &g)" double a=TIMEOUT_PEND_IO_MIN ; double b=TIMEOUT_PEND_IO_MIN; bool isFound=false; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { ChannelTimeoutPolicy ctp=(*itcs).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*itcs).getChannelTimeoutPolicyGet(); a=std::max(a,ctp.getTimeout()); b=std::max(b,ctg.getTimeout()); isFound=true; } if (isFound) { p=a; g=b; } else { p=DEFAULT_TIMEOUT_PEND_IO; g=DEFAULT_TIMEOUT_PEND_IO; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Prints timeout for put/get operations * \return ICAFE_NORMAL */ int PolicyHelper::printTimeout() { #define __METHOD__ "PolicyHelper::printTimeout()" short pvstrl=0; for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { pvstrl=std::max(pvstrl,(short) (*itcs).pv.length()); } string spv="Process Variable Name"; cout << "---------------------TIMEOUTS---------------------" << endl; printf("%s %s %*s %s %s\n", "Hndle",spv.c_str(), std::max((int) (pvstrl-spv.length()),(int) 0),"","PUTtim","GETtim"); // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { ChannelTimeoutPolicy ctp=(*itcs).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*itcs).getChannelTimeoutPolicyGet(); //cout << std::setw(40) << cc.pv << std::setw(3) << cc.getHandle() // << std::setw(10) << ctp.getTimeout() // << std::setw(10) << ctg.getTimeout() << endl; printf("%5d %s %*s %6.3f %6.3f\n", (*itcs).getHandle(),(*itcs).pv.c_str(), std::max((int) (pvstrl-(*itcs).pv.length()),(int) 0),"", ctp.getTimeout(), ctg.getTimeout() ) ; } cout << "--------------------------------------------------" << endl; return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Prints timeout for put/get operations for given handle * \param _handle input: handle to Conduit Object * \return ICAFE_NORMAL */ int PolicyHelper::printTimeout(unsigned int _handle) { #define __METHOD__ "PolicyHelper::printTimeout(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()) { //Conduit cc=(*it_handle); ChannelTimeoutPolicy ctp=(*it_handle).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*it_handle).getChannelTimeoutPolicyGet(); string spv="Process Variable Name"; int wantedl= std::max(28,(int) (*it_handle).pv.length()); printf("%s %s %*s %s %s\n", "Handle",spv.c_str(), std::max((int) (wantedl-spv.length()),(int) 0),"","PUTtim","GETtim"); printf("%5d %s %*s %6.3f %6.3f\n", (*it_handle).getHandle(),(*it_handle).pv.c_str(), std::max((int)(wantedl-(*it_handle).pv.length()),(int) 0),"", ctp.getTimeout(),ctg.getTimeout()); } else { cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to reset timeout for put/get operations to default values * for all handles * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setTimeoutToDefault() { #define __METHOD__ "PolicyHelper::setTimeoutToDefault()" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus=setTimeoutToDefault((*itcs).getHandle()); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * \brief Allows user to reset timeout for put/get operations to default values * for given handle * \param _handle input: Conduit object reference * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setTimeoutToDefault(unsigned int _handle) { #define __METHOD__ "PolicyHelper::setTimeoutToDefault(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()) { ChannelTimeoutPolicy ctp=(*it_handle).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*it_handle).getChannelTimeoutPolicyGet(); ctp.setTimeoutToDefault(); ctg.setTimeoutToDefault(); if(MUTEX) { cafeMutex.lock(); } handle_index.modify(it_handle, change_channelTimeoutPolicyPut(ctp)); handle_index.modify(it_handle, change_channelTimeoutPolicyGet(ctg)); if(MUTEX) { cafeMutex.unlock(); } } else { cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to set timeout for put/get operations (within allowed default min/max values) * for all handles * \param p input: put timeout * \param g input: get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setTimeout(double p, double g) { #define __METHOD__ "PolicyHelper::setTimeout(double p, double g)" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itcs = cs.begin(); itcs != cs.end(); ++itcs) { localStatus=setTimeout((*itcs).getHandle(),p,g); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * \brief Allows user to set timeoout for put/get operations (within allowed default min/max values) * \param _handle input: Conduit object reference * \param p input: put timeout * \param g input: get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setTimeout(unsigned int _handle, double p, double g) { #define __METHOD__ "PolicyHelper::setTimeout(unsigned int _handle, double p, double g)" 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()) { ChannelTimeoutPolicy ctp=(*it_handle).getChannelTimeoutPolicyPut(); ChannelTimeoutPolicy ctg=(*it_handle).getChannelTimeoutPolicyGet(); double a=(double) NULL, b= (double) NULL; if (p!=(double) NULL) { a=ctp.setTimeout(p); } if (g!=(double) NULL) { b=ctg.setTimeout(g); } if (a != p || b != g) { cout << "------------------------------------------------------" << endl; cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; cout << "PV = " << (*it_handle).pv << " Handle = " << (*it_handle).handle; cout << ": Requested timeout is not within allowed limits" << endl; if (a != p) { cout << "Timeout Granted (Requested) for put operation = " << a << " (" << p <<")" <(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { ChannelTimeoutPolicy ctp=(*it_groupHandle).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*it_groupHandle).getChannelTimeoutPolicySGGet(); ctp.setSelfGoverningTimeout(b); ctg.setSelfGoverningTimeout(b); if(MUTEX)cafeMutex.lock(); groupHandle_index.modify(it_groupHandle, change_channelTimeoutPolicySGPut(ctp)); groupHandle_index.modify(it_groupHandle, change_channelTimeoutPolicySGGet(ctg)); if(MUTEX)cafeMutex.unlock(); //cout << __METHOD__ << " Setting group Handle " << _gHandle << " SG sef-gov policy to " << b << endl; } else { cafeStatus.report(ECAFE_INVALID_GROUP_HANDLE); return ECAFE_INVALID_GROUP_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to retrieve the policy that governs the corrective adaption of timeouts for put/get operations * for a given handle * \param _gHandle input: Conduit Group object reference * \param p output: bool for put operations * \param g output: bool for get operations * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::getSGSelfGoverningTimeout(unsigned int _gHandle, bool &p, bool &g) { #define __METHOD__ "PolicyHelper::getSGSelfGoverningTimeout(unsigned int _gHandle, bool &p, bool &g)" cafeGroup_set_by_groupHandle & groupHandle_index=gs.get(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { ChannelTimeoutPolicy ctp=(*it_groupHandle).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*it_groupHandle).getChannelTimeoutPolicySGGet(); p=ctp.getSelfGoverningTimeout(); g=ctg.getSelfGoverningTimeout(); } else { p=false; g=false; cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to set the policy that governs the corrective adaption of timeouts for SG put operations * for a given group handle * \param _gHandle input: Conduit Group object reference * \param b input: bool * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSGSelfGoverningTimeoutPut(unsigned int _gHandle, bool b) { #define __METHOD__ "PolicyHelper::setSGSelfGoverningTimeoutPut(unsigned int _ghandle, bool b)" cafeGroup_set_by_groupHandle & groupHandle_index=gs.get(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { ChannelTimeoutPolicy ctp=(*it_groupHandle).getChannelTimeoutPolicySGPut(); ctp.setSelfGoverningTimeout(b); if(MUTEX)cafeMutex.lock(); groupHandle_index.modify(it_groupHandle, change_channelTimeoutPolicySGPut(ctp)); if(MUTEX)cafeMutex.unlock(); } else { cafeStatus.report(ECAFE_INVALID_GROUP_HANDLE); return ECAFE_INVALID_GROUP_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to set the policy that governs the corrective adaption of timeouts for SG get operations * for a given group handle * \param _gHandle input: Conduit Group object reference * \param b input: bool * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSGSelfGoverningTimeoutGet(unsigned int _gHandle, bool b) { #define __METHOD__ "PolicyHelper::setSGSelfGoverningTimeoutGet(unsigned int _gHandle, bool b)" cafeGroup_set_by_groupHandle & groupHandle_index=gs.get(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { ChannelTimeoutPolicy ctg=(*it_groupHandle).getChannelTimeoutPolicySGGet(); ctg.setSelfGoverningTimeout(b); if(MUTEX)cafeMutex.lock(); groupHandle_index.modify(it_groupHandle, change_channelTimeoutPolicySGGet(ctg)); if(MUTEX)cafeMutex.unlock(); } else { cafeStatus.report(ECAFE_INVALID_GROUP_HANDLE); return ECAFE_INVALID_GROUP_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to retrieve minimum timeout for SG put/get operations * \param p: output: SG put timeout * \param g: output: SG get timeout * \return ICAFE_NORMAL */ int PolicyHelper::getSGTimeoutMin(double & p, double & g) { #define __METHOD__ "PolicyHelper::getSGTimeoutMin(double &p, double &g)" double a=TIMEOUT_PEND_IO_MAX ; double b=TIMEOUT_PEND_IO_MAX ; bool isFound=false; // Loop through all elements for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { ChannelTimeoutPolicy ctp=(*itgs).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*itgs).getChannelTimeoutPolicySGGet(); a=std::min(a,ctp.getTimeout()); b=std::min(b,ctg.getTimeout()); isFound=true; } if (isFound) { p=a; g=b; } else { p=DEFAULT_TIMEOUT_SG_PEND_IO; g=DEFAULT_TIMEOUT_SG_PEND_IO; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to retrieve minimum timeout for put/get operations * \param p: output: SG put timeout * \param g: output: SG get timeout * \return ICAFE_NORMAL */ int PolicyHelper::getSGTimeoutMax(double & p, double & g) { #define __METHOD__ "PolicyHelper::getSGTimeoutMin(double &p, double &g)" double a=TIMEOUT_PEND_IO_MIN ; double b=TIMEOUT_PEND_IO_MIN; bool isFound=false; // Loop through all elements for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { ChannelTimeoutPolicy ctp=(*itgs).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*itgs).getChannelTimeoutPolicySGGet(); a=std::max(a,ctp.getTimeout()); b=std::max(b,ctg.getTimeout()); isFound=true; } if (isFound) { p=a; g=b; } else { p=DEFAULT_TIMEOUT_SG_PEND_IO; g=DEFAULT_TIMEOUT_SG_PEND_IO; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to reset synchronous group timeout for put/get operations to default values * for all group handles * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSGTimeoutToDefault() { #define __METHOD__ "PolicyHelper::setSGTimeoutToDefault()" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { localStatus=setSGTimeoutToDefault((*itgs).getGroupHandle()); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * \brief Allows user to reset synchronous group timeout for put/get operations to default values * for given handle * \param _gHandle input: ConduitGroup object reference * \return ICAFE_NORMAL or ECAFE_INVALID_HANDLE */ int PolicyHelper::setSGTimeoutToDefault(unsigned int _gHandle) { #define __METHOD__ "PolicyHelper::setSGTimeoutToDefault(unsigned int _gHandle)" cafeGroup_set_by_groupHandle & groupHandle_index=gs.get(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { ChannelTimeoutPolicy ctp=(*it_groupHandle).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*it_groupHandle).getChannelTimeoutPolicySGGet(); ctp.setTimeoutToDefault(); ctg.setTimeoutToDefault(); if(MUTEX) { cafeMutex.lock(); } groupHandle_index.modify(it_groupHandle, change_channelTimeoutPolicySGPut(ctp)); groupHandle_index.modify(it_groupHandle, change_channelTimeoutPolicySGGet(ctg)); if(MUTEX) { cafeMutex.unlock(); } } else { cafeStatus.report(ECAFE_INVALID_GROUP_HANDLE); return ECAFE_INVALID_GROUP_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Prints timeout for SG put/get operations * \return ICAFE_NORMAL */ int PolicyHelper::printSGTimeout() { #define __METHOD__ "PolicyHelper::printSGTimeout()" short pvstrl=0; for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { pvstrl=std::max(pvstrl,(short) (*itgs).groupName.length()); } string spv="Group"; cout << "---------------------TIMEOUTS---------------------" << endl; printf("%s %s %*s %s %s\n", "Hndle",spv.c_str(), std::max((int) (pvstrl-spv.length()),(int) 0),"","PUTtim","GETtim"); // Loop through all elements for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { ChannelTimeoutPolicy ctp=(*itgs).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*itgs).getChannelTimeoutPolicySGGet(); printf("%5d %s %*s %6.3f %6.3f\n", (*itgs).getGroupHandle(),(*itgs).groupName.c_str(), std::max((int) (pvstrl-(*itgs).groupName.length()),(int) 0),"", ctp.getTimeout(), ctg.getTimeout() ) ; } cout << "--------------------------------------------------" << endl; return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Prints timeout for put/get operations for given handle * \param _gHandle input: handle to ConduitGroup Object * \return ICAFE_NORMAL */ int PolicyHelper::printSGTimeout(unsigned int _gHandle) { #define __METHOD__ "PolicyHelper::printTimeout(unsigned int _handle)" cafeGroup_set_by_groupHandle & groupHandle_index=gs.get(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { //Conduit cc=(*it_handle); ChannelTimeoutPolicy ctp=(*it_groupHandle).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*it_groupHandle).getChannelTimeoutPolicySGGet(); string spv="Group"; int wantedl= std::max(28,(int) (*it_groupHandle).groupName.length()); printf("%s %s %*s %s %s\n", "Handle",spv.c_str(), std::max((int) (wantedl-spv.length()),(int) 0),"","PUTtim","GETtim"); printf("%5d %s %*s %6.3f %6.3f\n", (*it_groupHandle).getGroupHandle(),(*it_groupHandle).groupName.c_str(), std::max((int)(wantedl-(*it_groupHandle).groupName.length()),(int) 0),"", ctp.getTimeout(),ctg.getTimeout()); } else { cafeStatus.report(ECAFE_INVALID_HANDLE); return ECAFE_INVALID_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to retrieve timeout for SG put/get operations \n * \param _gHandle input: Conduit Group object reference * \param p output: SG put timeout * \param g output: SG get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_GROUP_HANDLE */ int PolicyHelper::getSGTimeout(unsigned int _gHandle, double & p, double & g) { #define __METHOD__ "PolicyHelper::getSGTimeout(unsigned int _gHandle, double &p, double &g)" cafeGroup_set_by_groupHandle & groupHandle_index=gs.get(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { ChannelTimeoutPolicy ctp=(*it_groupHandle).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*it_groupHandle).getChannelTimeoutPolicySGGet(); p=ctp.getTimeout(); g=ctg.getTimeout(); } else { cafeStatus.report(ECAFE_INVALID_GROUP_HANDLE); return ECAFE_INVALID_GROUP_HANDLE; } return ICAFE_NORMAL; #undef __METHOD__ } /** * \brief Allows user to set timeout for SG put/get operations (within allowed default min/max values) * for all handles * \param p input: SG put timeout * \param g input: SG get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_GROUP_HANDLE */ int PolicyHelper::setSGTimeout(double p, double g) { #define __METHOD__ "PolicyHelper::setSGTimeout(double p, double g)" int gStatus=ICAFE_NORMAL; int localStatus; // Loop through all elements for (itgs = gs.begin(); itgs != gs.end(); ++itgs) { localStatus=setSGTimeout((*itgs).getGroupHandle(),p,g); if (localStatus !=ICAFE_NORMAL) { gStatus=localStatus; } } return gStatus; #undef __METHOD__ } /** * \brief Allows user to set timeoout for SG put/get operations (within allowed default min/max values) * \param _gHandle input: Conduit Group object reference * \param p input: SG put timeout * \param g input: SG get timeout * \return ICAFE_NORMAL or ECAFE_INVALID_GROUP_HANDLE */ int PolicyHelper::setSGTimeout(unsigned int _gHandle, double p, double g) { #define __METHOD__ "PolicyHelper::setSGTimeout(unsigned int _handle, double p, double g)" cafeGroup_set_by_groupHandle & groupHandle_index=gs.get(); cafeGroup_set_by_groupHandle::iterator it_groupHandle; it_groupHandle = groupHandle_index.find(_gHandle); if (it_groupHandle != groupHandle_index.end()) { ChannelTimeoutPolicy ctp=(*it_groupHandle).getChannelTimeoutPolicySGPut(); ChannelTimeoutPolicy ctg=(*it_groupHandle).getChannelTimeoutPolicySGGet(); double a=(double) NULL, b= (double) NULL; if (p!=(double) NULL) { a=ctp.setTimeout(p); } if (g!=(double) NULL) { b=ctg.setTimeout(g); } if (a != p || b != g) { cout << "------------------------------------------------------" << endl; cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__ << endl; cout << "Synch. Group = " << (*it_groupHandle).groupName << " Handle = " << (*it_groupHandle).groupHandle; cout << ": Requested timeout is not within allowed limits" << endl; if (a != p) { cout << "Timeout Granted (Requested) for put operation = " << a << " (" << p <<")" <