///
/// \file    cafe.h
/// \author  Jan Chrin, PSI
/// \date    Release: June 2018
/// \version CAFE 1.6.0

#ifndef CAFE_H
#define CAFE_H

#include <connect.h>
#include <conduitEventHandlerArgs.h>
#include <instant.h>
#include <cafeDataType.h>
#include <global.h>
#if HAVE_PYTHON_H
#include <unicodeobject.h>
#endif

#if HAVE_ZEROMQ
#include <zbsDataHolders.h>
using namespace CAFEBS;
#endif

/**
* \class CAFE
* \brief Methods for synchronous and asynchronous interactions
*/
class CAFE : public Connect {
private:
    Instant<dbr_string_t>   cafeSoluble;
    Instant<dbr_float_t>    cafeFrappuccino;
    Instant<dbr_short_t>    cafeSchale;
    Instant<dbr_enum_t>     cafeEspresso;
    Instant<dbr_char_t>     cafeCappuccino;
    Instant<dbr_long_t>     cafeLatte;
    Instant<dbr_double_t>   cafeDoppio;

    Transpose<dbr_string_t> renderString; // 0
    Transpose<dbr_short_t>  renderShort;  // 1
    Transpose<dbr_float_t>  renderFloat;  // 2
    Transpose<dbr_enum_t>   renderEnum;   // 3
    Transpose<dbr_char_t>   renderChar;   // 4
    Transpose<dbr_long_t>   renderLong;   // 5
    Transpose<dbr_double_t> renderDouble; // 6

    Granules cafeGranules;
    ChannelGetCacheWaitPolicy channelGetCacheWaitPolicy;
    ChannelRequestStatus  channelRequestStatusGet;
    ChannelRequestStatus  channelRequestStatusGetCtrl;
    ChannelRequestMetaDataClient channelRequestMetaDataClient; //used for PVDataHolder
    ChannelRequestMetaDataClient channelRequestMetaCtrlClient; //used for PVCtrlHolder
    CAFENUM::DBR_TYPE vectorDbrType;
    //Groups
    ChannelTimeoutPolicy channelTimeoutPolicySGGet;
    ChannelTimeoutPolicy channelTimeoutPolicySGPut;

public:
    CAFE()
    {
        vectorDbrType=CAFENUM::DBR_NONE; //cafeVectors.h
        //Put in default values
        //make no wait
        channelRequestPolicyMasterPut.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
                                                CAFENUM::NO_WAIT,  CAFENUM::WITH_CALLBACK_DEFAULT); //WITHOUT_CALLBACK)

        //channelRequestPolicyMasterGet.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
        //	  CAFENUM::WAIT,  CAFENUM::WITH_CALLBACK_DEFAULT); //WITHOUT_CALLBACK);
        //channelRequestPolicyMasterGetCtrl.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
        //	 CAFENUM::WAIT, CAFENUM::WITH_CALLBACK_DEFAULT); //WITH_CALLBACK_DEFAULT);
    };

    //28 May 2017
    CAFE(ChannelRequestPolicy _channelRequestPolicyMasterPut,
         ChannelRequestPolicy _channelRequestPolicyMasterGet,
         ChannelGetActionWhenMonitorPolicy _channelGetActionWhenMonitorPolicyMaster)
    {
        channelRequestPolicyMasterPut = _channelRequestPolicyMasterPut;
        channelRequestPolicyMasterGet = _channelRequestPolicyMasterGet;
        channelRequestPolicyMasterGetCtrl = _channelRequestPolicyMasterGet;
        channelGetActionWhenMonitorPolicyMaster = _channelGetActionWhenMonitorPolicyMaster;
        vectorDbrType=CAFENUM::DBR_NONE;
    }

    //28 May 2017
    CAFE(ChannelRequestPolicy _channelRequestPolicyMasterPut, ChannelRequestPolicy _channelRequestPolicyMasterGet)
    {
        channelRequestPolicyMasterPut = _channelRequestPolicyMasterPut;
        channelRequestPolicyMasterGet = _channelRequestPolicyMasterGet;
        channelRequestPolicyMasterGetCtrl = _channelRequestPolicyMasterGet;
        vectorDbrType=CAFENUM::DBR_NONE;
    }

    //28 May 2017
    CAFE(ChannelRequestPolicy _channelRequestPolicyMasterPut)
    {
        channelRequestPolicyMasterPut = _channelRequestPolicyMasterPut;
        //channelRequestPolicyMasterGet.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
        //						  CAFENUM::WAIT,  CAFENUM::WITH_CALLBACK_DEFAULT); //WITHOUT_CALLBACK);
        //channelRequestPolicyMasterGetCtrl.setPolicy(CAFENUM::FLUSH_AFTER_EACH_MESSAGE,
        //						  CAFENUM::WAIT, CAFENUM::WITH_CALLBACK_DEFAULT); //WITH_CALLBACK_DEFAULT);
        vectorDbrType=CAFENUM::DBR_NONE;
    }

#include <cafeCache.h>
#include <cafeVectors.h>
#include <cafeRoast.h>
    //#if HAVE_LIBQTXML
    //only if qt xml activated
#include <cafeXML.h>
    // if HAVE_LIBQTXML moved to within header file
    //#endif

    //get NON_BLOCKING
    int getNonBlocking(const unsigned int  handle)
    {
        return get(handle);
    };
    int get      (const unsigned int  handle);
    int get      (const unsigned int  *handleArray, unsigned int nelem, int  *statusArray);
    int get      (const unsigned int  *handleArray, unsigned int nHandles, std::vector<int> &statusV);
    int getCtrl  (const unsigned int  handle);

    //get BLOCKING
    int  get      (const unsigned int  handle, PVDataHolder & pvd);
    int  get      (const unsigned int  *handleArray, unsigned int nelem, PVDataHolder * pvd);

    int waitForBundledEvents(std::vector<unsigned int> handleV, std::vector<int> &vRB);
    int waitForBundledEvents(unsigned int  *handleArray, unsigned int nHandles, std::vector<int> &vRB);
    int waitForGetEvent(unsigned int handle);

    int getCtrl  (const unsigned int  handle, PVCtrlHolder & pvc);
    int getCtrl  (const unsigned int  *handleArray, unsigned int nelem, PVCtrlHolder * pvc);

    //pvName
    //NON_BLOCKING
    int get      (const char * pv);
    int getCtrl  (const char * pv);

    //BLOCKING
    int get    (const char * pv, PVDataHolder & pvd);
    int getCtrl(const char * pv, PVCtrlHolder & pvc);

    //Special
    int getWFAsString(unsigned int handle, std::string & message);
    int getWFAsString(const char * pv, std::string & message)
    {
        unsigned int  handle;
        status=ICAFE_NORMAL;
        try {
            status = open(pv,  handle);
        }
        catch (CAFEException_open & e) {
            return e.pvEx.statusCode;
        }
        if (status == ICAFE_NORMAL) {
            status=getWFAsString(handle, message);
        }
        return status;
    }

    int getWFAsStringCache(unsigned int handle, std::string & message);
    int getWFAsStringCache(const char * pv, std::string & message)
    {
        unsigned int  handle;
        status=ICAFE_NORMAL;
        try {
            status = open(pv,  handle);
        }
        catch (CAFEException_open & e) {
            return e.pvEx.statusCode;
        }
        if (status == ICAFE_NORMAL) {
            status=getWFAsStringCache(handle, message);
        }
        return status;
    }

    std::string getChannelIDAsString(chid _chid)
    {
        std::stringstream ss;
        ss << _chid;
        return ss.str();
    }

		int  getAllChannelInfo(unsigned int handle, ChannelRegalia & channelInfo, PVCtrlHolder & pvc, PVDataHolder &pvd, std::string & desc);
	  int  getChannelDataStore(unsigned int handle, ChannelDataStore & cds);

    int supplementHandles();
    int supplementHandlesV(std::vector<unsigned int> hV);
    int supplementHandle(unsigned int handle) {
		 std::vector<unsigned int> hV;
		 hV.push_back(handle);
		 return supplementHandlesV(hV);
		} 


#if HAVE_ZEROMQ
    int calcDBPMStatus(int, int, std::string);
    int initBSwithCA(CAFEBS::BSDataHolder &bsd);
		int setBS2CA_Step1(CAFEBS::BSDataHolder &bsd);
		int setBS2CA_Step2(CAFEBS::BSDataHolder &bsd);
		int setBS2CA_Step3(CAFEBS::BSDataHolder &bsd);
    int setBS2CA(CAFEBS::BSDataHolder &bsd);
    int setBS(CAFEBS::BSDataHolder &bsd, bool closeCA);
    int getBS(CAFEBS::BSDataHolder &bsd);
    int closeBS(CAFEBS::BSDataHolder &bsd);
    int setPulseIDBufferSize(unsigned int _handle, unsigned short _bsize)
    {
        return handleHelper.setMapPulseIDBufferSize(_handle, _bsize);
    }
    int setPulseIDBufferSize(const char * _pv, unsigned short _bsize)
    {
        unsigned int _handle=handleHelper.getHandleFromPV(_pv);
        return handleHelper.setMapPulseIDBufferSize(_handle, _bsize);
    }
    int setPulseIDBufferSizeAll(unsigned short _bsize)
    {
        return handleHelper.setMapPulseIDBufferSizeAll(_bsize);
    }
    int getDBPM(DBPMKeeper &dbpm);
    int readDBPMOffsets(DBPMKeeper &dbpm);
    int prepareDBPM(std::vector<std::string> &_glist, std::vector<unsigned int> &_hV, std::vector<std::string> &dev,  std::vector<float> &pos) ;
    int prepareDBPM(std::vector<std::string> &_glist, std::vector<unsigned int> &_hV, std::map<float, std::string> &posDev) ;
#endif

    //Standard BLOCKING get
    //0+
    int  get(const unsigned int  handle, std::string * valStr,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        unsigned int nn=handleHelper.getNelemClient(handle);
        if (nn==0) {
            return ECAFE_INVALID_HANDLE;
        }
        //check on handle number before proceeding!
        dbr_string_t * _val = new dbr_string_t[nn];
        status=cafeSoluble.get(handle, DBR_TIME_STRING, _val, alarmStatus, alarmSeverity, ts);
        for (unsigned int i=0; i< handleHelper.getNelemRequest(handle); ++i) {
            valStr[i]=_val[i];
        }
        delete [] _val;
        return status;
    };

    int  get(const unsigned int  handle, std::string * valStr, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        unsigned int nn=handleHelper.getNelemClient(handle);
        if (nn==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t * _val = new dbr_string_t[nn];
        status=cafeSoluble.get(handle, DBR_STS_STRING, _val, alarmStatus, alarmSeverity);
        for (unsigned int i=0; i< handleHelper.getNelemRequest(handle); ++i) {
            valStr[i]=_val[i];
        }
        delete [] _val;
        return status;
    };

    int  get(const unsigned int  handle, std::string * valStr)
    {
        unsigned int nn=handleHelper.getNelemClient(handle);
        if (nn==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t * _val = new dbr_string_t[nn];
        status=cafeSoluble.get(handle, DBR_STRING, _val);
        for (unsigned int i=0; i< handleHelper.getNelemRequest(handle); ++i) {
            valStr[i]=_val[i];
        }
        delete [] _val;
        return status;
    };

    //0
    int get(const unsigned int  handle, dbr_string_t * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        return cafeSoluble.get(handle, DBR_TIME_STRING, _val, alarmStatus, alarmSeverity, ts);
    };
    int get(const unsigned int  handle, dbr_string_t * _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        return cafeSoluble.get(handle, DBR_STS_STRING, _val, alarmStatus, alarmSeverity);
    };
    int get(const unsigned int  handle, dbr_string_t * _val)
    {
        return cafeSoluble.get(handle, DBR_STRING, _val);
    };
    //1
    int get(const unsigned int  handle, dbr_short_t * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        return cafeSchale.get (handle, DBR_TIME_SHORT, _val, alarmStatus, alarmSeverity, ts);
    };
    int get(const unsigned int  handle, dbr_short_t * _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        return cafeSchale.get (handle, DBR_STS_SHORT, _val, alarmStatus, alarmSeverity);
    };
    int get(const unsigned int  handle, dbr_short_t * _val)
    {
        return cafeSchale.get (handle, DBR_SHORT, _val);
    };
    //2
    int get(const unsigned int  handle, dbr_float_t * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        return cafeFrappuccino.get(handle, DBR_TIME_FLOAT, _val, alarmStatus, alarmSeverity, ts);
    };
    int get(const unsigned int  handle, dbr_float_t * _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        return cafeFrappuccino.get(handle, DBR_STS_FLOAT, _val, alarmStatus, alarmSeverity);
    };
    int get(const unsigned int  handle, dbr_float_t * _val)
    {
        return cafeFrappuccino.get (handle, DBR_FLOAT, _val);
    };
    //3
    int get(const unsigned int  handle, dbr_ushort_t * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        return cafeEspresso.get (handle, DBR_TIME_ENUM, _val, alarmStatus, alarmSeverity, ts);
    };
    int get(const unsigned int  handle, dbr_ushort_t * _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        return cafeEspresso.get (handle, DBR_STS_ENUM, _val, alarmStatus, alarmSeverity);
    };
    int get(const unsigned int  handle, dbr_ushort_t * _val)
    {
        return cafeEspresso.get (handle, DBR_ENUM, _val);
    };
//4
    int get(const unsigned int  handle, dbr_char_t * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        return cafeCappuccino.get (handle, DBR_TIME_CHAR, _val, alarmStatus, alarmSeverity, ts);
    };
    int get(const unsigned int  handle, dbr_char_t * _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        return cafeCappuccino.get (handle, DBR_STS_CHAR, _val, alarmStatus, alarmSeverity);
    };
    int get(const unsigned int  handle, dbr_char_t * _val)
    {
        return cafeCappuccino.get (handle, DBR_CHAR, _val);
    };
    //5
    int get(const unsigned int  handle, dbr_long_t * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        return cafeLatte.get (handle, DBR_TIME_LONG, _val, alarmStatus, alarmSeverity, ts);
    };
    int get(const unsigned int  handle, dbr_long_t * _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        return cafeLatte.get (handle, DBR_STS_LONG, _val, alarmStatus, alarmSeverity);
    };
    int get(const unsigned int  handle, dbr_long_t * _val)
    {
        return cafeLatte.get (handle, DBR_LONG, _val);
    };
    //5+ long long
    int get(const unsigned int  handle, long long   * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts);
    int get(const unsigned int  handle, long long   * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity);
    int get(const unsigned int  handle, long long   * _val);

    //6
    int get(const unsigned int handle, dbr_double_t * _val,  dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)
    {
        return cafeDoppio.get (handle, DBR_TIME_DOUBLE, _val, alarmStatus, alarmSeverity, ts);
    };
    int get(const unsigned int handle, dbr_double_t * _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)
    {
        return cafeDoppio.get (handle, DBR_STS_DOUBLE, _val, alarmStatus, alarmSeverity);
    };
    int get(const unsigned int handle, dbr_double_t * _val)
    {
        return cafeDoppio.get (handle, DBR_DOUBLE, _val);
    };
    //Arrays
    int getCharArray(const unsigned int handle, dbr_char_t * _val)
    {
        return cafeCappuccino.get (handle, DBR_CHAR, _val);
    };
    int getShortArray(const unsigned int handle, dbr_short_t * _val)
    {
        return cafeSchale.get (handle, DBR_SHORT, _val);
    };
    int getUShortArray(const unsigned int handle, dbr_ushort_t * _val)
    {
        return cafeEspresso.get (handle, DBR_ENUM, _val);
    };
    int getDoubleArray(const unsigned int handle, dbr_double_t * _val)
    {
        return cafeDoppio.get (handle, DBR_DOUBLE, _val);
    };
    int getFloatArray(const unsigned int handle, dbr_float_t * _val)
    {
        return cafeFrappuccino.get (handle, DBR_FLOAT, _val);
    };
    int getLongArray(const unsigned int handle, dbr_long_t * _val)
    {
        return cafeLatte.get (handle, DBR_LONG, _val);
    };
    int getLongLongArray(const unsigned int handle, long long * _val)
    {
        return get (handle, _val);
    };
    int getStringArray(const unsigned int handle, std::string * valStr)
    {
        return  get(handle, valStr);
    };
    int getDbrStringArray(const unsigned int  handle, dbr_string_t * _val)
    {
        return cafeSoluble.get(handle, DBR_STRING, _val);
    };

    //0
    //single values
    int getString(const unsigned int handle, std::string  & valStr)   //0+
    {
        unsigned int nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_STRING, val);
        if (status==ICAFE_NORMAL) {
            valStr=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    };

    int get(const unsigned int handle, std::string  & valStr)   //0+
    {
        unsigned int nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_STRING, val);
        if (status==ICAFE_NORMAL) {
            valStr=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    };

    int get(const unsigned int  handle, std::string  & valStr, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //0
    {
        unsigned int nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_STS_STRING, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            valStr=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    };

    int  getStringTS(const unsigned int  handle, std::string  & valStr,
                     dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //0
    {
        unsigned int nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_TIME_STRING, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            valStr=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }

    int get(const unsigned int  handle, std::string  & valStr,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //0
    {
        unsigned int nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_TIME_STRING, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            valStr=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }

    int get(const unsigned int handle, dbr_string_t  & _val)   //0
    {
        unsigned int nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_STRING, val);
        if (status==ICAFE_NORMAL) {
            sprintf(_val, val[0]);
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }

    int get(const unsigned int  handle, dbr_string_t  & _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //0
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_STS_STRING, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            sprintf(_val, val[0]);
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }

    int get(const unsigned int  handle, dbr_string_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //0
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1]= {""};
        status=cafeSoluble.get(handle, DBR_TIME_STRING, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            sprintf(_val, val[0]);
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }

    int  get(const unsigned int  handle, dbr_short_t  & _val)  //1
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_short_t val[1]= {0};
        status=cafeSchale.get(handle, DBR_SHORT, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_short_t  & _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //1
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_short_t val[1]= {0};
        status=cafeSchale.get(handle, DBR_STS_SHORT, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_short_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //1
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_short_t val[1]= {0};
        status=cafeSchale.get(handle, DBR_TIME_SHORT, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_float_t  &_val)  //2
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_float_t val[1]= {0};
        status=cafeFrappuccino.get(handle, DBR_FLOAT, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_float_t  &_val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //2
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_float_t val[1]= {0};
        status=cafeFrappuccino.get(handle, DBR_STS_FLOAT, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_float_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //2
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_float_t val[1]= {0};
        status=cafeFrappuccino.get(handle, DBR_TIME_FLOAT, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_enum_t  & _val)  //3
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_enum_t val[1]= {0};
        status=cafeEspresso.get(handle, DBR_ENUM, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_enum_t  & _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //3
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_enum_t val[1]= {0};
        status=cafeEspresso.get(handle, DBR_STS_ENUM, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_enum_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //3
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_enum_t val[1]= {0};
        status=cafeEspresso.get(handle, DBR_TIME_ENUM, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_char_t  & _val)  //4
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_char_t val[1]= {0};
        status=cafeCappuccino.get(handle, DBR_CHAR, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_char_t  & _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //4
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_char_t val[1]= {0};
        status=cafeCappuccino.get(handle, DBR_STS_CHAR, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_char_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //4
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_char_t val[1]= {0};
        status=cafeCappuccino.get(handle, DBR_TIME_CHAR, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int getLong(const unsigned int  handle, dbr_long_t  & _val)  //5
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_long_t val[1]= {0};
        status=cafeLatte.get(handle, DBR_LONG, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_long_t  & _val)  //5
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_long_t val[1]= {0};
        status=cafeLatte.get(handle, DBR_LONG, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_long_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //5
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_long_t val[1]= {0};
        status=cafeLatte.get(handle, DBR_STS_LONG, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_long_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //5
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_long_t val[1]= {0};
        status=cafeLatte.get(handle, DBR_TIME_LONG, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }

    int get(const unsigned int  handle, long long  & _val)  //5+ long long
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        long long val[1]= {0};
        status=CAFE::get(handle, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, long long  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)  //5+ long long
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        long long val[1]= {0};
        status=CAFE::get(handle, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, long long & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //5+ long long
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        long long val[1]= {0};
        status=CAFE::get(handle, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }

    int getDouble(const unsigned int  handle, dbr_double_t  & _val)   //6
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_double_t val[1]= {0};
        status=cafeDoppio.get(handle, DBR_DOUBLE, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_double_t  & _val)   //6
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_double_t val[1]= {0};
        status=cafeDoppio.get(handle, DBR_DOUBLE, val);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_double_t  & _val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity)   //6
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_double_t val[1]= {0};
        status=cafeDoppio.get(handle, DBR_STS_DOUBLE, val, alarmStatus, alarmSeverity);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    int get(const unsigned int  handle, dbr_double_t  & _val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts)  //6
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_double_t val[1]= {0};
        status=cafeDoppio.get(handle, DBR_TIME_DOUBLE, val, alarmStatus, alarmSeverity, ts);
        if (status==ICAFE_NORMAL) {
            _val=val[0];
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }




    ////////////////////////////////////////////// by PV name ///////////////////////////////////

    int get(const char * pv, std::string  * valStr); //0+
    int get(const char * pv, std::string  * valStr, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity);//0+
    int get(const char * pv, std::string  * valStr,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //0+

    int get(const char * pv, dbr_string_t  * val); //0
    int get(const char * pv, dbr_string_t  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //0
    int get(const char * pv, dbr_string_t  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //0
    int get(const char * pv, dbr_short_t  * val);//1
    int get(const char * pv, dbr_short_t  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //1
    int get(const char * pv, dbr_short_t  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //1
    int get(const char * pv, dbr_float_t  * val);//2
    int get(const char * pv, dbr_float_t  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //2
    int get(const char * pv, dbr_float_t  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //2
    int get(const char * pv, dbr_enum_t  * val); //3
    int get(const char * pv, dbr_enum_t  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity);  //3
    int get(const char * pv, dbr_enum_t  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //3
    int get(const char * pv, dbr_char_t  * val); //4
    int get(const char * pv, dbr_char_t  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //4
    int get(const char * pv, dbr_char_t  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //4
    int get(const char * pv, dbr_long_t  * val); //5
    int get(const char * pv, dbr_long_t  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //5
    int get(const char * pv, dbr_long_t  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //5

    int get(const char * pv, long long  * val);  //5+ long long
    int get(const char * pv, long long  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //5+ long long
    int get(const char * pv, long long  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //5+ long long

    int get(const char * pv, dbr_double_t  * val);//6
    int get(const char * pv, dbr_double_t  * val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity);  //6
    int get(const char * pv, dbr_double_t  * val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //6


    int get(const char * pv, std::string  & valStr); //0+
    int get(const char * pv, std::string  & valStr, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //0
    int get(const char * pv, std::string  & valStr,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //0

    int get(const char * pv, dbr_string_t  & val); //0
    int get(const char * pv, dbr_string_t  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //0
    int get(const char * pv, dbr_string_t  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //0
    int get(const char * pv, dbr_short_t  & val); //1
    int get(const char * pv, dbr_short_t  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //1
    int get(const char * pv, dbr_short_t  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //1
    int get(const char * pv, dbr_float_t  & val); //2
    int get(const char * pv, dbr_float_t  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //2
    int get(const char * pv, dbr_float_t  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //2
    int get(const char * pv, dbr_enum_t  & val); //3
    int get(const char * pv, dbr_enum_t  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //3
    int get(const char * pv, dbr_enum_t  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //3
    int get(const char * pv, dbr_char_t  & val); //4
    int get(const char * pv, dbr_char_t  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //4
    int get(const char * pv, dbr_char_t  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //4

    int get(const char * pv, dbr_long_t  & val); //5
    int get(const char * pv, dbr_long_t  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //5
    int get(const char * pv, dbr_long_t  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //5

    int get(const char * pv, long long  & val); //5+ long long
    int get(const char * pv, long long  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity); //5+ long long
    int get(const char * pv, long long  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //5+ long long

    int get(const char * pv, dbr_double_t  & val);  //6
    int get(const char * pv, dbr_double_t  & val, dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity);  //6
    int get(const char * pv, dbr_double_t  & val,
            dbr_short_t &alarmStatus, dbr_short_t &alarmSeverity, epicsTimeStamp &ts); //6


    /////////////////////////////////////////////////////////////////////////////////////////////

    int  waitForPut  (const unsigned int *h, const unsigned int nelem);

    /////////////////////////////////////////////////////////////////////////////////////////////


    int set(const unsigned int  handle, PVDataHolder & pvd); //Yes
    int set(const unsigned int  * handleArray, const unsigned int  nelem, PVDataHolder * pvd);
    int set(const char *, PVDataHolder & pvd);

    //0
    int set(const unsigned int  handle, const dbr_string_t * _val)
    {
        return cafeSoluble.set (handle, DBR_STRING, _val);
    };
    //1
    int set(const unsigned int  handle, const dbr_short_t * _val)
    {
        return cafeSchale.set (handle, DBR_SHORT, _val);
    };
    //2
    int set(const unsigned int  handle, const dbr_float_t * _val)
    {
        return cafeFrappuccino.set (handle, DBR_FLOAT, _val);
    };
    //3
    int set(const unsigned int  handle, const dbr_enum_t * _val)
    {
        return cafeEspresso.set (handle, DBR_ENUM, _val);
    };
    //4
    int set(const unsigned int  handle, const dbr_char_t * _val)
    {
        return cafeCappuccino.set (handle, DBR_CHAR, _val);
    };
    //5
    int set(const unsigned int  handle, const dbr_long_t * _val)
    {
        return cafeLatte.set (handle, DBR_LONG, _val);
    };
    //5+ long long
    int set(const unsigned int  handle, const long long * _val);
    //6
    int set(const unsigned int  handle, const dbr_double_t * _val)
    {
        return cafeDoppio.set (handle, DBR_DOUBLE, _val);
    };


    //set for PythonTypes
    //0
    int setStringArray(const unsigned int handle, const dbr_string_t * _val)
    {
        return cafeSoluble.set (handle, DBR_STRING, _val);
    };

    //4
    int setCharArray(const unsigned int handle, const dbr_char_t *  _val)
    {
        return cafeCappuccino.set (handle, DBR_CHAR, _val);
    };
    //5
    int setLongArray(const unsigned int handle, const dbr_long_t * _val)
    {
        return cafeLatte.set (handle, DBR_LONG, _val);
    };
    //6
    int setDoubleArray(const unsigned int handle, const dbr_double_t * _val)
    {
        return cafeDoppio.set (handle, DBR_DOUBLE, _val);
    };

    //0
    int setString(const unsigned int handle, const std::string  _val)
    {
        return set (handle, _val);
    };
    //1
    int setShort(const unsigned int  handle, const dbr_short_t  _val)
    {
        return set (handle, _val);
    };
    //2
    int setFloat(const unsigned int  handle, const dbr_float_t  _val)
    {
        return set (handle, _val);
    };
    //3
    int setUShort(const unsigned int  handle, const dbr_enum_t  _val)
    {
        return set (handle, _val);
    };
    //4
    int setChar(const unsigned int handle, const dbr_char_t   _val)
    {
        return set (handle,  _val);
    };
    //5
    int   setLong(const unsigned int handle, const dbr_long_t  _val)
    {
        return set (handle, _val);
    };
    //5+
    int setLongLong(const unsigned int handle, const long long  _val)
    {
        return set (handle, _val);
    };
    //6
    int setDouble(const unsigned int handle, const dbr_double_t  _val)
    {
        return set (handle, _val);
    };


    //0
    int set(const unsigned int  handle, std::string _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1];
        //remove leading and trailing blanks;
        char mess[MAX_STRING_SIZE];
        handleHelper.removeLeadingAndTrailingSpacesDbrString((char *) _val.c_str(),mess);
        sprintf(val[0],"%s",mess);

        status=cafeSoluble.set(handle, DBR_STRING, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //0
    int set(const unsigned int  handle, const dbr_string_t _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_string_t val[1];
        sprintf(val[0],"%s",_val);
        status=cafeSoluble.set(handle, DBR_STRING, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //1
    int set(const unsigned int  handle, const dbr_short_t _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_short_t val[1];
        val[0]=_val;
        status=cafeSchale.set(handle, DBR_SHORT, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //2
    int set(const unsigned int  handle, const dbr_float_t _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_float_t val[1];
        val[0]=_val;
        status=cafeFrappuccino.set(handle, DBR_FLOAT, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //3
    int set(const unsigned int  handle, const dbr_enum_t _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_enum_t val[1];
        val[0]=_val;
        status=cafeEspresso.set(handle, DBR_ENUM, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //4
    int set(const unsigned int  handle, const dbr_char_t _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_char_t val[1];
        val[0]=_val;
        status=cafeCappuccino.set(handle, DBR_CHAR, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //5
    int set(const unsigned int  handle, const dbr_long_t _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_long_t val[1];
        val[0]=_val;
        status=cafeLatte.set(handle, DBR_LONG, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //5+ long long
    int set(const unsigned int  handle, const long long _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        if (_val <= LONG_MAX) {
            dbr_long_t val[1];
            val[0]=_val;
            status=CAFE::set(handle,  val);
        }
        else {
            dbr_double_t val[1];
            val[0]=_val;
            status=CAFE::set(handle,  val);
        }
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }
    //6
    int set(const unsigned int  handle, const dbr_double_t _val)
    {
        unsigned int  nelemPrevious=CAFE::setNelemToOne(handle);
        if (nelemPrevious==0) {
            return ECAFE_INVALID_HANDLE;
        }
        dbr_double_t val[1];
        val[0]=_val;
        status=cafeDoppio.set(handle, DBR_DOUBLE, val);
        CAFE::setNelemToPrevious(handle, nelemPrevious);
        return status;
    }


    //0  non-blocking, flush at end
    int set(const unsigned int  *handleArray,  const unsigned int  nelem, const dbr_string_t * _val,  int  *statusArray)
    {
        return cafeSoluble.set (handleArray, nelem, DBR_STRING, _val, statusArray);
    }
    //1  non-blocking, flush at end
    int set(const unsigned int  *handleArray, const unsigned int  nelem, const dbr_short_t * _val,  int  *statusArray)
    {
        return cafeSchale.set (handleArray, nelem, DBR_SHORT, _val, statusArray);
    }
    //2  non-blocking, flush at end
    int set(const unsigned int  *handleArray, const unsigned int  nelem, const dbr_float_t * _val,  int  *statusArray)
    {
        return cafeFrappuccino.set (handleArray, nelem, DBR_FLOAT, _val, statusArray);
    }
    //3  non-blocking, flush at end
    int set(const unsigned int  *handleArray, const unsigned int  nelem, const dbr_enum_t * _val,  int  *statusArray)
    {
        return cafeEspresso.set (handleArray, nelem, DBR_ENUM, _val, statusArray);
    }
    //4  non-blocking, flush at end
    int set(const unsigned int  *handleArray, const unsigned int  nelem, const dbr_char_t * _val,  int  *statusArray)
    {
        return cafeCappuccino.set (handleArray, nelem, DBR_CHAR, _val, statusArray);
    }
    //5  non-blocking, flush at end
    int set(const unsigned int  *handleArray, const unsigned int  nelem, const dbr_long_t * _val,  int  *statusArray)
    {
        return cafeLatte.set (handleArray, nelem, DBR_LONG, _val, statusArray);
    }
    //5+ long long  non-blocking, flush at end
    int set(const unsigned int  *handleArray, const unsigned int  nelem, const long long * _val,  int  *statusArray);

    //6  non-blocking, flush at end
    int set(const unsigned int  *handleArray,  const unsigned int  nelem, const dbr_double_t * _val,  int  *statusArray)
    {
        return cafeDoppio.set (handleArray, nelem, DBR_DOUBLE, _val, statusArray);
    }



    //0
    int set(const char *, const dbr_string_t * _val);
    //1
    int set(const char *, const dbr_short_t * _val);
    //2
    int set(const char *, const dbr_float_t * _val);
    //3
    int set(const char *, const dbr_enum_t * _val);
    //4
    int set(const char *, const dbr_char_t * _val);
    //5
    int set(const char *, const dbr_long_t * _val);
    //5+ long long
    int set(const char *, const long long * _val);
    //6
    int set(const char *, const dbr_double_t * _val);

    //0 string
    int set(const char * pv, const std::string _val);
    //0
    int set(const char *, const dbr_string_t _val);
    //1
    int set(const char *, const dbr_short_t  _val);
    //2
    int set(const char *, const dbr_float_t  _val);
    //3
    int set(const char *, const dbr_enum_t   _val);
    //4
    int set(const char *, const dbr_char_t   _val);
    //5
    int set(const char *, const dbr_long_t   _val);
    //5+ long long
    int set(const char *, const long long   _val);
    //6
    int set(const char *, const dbr_double_t _val);


    //helper functions for &val methods
    unsigned int setNelemToOne(const unsigned int handle);
    unsigned int setNelemToPrevious(const unsigned int handle, unsigned int nelemPrevious);

    unsigned int setNelemToRetrieveFromCacheToOne(const unsigned int handle);
    unsigned int setNelemToRetrieveFromCacheToPrevious(const unsigned int handle, unsigned int nelemPrevious);

    //      group functions
    int groupAttach (const unsigned int groupHandle, PVGroup &pvgroup);
    int groupFetch(const unsigned int groupHandle, PVGroup &pvgroup);

    int groupGet(PVGroup &pvgroup);
    int groupGet(const unsigned int groupHandle, PVGroup &pvgroup);

    int groupGetScalar(const unsigned int groupHandle, std::vector<std::string> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<double> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<float> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<short> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<long> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<long long> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<unsigned short> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<unsigned char> &valV, std::vector<int> &statusV);
    int groupGetScalar(const unsigned int groupHandle, std::vector<char> &valV, std::vector<int> &statusV);

    int groupGetScalar(const unsigned int groupHandle, std::string * val,int * statusArray );
    int groupGetScalar(const unsigned int groupHandle, double * val, int * statusArray);
    int groupGetScalar(const unsigned int groupHandle, float * val, int * statusArray);
    int groupGetScalar(const unsigned int groupHandle, short * val, int * statusArray);
    int groupGetScalar(const unsigned int groupHandle, long * val,int * statusArray );
    int groupGetScalar(const unsigned int groupHandle, long long * val, int * statusArray);
    int groupGetScalar(const unsigned int groupHandle, unsigned short * val, int * statusArray );
    int groupGetScalar(const unsigned int groupHandle, unsigned char * val,int * statusArray );
    int groupGetScalar(const unsigned int groupHandle, char * val,int * statusArray );

    int groupGetCache(const unsigned int groupHandle, PVGroup &pvgroup)
    {
        const unsigned int * handleArray = handleHelper.getHandlesFromWithinGroup(groupHandle);
        status=getCache (handleArray, pvgroup.getNPV(),  pvgroup.pvdata);
        pvgroup.statusGroup=status;
        return status;
    }

    //Closes channels but does not delete handle
    std::vector<unsigned int> closeDisconnectedChannelsFromWithinGroupV(const unsigned int groupHandle)
    {
        std::vector<unsigned int> dhV=handleHelper.getDisconnectedHandlesFromWithinGroupV(groupHandle);
        if (dhV.size() >0) {
            closeChannelsKeepHandles(dhV);
        }
        return dhV;
    }

    std::vector<unsigned int> getDisconnectedHandlesFromWithinGroupV(const unsigned int groupHandle)
    {
        return handleHelper.getDisconnectedHandlesFromWithinGroupV(groupHandle);
    }

    std::vector<unsigned int> getHandlesFromWithinGroupV(const unsigned int groupHandle)
    {
        return handleHelper.getHandlesFromWithinGroupV(groupHandle);
    }

    unsigned int * getHandlesFromWithinGroup(const unsigned int groupHandle)
    {
        return handleHelper.getHandlesFromWithinGroup(groupHandle);
    }

    int groupSet(PVGroup &pvgroup);
    int groupSet(const unsigned int groupHandle, PVGroup &pvgroup);

    int groupMonitorStart(const unsigned int  groupHandle, std::vector<int> &statusV)
    {
        std::vector<unsigned int> monitorIDV;
        return groupMonitorStart(groupHandle, statusV, monitorIDV);
    }

    int groupMonitorStart(const unsigned int  groupHandle, std::vector<int> &statusV, std::vector<MonitorPolicy> &mpV);
    int groupMonitorStart(const unsigned int  groupHandle, std::vector<int> &statusV, std::vector<unsigned int> &monitorIDV);
    int groupMonitorStop (const unsigned int  groupHandle, std::vector<int> &statusV);

    unsigned int groupGetNPV(unsigned int _gHandle)
    {
        return handleHelper.getGroupNPV(_gHandle);
    }
    unsigned int groupGetNPV(const char * _gName)
    {
        return handleHelper.getGroupNPV(_gName);
    }
    unsigned int groupGetNPV(const char * _gName, ca_client_context * ccc)
    {
        return handleHelper.getGroupNPV(_gName, ccc);
    }

#if HAVE_PYTHON_H
    void loadSFGroups(std::string suff);
#endif

};

#endif // CAFE_H