Connection time optimized

autogen_cafepy3_release.sh

@@ -27,7 +27,7 @@ export CAFE_EPICS_V_MINOR=$EBMIN
 export CAFE_EPICS_V_PATCH=$EBPAT
 
 #--enable-boost --with-boost=/afs/psi.ch/intranet/Controls/BD/deps/boost_1_57_0 \
-CYCAFE_VERSION=pycafe-1.3.0-final-1
+CYCAFE_VERSION=pycafe-1.5.0-final-1
 
 ./configure \
     --prefix=/opt/gfa/cafe/python/python-3.5/${CYCAFE_VERSION}/ \

autogen_cafepy3_release_noqt.sh

@@ -27,8 +27,8 @@ export CAFE_EPICS_V_MINOR=$EBMIN
 export CAFE_EPICS_V_PATCH=$EBPAT
 
 #--enable-boost --with-boost=/afs/psi.ch/intranet/Controls/BD/deps/boost_1_57_0 \
-CAFE_VERSION=cafe-1.0.0-beta-1
-CYCAFE_VERSION=pycafe-noqt-1.0.0-beta-1
+CAFE_VERSION=cafe-1.5.0-final-1
+CYCAFE_VERSION=pycafe-noqt-1.5.0-final-1
 
 ./configure \
     --prefix=/opt/gfa/cafe/python/python-3.5/${CYCAFE_VERSION}/ \

autogen_rel.sh

@@ -26,7 +26,7 @@ export CAFE_EPICS_V_MINOR=$EBMIN
 export CAFE_EPICS_V_PATCH=$EBPAT
  
 
-CAFE_VERSION=cafe-1.3.0-final-2
+CAFE_VERSION=cafe-1.5.0-final-1
 
 
 ./configure \

autogen_rel_noqt.sh

@@ -27,7 +27,7 @@ export CAFE_EPICS_V_PATCH=$EBPAT
 
 #--enable-boost --with-boost=/afs/psi.ch/intranet/Controls/BD/deps/boost_1_57_0 \
 
-CAFE_VERSION=cafe-noqt-1.1.0-final-1
+CAFE_VERSION=cafe-noqt-1.5.0-final-1
 
 
 ./configure \

examples/cafeTest/cafeTest.cc

@@ -5,7 +5,6 @@
 
 #include "callbacks.h" //ca callback funtions
 
-
 // Test with 6 PVS
 // PV_X1,PV_Y1 are scalar numerics
 // PV_WF is a vector numeric
@@ -15,7 +14,7 @@
 
 #define PV_X1      "ARIDI-BPM-01LE:X-AVG"
 #define PV_Y1      "ARIDI-BPM-01LE:Y-AVG"
-#define PV_WF      "ARIDI-BPM-01LE:WF-INT-1"   //256 elements
+#define PV_WF      "ARIDI-BPM-01LE:WF-INT-2"   //256 elements
 #define PV_MBBI    "ARIDI-BPM-01LE:GET-ENABLE" //mmbi
 #define PV_X1_DESC "ARIDI-BPM-01LE:X-AVG.DESC" //dbr_string_t
 #define PV_JOKE    "PV:JOKE"
@@ -255,7 +254,7 @@ int main( int argc, char *argv[] )
 			cout << "Value d=" << d << endl; 
 		}
 		
-		//Handle and PV Mappring, i.e., to interchange between handle and pvName
+		//Handle and PV Mapping, i.e., to interchange between handle and pvName
 		             handle = cafe->getHandleFromPV(pvArray[0].c_str());
 		const char * pvName = cafe->getPVFromHandle(handle);
 		  
@@ -263,7 +262,7 @@ int main( int argc, char *argv[] )
 		
 		//------------------------------------------------------------	
 		//Set data
-		//The set method is able to intrepret all data types, and can 
+		//The set method is able to interpret all data types, and can 
 		//cater for scalar values and arrays
 		//------------------------------------------------------------
 	
@@ -614,7 +613,7 @@ int main( int argc, char *argv[] )
 		
 		PVDataHolder pvDat;
 		status= cafe->get(PV_MBBI, pvDat);	 
-		cout << "VALUE as string:         " << pvDat.getAsString() << endl;
+		cout << "VALUE as string:          " << pvDat.getAsString() << endl;
 		cout << "VALUE as int:             " << pvDat.getAsUShort() << endl;
 		cout << "Integer Value as String:  " << pvDat.getEnumIntegerValueAsString() << endl;
 		

include/PVCtrlHolder.h

@@ -42,7 +42,8 @@ private:
     CAFE_DATATYPE_UNION lowerCtrlLimit;
 
     Helper helper;
-  
+   
+	
     public:
 	
     PVCtrlHolder(){
@@ -205,12 +206,13 @@ private:
         print(nelem) ;
     }
 
+
     void print(unsigned int  nelemToPrint) {
 
         nelemToPrint=min(nelemToPrint,nelem);
         std::cout <<  "------------------------------------------" << std::endl;
         std::cout <<  "PVCtrlHolder:" << std::endl;
-	std::cout <<  "processVariable= "  << pv << std::endl;	
+	      std::cout <<  "processVariable= "  << pv << std::endl;	
         if (strcmp(pvAlias,pv)) {
             std::cout <<  "pvAlias        = "  << pvAlias << std::endl;
         }
@@ -220,11 +222,15 @@ private:
                 << " (" << dataType << ") "  << std::endl;
         std::cout <<  "dbrTypeRequest = "  << dbr_type_to_text(dbrDataType)<< std::endl;
         if (dataType!=CAFE_NO_ACCESS || dataType != CAFE_TYPENOTCONN) {
-	std::cout <<  "nelem          = "  << nelem << std::endl;
+	       std::cout <<  "nelem          = "  << nelem << std::endl;
 
-	std::cout <<  "alarmStatus    = "  << alarmStatus << std::endl;
-	std::cout <<  "alarmSeverity  = "  << alarmSeverity << std::endl;
-	std::cout <<  "precision      = "  << precision << std::endl;
+	     //std::cout <<  "alarmStatus    = "  << alarmStatus << " [" <<  acond.asString(alarmStatus)<< "]" << std::endl;
+	     //std::cout <<  "alarmSeverity  = "  << alarmSeverity << " [" << aseve.asString(alarmSeverity) << "]"<< std::endl;
+	      std::cout <<  "alarmStatus    = " << acond.asString(alarmStatus)  << " ("  <<  alarmStatus <<  ")" << std::endl;
+        std::cout <<  "alarmSeverity  = " << aseve.asString(alarmSeverity) << " (" <<alarmSeverity <<  ")" << std::endl;
+
+	
+	      std::cout <<  "precision      = "  << precision << std::endl;
         std::cout <<  "units          = "  << units << std::endl;
         /*
         if (dataType==CAFE_DOUBLE){

include/PVDataHolder.h

@@ -159,6 +159,7 @@ public:
             std::cout <<  "Variable has not been applied to a get operation!" << std::endl;
             return;
         }
+       
         std::cout <<  "------------------------------------------" << std::endl;
         //std::cout <<  "PVDataHolder:" << std::endl;
 
@@ -171,7 +172,8 @@ public:
         std::cout <<  "attrib         = "  << attrib << std::endl;
         std::cout <<  "dataType       = "  << cafeDataTypeCode.message(dataType).c_str()
                 << " (" << dataType << ") "  << std::endl;
-        std::cout <<  "dbrTypeRequest = "  << dbr_type_to_text(dbrDataType)<< std::endl;
+        std::cout <<  "dbrTypeRequest = "  << dbr_type_to_text(dbrDataType)
+                  << " (" << dbrDataType << ") " << std::endl;
 
         //std::cout <<  "dataType = "  << CAFEDataTypeCode.message(dataType).c_str() << std::endl;
 
@@ -187,15 +189,16 @@ public:
         }
 
         if (dbr_type_is_STS(dbrDataType) || dbr_type_is_TIME(dbrDataType) ) {
-            std::cout <<  "alarmStatus    = "  << alarmStatus << std::endl;
-            std::cout <<  "alarmSeverity  = "  << alarmSeverity << std::endl;
+           
+            std::cout <<  "alarmStatus    = " << acond.asString(alarmStatus)  << " ("  <<  alarmStatus <<  ")" << std::endl;
+            std::cout <<  "alarmSeverity  = " << aseve.asString(alarmSeverity) << " (" <<alarmSeverity <<  ")" << std::endl;
 
             if (dbr_type_is_TIME(dbrDataType)) {
             std::cout <<  "epicsTimeStamp = "  << ts.secPastEpoch << " sec. and " << ts.nsec << " nsec" << std::endl;
             }
         }
         if(beamEventNo!=0) {std::cout <<  "beamEventNo    = "  << beamEventNo << std::endl;};
-        std::cout <<  "status         = "  << cafeStatusCode.message(status).c_str() << std::endl;
+        std::cout <<  "status         = "  << cafeStatusCode.message(status).c_str() << " (" << status << ") " << std::endl;
         std::cout <<  "value(s)       = "  ;
 	
         switch (dataType) {

include/PVGroup.h

@@ -156,6 +156,8 @@ public:
             CAFEStatus cstat; cstat.report(statusGroup);
         }
         for (unsigned int  i=0; i<npvToPrint; ++i) {
+				    std::cout <<  "------------------------------------------" << std::endl;
+            std::cout <<  "Element [" << i << "] of " << npvToPrint << " in group: " << name << endl;
             pvdata[i].print();
         }
     }
@@ -169,6 +171,8 @@ public:
             CAFEStatus cstat; cstat.report(statusGroup);
         }
         for (unsigned int  i=0; i<npvToPrint; ++i) {
+						std::cout <<  "------------------------------------------" << std::endl;
+            std::cout <<  "Element [" << i << "] of " << npvToPrint << " in group: " << name << endl;
             pvdata[i].print(min(maxNelemWF,pvdata[i].getNelem()));
         }
     }

include/PVHolder.h

@@ -48,6 +48,9 @@ protected:
     short alarmStatus;   //alarm.h 0-22 0=NO_ALARM
     short alarmSeverity; //alarm.h 0=NO_ALARM 1=MINOR 2=MAJOR 3=INVALID
 
+    CAFEGlobalAlarmCondition acond;
+	  CAFEGlobalAlarmSeverity  aseve;
+
     unsigned int  userNo; //e.g. add handle
 
     unsigned int  beamEventNo;
@@ -98,10 +101,14 @@ public:
 
    boost::shared_ptr<vector<double> > ValVD_ptr;
    boost::shared_ptr<vector<float> > ValVF_ptr;
-   //boost::shared_ptr<vector<short> > ValVS_ptr;
+   boost::shared_ptr<vector<short> > ValVS_ptr;
    boost::shared_ptr<vector<int> > ValVI_ptr;
-   //boost::shared_ptr<vector<unsigned char> > ValVC_ptr;
-   //boost::shared_ptr<vector<unsigned short> > ValVUS_ptr;
+	 boost::shared_ptr<vector<long> > ValVL_ptr;
+	 boost::shared_ptr<vector<unsigned long> > ValVUL_ptr;
+	 boost::shared_ptr<vector<long long> > ValVLL_ptr;
+	 boost::shared_ptr<vector<unsigned long long> > ValVULL_ptr;	
+   boost::shared_ptr<vector<unsigned char> > ValVC_ptr;
+   boost::shared_ptr<vector<unsigned short> > ValVUS_ptr;
    boost::shared_ptr<vector<string> > ValVStr_ptr;
 
    typedef boost::shared_ptr<double []> ValDPtr;
@@ -135,7 +142,7 @@ public:
         return;
     };
 
-
+	void setBSStatus(int st) {status=st;} //for bsread
 
     const char  * getPV() const {return pv;};
     const char  * getPVName() const {return pv;};
@@ -148,12 +155,15 @@ public:
     CAFE_DATATYPE_UNION_SEQ getVal() const {return val.get();};
 
 
-    short getAlarmStatus() const {return alarmStatus;};
+    short getAlarmStatus()   const {return alarmStatus;};
     short getAlarmSeverity() const {return alarmSeverity;};
+		
+    string getAlarmStatusAsString()   {return acond.asString(alarmStatus);};
+    string getAlarmSeverityAsString()  {return aseve.asString(alarmSeverity);};
 
     unsigned int  getBeamEventNo() const {return beamEventNo;};
     bool getRule() const {return rule;};
-	bool getHasAlarm() const{return hasAlarm;};
+	  bool getHasAlarm() const{return hasAlarm;};
     int  getStatus() const {return status;};
     CAFE_DATATYPE getDataTypeClient() const {return dataType;};
     CAFE_DATATYPE getDataType() const {return dataType;};
@@ -194,6 +204,8 @@ public:
     void setString(std::string     str) {strcpy(val[0].str,str.c_str()); dataType=CAFE_STRING;};
     void setDouble(double d) {val[0].d=d; dataType=CAFE_DOUBLE;};
     void setInt(int    l) {val[0].l=l; dataType=CAFE_LONG;};
+		
+		
 	  void setVString(vector<std::string>  Vstr) {
 		   if(Vstr.size()!=nelem) {nelem=Vstr.size();}
 		   for (unsigned int  i=0; i<nelem; ++ i) {
@@ -206,6 +218,64 @@ public:
 		  if(Vl.size()!=nelem) {nelem=Vl.size();}
 		  for (unsigned int  i=0; i<nelem; ++ i) {
 			val[i].l=Vl[i];} dataType=CAFE_LONG;};
+			
+		
+		
+		
+	  void set(vector<std::string>  Vstr) {
+		   if(Vstr.size()!=nelem) {nelem=Vstr.size();}
+		   for (unsigned int  i=0; i<nelem; ++ i) {
+			 strcpy(val[i].str,Vstr[i].c_str());} dataType=CAFE_STRING;};
+	  void set(vector<double> Vd) {
+		  if(Vd.size()!=nelem) {nelem=Vd.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].d=Vd[i];} dataType=CAFE_DOUBLE;};
+		void set(vector<float> Vf) {
+		  if(Vf.size()!=nelem) {nelem=Vf.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].f=Vf[i];} dataType=CAFE_FLOAT;};	
+			
+	  void set   (vector<int>    Vl) {
+		  if(Vl.size()!=nelem) {nelem=Vl.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].l=Vl[i];} dataType=CAFE_LONG;};
+			
+		void set   (vector<long>    Vl) {
+		  if(Vl.size()!=nelem) {nelem=Vl.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].l=Vl[i];} dataType=CAFE_LONG;};	
+			
+		void set   (vector<unsigned long>    Vul) {
+		  if(Vul.size()!=nelem) {nelem=Vul.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].d=Vul[i];} dataType=CAFE_DOUBLE;};		
+			
+		void set   (vector<long long>    Vll) {
+		  if(Vll.size()!=nelem) {nelem=Vll.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].d=Vll[i];} dataType=CAFE_DOUBLE;};	
+				
+		void set   (vector<unsigned long long>    Vull) {
+		  if(Vull.size()!=nelem) {nelem=Vull.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].d=Vull[i];} dataType=CAFE_DOUBLE;};	
+			
+		void set   (vector<short>    Vs) {
+		  if(Vs.size()!=nelem) {nelem=Vs.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].s=Vs[i];} dataType=CAFE_SHORT;};	
+			
+		void set   (vector<unsigned short>    Vus) {
+		  if(Vus.size()!=nelem) {nelem=Vus.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].us=Vus[i];} dataType=CAFE_ENUM;};		
+			
+		void set   (vector<unsigned char>    Vc) {
+		  if(Vc.size()!=nelem) {nelem=Vc.size();}
+		  for (unsigned int  i=0; i<nelem; ++ i) {
+			val[i].ch=Vc[i];} dataType=CAFE_CHAR;};	
+			
+			
 
     void set(unsigned int    l)  {val[0].l= (int) l; dataType=CAFE_LONG;};
     void set(unsigned short  us) {val[0].us=us; dataType=CAFE_ENUM;};
@@ -287,9 +357,10 @@ public:
     }
 
     boost::shared_ptr<vector<double> > getAsVDouble(){
-    #define __METHOD__  "PVHolder::getVDouble "
+    #define __METHOD__  "PVHolder::getAsVDouble "
 
         ValVD_ptr.reset(new vector<double>());
+				ValVD_ptr->reserve(nelem);
 
         switch (dataType)
         {
@@ -322,9 +393,10 @@ public:
     }
 
     boost::shared_ptr<vector<float> > getAsVFloat(){
-    #define __METHOD__  "PVHolder::getVFloat "
+    #define __METHOD__  "PVHolder::getAsVFloat "
 
         ValVF_ptr.reset(new vector<float>());
+				ValVF_ptr->reserve(nelem);
 
         switch (dataType)
         {
@@ -357,6 +429,10 @@ public:
         //cout << "size/// " << vf[0].size() << endl;
         //cout << vf[0][0] << " val " << val[0].f << endl;
         //cout << vf[0][1] << " val " << val[1].f << endl;
+				//vector<float>  vf= *ValVF_ptr.get();
+        //cout << "size/// " << vf.size() << endl;
+        //cout << vf[0] << " val " << val[0].f << endl;
+        //cout << vf[1] << " val " << val[1].f << endl;
 
     return  ValVF_ptr;
     #undef __METHOD__
@@ -364,10 +440,11 @@ public:
 
 
     boost::shared_ptr<vector<int> > getAsVInt(){
-    #define __METHOD__  "PVHolder::getVInt "
+    #define __METHOD__  "PVHolder::getAsVInt "
 
         ValVI_ptr.reset(new vector<int>());
-
+				ValVI_ptr->reserve(nelem);
+					
         switch (dataType)
         {
             case CAFE_DOUBLE:
@@ -398,16 +475,338 @@ public:
     #undef __METHOD__
     }
 
+
+		
+    boost::shared_ptr<vector<long> > getAsVLong(){
+    #define __METHOD__  "PVHolder::getAsVInt "
+
+        ValVL_ptr.reset(new vector<long>());
+				ValVL_ptr->reserve(nelem);
+
+        switch (dataType)
+        {
+            case CAFE_DOUBLE:
+                for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].d);}
+                break;
+            case CAFE_FLOAT:
+                for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].f);}
+                break;
+            case CAFE_LONG:
+                for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].l);}
+                break;
+            case CAFE_SHORT:
+                for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].s);}
+                break;
+            case CAFE_ENUM:
+                for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].us);}
+                break;
+            case CAFE_CHAR:
+                for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back((long) val[i].ch);}
+                break;
+            case CAFE_STRING:
+                default:
+                for (unsigned i=0; i<nelem; ++i) {ValVL_ptr->push_back( getAsLong(i));}
+                break;
+        }
+
+    return  ValVL_ptr;
+    #undef __METHOD__
+    }
+
+		
+    boost::shared_ptr<vector<unsigned long> > getAsVULong(){
+    #define __METHOD__  "PVHolder::getAsVInt "
+
+        ValVUL_ptr.reset(new vector<unsigned long>());
+				ValVUL_ptr->reserve(nelem);
+
+        switch (dataType)
+        {
+            case CAFE_DOUBLE:
+                for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].d);}
+                break;
+            case CAFE_FLOAT:
+                for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].f);}
+                break;
+            case CAFE_LONG:
+                for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].l);}
+                break;
+            case CAFE_SHORT:
+                for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].s);}
+                break;
+            case CAFE_ENUM:
+                for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].us);}
+                break;
+            case CAFE_CHAR:
+                for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back((unsigned long) val[i].ch);}
+                break;
+            case CAFE_STRING:
+                default:
+                for (unsigned i=0; i<nelem; ++i) {ValVUL_ptr->push_back( getAsULong(i));}
+                break;
+        }
+
+    return  ValVUL_ptr;
+    #undef __METHOD__
+    }
+
+		
+		
+		
+    boost::shared_ptr<vector<long long> > getAsVLongLong(){
+    #define __METHOD__  "PVHolder::getAsVLongLong "
+
+        ValVLL_ptr.reset(new vector<long long>());
+				ValVLL_ptr->reserve(nelem);
+
+        switch (dataType)
+        {
+            case CAFE_DOUBLE:
+                for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].d);}
+                break;
+            case CAFE_FLOAT:
+                for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].f);}
+                break;
+            case CAFE_LONG:
+                for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].l);}
+                break;
+            case CAFE_SHORT:
+                for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].s);}
+                break;
+            case CAFE_ENUM:
+                for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].us);}
+                break;
+            case CAFE_CHAR:
+                for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back((long long) val[i].ch);}
+                break;
+            case CAFE_STRING:
+                default:
+                for (unsigned i=0; i<nelem; ++i) {ValVLL_ptr->push_back( getAsLongLong(i));}
+                break;
+        }
+
+    return  ValVLL_ptr;
+    #undef __METHOD__
+    }
+
+		
+    boost::shared_ptr<vector<unsigned long long> > getAsVULongLong(){
+    #define __METHOD__  "PVHolder::getAsVLongLong "
+
+        ValVULL_ptr.reset(new vector<unsigned long long>());
+        ValVULL_ptr->reserve(nelem);
+
+        switch (dataType)
+        {
+            case CAFE_DOUBLE:
+                for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].d);}
+                break;
+            case CAFE_FLOAT:
+                for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].f);}
+                break;
+            case CAFE_LONG:
+                for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].l);}
+                break;
+            case CAFE_SHORT:
+                for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].s);}
+                break;
+            case CAFE_ENUM:
+                for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].us);}
+                break;
+            case CAFE_CHAR:
+                for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back((unsigned long long) val[i].ch);}
+                break;
+            case CAFE_STRING:
+                default:
+                for (unsigned i=0; i<nelem; ++i) {ValVULL_ptr->push_back( getAsULongLong(i));}
+                break;
+        }
+
+    return  ValVULL_ptr;
+    #undef __METHOD__
+    }
+
+		
+		
+		
+		
+    boost::shared_ptr<vector<short> > getAsVShort(){
+    #define __METHOD__  "PVHolder::getAsVShort "
+
+        ValVS_ptr.reset(new vector<short>());
+				ValVS_ptr->reserve(nelem);
+				
+        switch (dataType)
+        {
+            case CAFE_DOUBLE:
+                for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].d);}
+                break;
+            case CAFE_FLOAT:
+                for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].f);}
+                break;
+            case CAFE_LONG:
+                for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].l);}
+                break;
+            case CAFE_SHORT:
+                for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back(val[i].s);}
+                break;
+            case CAFE_ENUM:
+                for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((short) val[i].us);}
+                break;
+            case CAFE_CHAR:
+                for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back((unsigned short) val[i].ch);}
+                break;
+            case CAFE_STRING:
+                default:
+                for (unsigned i=0; i<nelem; ++i) {ValVS_ptr->push_back( getAsShort(i));}
+                break;
+        }
+
+    return  ValVS_ptr;
+    #undef __METHOD__
+    }
+
+		
+		
+    boost::shared_ptr<vector<unsigned short> > getAsVUShort(){
+    #define __METHOD__  "PVHolder::getAsVUShort "
+
+        ValVUS_ptr.reset(new vector<unsigned short>());
+				ValVUS_ptr->reserve(nelem);
+
+        switch (dataType)
+        {
+            case CAFE_DOUBLE:
+                for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].d);}
+                break;
+            case CAFE_FLOAT:
+                for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].f);}
+                break;
+            case CAFE_LONG:
+                for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].l);}
+                break;
+            case CAFE_SHORT:
+                for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short)val[i].s);}
+                break;
+            case CAFE_ENUM:
+                for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back( val[i].us);}
+                break;
+            case CAFE_CHAR:
+                for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back((unsigned short) val[i].ch);}
+                break;
+            case CAFE_STRING:
+                default:
+                for (unsigned i=0; i<nelem; ++i) {ValVUS_ptr->push_back( getAsUShort(i));}
+                break;
+        }
+
+    return  ValVUS_ptr;
+    #undef __METHOD__
+    }
+
+		
+    boost::shared_ptr<vector<unsigned char> > getAsVUChar(){
+    #define __METHOD__  "PVHolder::getAsVUChar "
+
+        ValVC_ptr.reset(new vector<unsigned char>());
+				ValVC_ptr->reserve(nelem);
+
+        switch (dataType)
+        {
+            case CAFE_DOUBLE:
+                for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].d);}
+                break;
+            case CAFE_FLOAT:
+                for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].f);}
+                break;
+            case CAFE_LONG:
+                for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].l);}
+                break;
+            case CAFE_SHORT:
+                for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char)val[i].s);}
+                break;
+            case CAFE_ENUM:
+                for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back( (unsigned char)val[i].us);}
+                break;
+            case CAFE_CHAR:
+                for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back((unsigned char) val[i].ch);}
+                break;
+            case CAFE_STRING:
+                default:
+                for (unsigned i=0; i<nelem; ++i) {ValVC_ptr->push_back( (unsigned char) getAsChar(i));}
+                break;
+        }
+
+    return  ValVC_ptr;
+    #undef __METHOD__
+    }
+
     boost::shared_ptr<vector<string> > getAsVString(){
-    #define __METHOD__  "PVHolder::getVString "
+    #define __METHOD__  "PVHolder::getAsVString "
 
         ValVStr_ptr.reset(new vector<string>());
+				ValVStr_ptr->reserve(nelem);
         for (unsigned i=0; i<nelem; ++i) {ValVStr_ptr->push_back( getAsString(i));}
 
     return  ValVStr_ptr;
     #undef __METHOD__
     }
 
+
+    
+    vector<string> getAsVectorString() {		
+			boost::shared_ptr<vector<string> >  spVs = getAsVString();		 
+			return *spVs.get();
+		}
+    vector<float> getAsVectorFloat() {
+			boost::shared_ptr<vector<float> >  spVf = getAsVFloat();		 
+			return *spVf.get();
+		}		 
+    vector<double> getAsVectorDouble() {		
+			boost::shared_ptr<vector<double> >  spVd = getAsVDouble();		 
+			return *spVd.get();
+		}
+    vector<int> getAsVectorInt() {
+			boost::shared_ptr<vector<int> >  spVi = getAsVInt();		 
+			return *spVi.get();
+		}
+		
+		vector<long> getAsVectorLong() {
+			boost::shared_ptr<vector<long> >  spVl = getAsVLong();		 
+			return *spVl.get();
+		}		
+		
+		vector<unsigned long> getAsVectorULong() {
+			boost::shared_ptr<vector<unsigned long> >  spVul = getAsVULong();		 
+			return *spVul.get();
+		}
+		
+		vector<long long> getAsVectorLongLong() {
+			boost::shared_ptr<vector<long long> >  spVll = getAsVLongLong();		 
+			return *spVll.get();
+		}		
+		
+		vector<unsigned long long> getAsVectorULongLong() {
+			boost::shared_ptr<vector<unsigned long long> >  spVull = getAsVULongLong();		 
+			return *spVull.get();
+		}
+		
+		
+		vector<short> getAsVectorShort() {
+			boost::shared_ptr<vector<short> >  spVsh = getAsVShort();		 
+			return *spVsh.get();
+		}
+  
+	  vector<unsigned short> getAsVectorUShort() {
+			boost::shared_ptr<vector<unsigned short> >  spVus = getAsVUShort();		 
+			return *spVus.get();
+		}
+  	 vector<unsigned char> getAsVectorUChar() {
+			boost::shared_ptr<vector<unsigned char> >  spVc = getAsVUChar();		 
+			return *spVc.get();
+		}
+	
+
     ValDPtr getDouble(){
     #define __METHOD__  "PVHolder::getDouble "
         if (dataType!=CAFE_DOUBLE) {

include/PyCafe2_api.h

@@ -0,0 +1,115 @@
+/* Generated by Cython 0.23.4 */
+
+#ifndef __PYX_HAVE_API__PyCafe
+#define __PYX_HAVE_API__PyCafe
+#include "Python.h"
+
+static void (*__pyx_api_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
+#define py_cb_wrapper __pyx_api_f_6PyCafe_py_cb_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
+#define py_cb_ctrl_wrapper __pyx_api_f_6PyCafe_py_cb_ctrl_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
+#define py_cb_handle_wrapper __pyx_api_f_6PyCafe_py_cb_handle_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
+#define py_cb_handle_monid_wrapper __pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper)(unsigned int) = 0;
+#define py_cb_handle_get_wrapper __pyx_api_f_6PyCafe_py_cb_handle_get_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper)(unsigned int) = 0;
+#define py_cb_handle_put_wrapper __pyx_api_f_6PyCafe_py_cb_handle_put_wrapper
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportFunction
+#define __PYX_HAVE_RT_ImportFunction
+static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+    PyObject *d = 0;
+    PyObject *cobj = 0;
+    union {
+        void (*fp)(void);
+        void *p;
+    } tmp;
+    d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
+    if (!d)
+        goto bad;
+    cobj = PyDict_GetItemString(d, funcname);
+    if (!cobj) {
+        PyErr_Format(PyExc_ImportError,
+            "%.200s does not export expected C function %.200s",
+                PyModule_GetName(module), funcname);
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x02070000
+    if (!PyCapsule_IsValid(cobj, sig)) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
+        goto bad;
+    }
+    tmp.p = PyCapsule_GetPointer(cobj, sig);
+#else
+    {const char *desc, *s1, *s2;
+    desc = (const char *)PyCObject_GetDesc(cobj);
+    if (!desc)
+        goto bad;
+    s1 = desc; s2 = sig;
+    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
+    if (*s1 != *s2) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, desc);
+        goto bad;
+    }
+    tmp.p = PyCObject_AsVoidPtr(cobj);}
+#endif
+    *f = tmp.fp;
+    if (!(*f))
+        goto bad;
+    Py_DECREF(d);
+    return 0;
+bad:
+    Py_XDECREF(d);
+    return -1;
+}
+#endif
+
+
+static int import_PyCafe(void) {
+  PyObject *module = 0;
+  module = __Pyx_ImportModule("PyCafe");
+  if (!module) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_get_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper, "void (unsigned int)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_put_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper, "void (unsigned int)") < 0) goto bad;
+  Py_DECREF(module); module = 0;
+  return 0;
+  bad:
+  Py_XDECREF(module);
+  return -1;
+}
+
+#endif /* !__PYX_HAVE_API__PyCafe */

include/PyCafe2_api_March7.h

@@ -0,0 +1,107 @@
+#ifndef __PYX_HAVE_API__PyCafe
+#define __PYX_HAVE_API__PyCafe
+#include "Python.h"
+
+static void (*__pyx_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
+#define py_cb_wrapper __pyx_f_6PyCafe_py_cb_wrapper
+static void (*__pyx_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
+#define py_cb_ctrl_wrapper __pyx_f_6PyCafe_py_cb_ctrl_wrapper
+static void (*__pyx_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
+#define py_cb_handle_wrapper __pyx_f_6PyCafe_py_cb_handle_wrapper
+static void (*__pyx_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
+#define py_cb_handle_monid_wrapper __pyx_f_6PyCafe_py_cb_handle_monid_wrapper
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportFunction
+#define __PYX_HAVE_RT_ImportFunction
+static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+    PyObject *d = 0;
+    PyObject *cobj = 0;
+    union {
+        void (*fp)(void);
+        void *p;
+    } tmp;
+    d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
+    if (!d)
+        goto bad;
+    cobj = PyDict_GetItemString(d, funcname);
+    if (!cobj) {
+        PyErr_Format(PyExc_ImportError,
+            "%.200s does not export expected C function %.200s",
+                PyModule_GetName(module), funcname);
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x02070000
+    if (!PyCapsule_IsValid(cobj, sig)) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
+        goto bad;
+    }
+    tmp.p = PyCapsule_GetPointer(cobj, sig);
+#else
+    {const char *desc, *s1, *s2;
+    desc = (const char *)PyCObject_GetDesc(cobj);
+    if (!desc)
+        goto bad;
+    s1 = desc; s2 = sig;
+    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
+    if (*s1 != *s2) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, desc);
+        goto bad;
+    }
+    tmp.p = PyCObject_AsVoidPtr(cobj);}
+#endif
+    *f = tmp.fp;
+    if (!(*f))
+        goto bad;
+    Py_DECREF(d);
+    return 0;
+bad:
+    Py_XDECREF(d);
+    return -1;
+}
+#endif
+
+
+static int import_PyCafe(void) {
+  PyObject *module = 0;
+  module = __Pyx_ImportModule("PyCafe");
+  if (!module) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
+  Py_DECREF(module); module = 0;
+  return 0;
+  bad:
+  Py_XDECREF(module);
+  return -1;
+}
+
+#endif /* !__PYX_HAVE_API__PyCafe */

include/PyCafe3_api_March7.h

@@ -0,0 +1,109 @@
+/* Generated by Cython 0.23.4 */
+
+#ifndef __PYX_HAVE_API__PyCafe
+#define __PYX_HAVE_API__PyCafe
+#include "Python.h"
+
+static void (*__pyx_api_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
+#define py_cb_wrapper __pyx_api_f_6PyCafe_py_cb_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
+#define py_cb_ctrl_wrapper __pyx_api_f_6PyCafe_py_cb_ctrl_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
+#define py_cb_handle_wrapper __pyx_api_f_6PyCafe_py_cb_handle_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
+#define py_cb_handle_monid_wrapper __pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportFunction
+#define __PYX_HAVE_RT_ImportFunction
+static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+    PyObject *d = 0;
+    PyObject *cobj = 0;
+    union {
+        void (*fp)(void);
+        void *p;
+    } tmp;
+    d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
+    if (!d)
+        goto bad;
+    cobj = PyDict_GetItemString(d, funcname);
+    if (!cobj) {
+        PyErr_Format(PyExc_ImportError,
+            "%.200s does not export expected C function %.200s",
+                PyModule_GetName(module), funcname);
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x02070000
+    if (!PyCapsule_IsValid(cobj, sig)) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
+        goto bad;
+    }
+    tmp.p = PyCapsule_GetPointer(cobj, sig);
+#else
+    {const char *desc, *s1, *s2;
+    desc = (const char *)PyCObject_GetDesc(cobj);
+    if (!desc)
+        goto bad;
+    s1 = desc; s2 = sig;
+    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
+    if (*s1 != *s2) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, desc);
+        goto bad;
+    }
+    tmp.p = PyCObject_AsVoidPtr(cobj);}
+#endif
+    *f = tmp.fp;
+    if (!(*f))
+        goto bad;
+    Py_DECREF(d);
+    return 0;
+bad:
+    Py_XDECREF(d);
+    return -1;
+}
+#endif
+
+
+static int import_PyCafe(void) {
+  PyObject *module = 0;
+  module = __Pyx_ImportModule("PyCafe");
+  if (!module) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
+  Py_DECREF(module); module = 0;
+  return 0;
+  bad:
+  Py_XDECREF(module);
+  return -1;
+}
+
+#endif /* !__PYX_HAVE_API__PyCafe */

include/PyCafe3_api_Sep22.h

@@ -0,0 +1,115 @@
+/* Generated by Cython 0.23.4 */
+
+#ifndef __PYX_HAVE_API__PyCafe
+#define __PYX_HAVE_API__PyCafe
+#include "Python.h"
+
+static void (*__pyx_api_f_6PyCafe_py_cb_wrapper)(PVDataHolder, unsigned int, std::string) = 0;
+#define py_cb_wrapper __pyx_api_f_6PyCafe_py_cb_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper)(PVCtrlHolder, unsigned int, std::string) = 0;
+#define py_cb_ctrl_wrapper __pyx_api_f_6PyCafe_py_cb_ctrl_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_wrapper)(unsigned int) = 0;
+#define py_cb_handle_wrapper __pyx_api_f_6PyCafe_py_cb_handle_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper)(unsigned int, unsigned long) = 0;
+#define py_cb_handle_monid_wrapper __pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper)(unsigned int) = 0;
+#define py_cb_handle_get_wrapper __pyx_api_f_6PyCafe_py_cb_handle_get_wrapper
+static void (*__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper)(unsigned int) = 0;
+#define py_cb_handle_put_wrapper __pyx_api_f_6PyCafe_py_cb_handle_put_wrapper
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+#ifndef __PYX_HAVE_RT_ImportFunction
+#define __PYX_HAVE_RT_ImportFunction
+static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
+    PyObject *d = 0;
+    PyObject *cobj = 0;
+    union {
+        void (*fp)(void);
+        void *p;
+    } tmp;
+    d = PyObject_GetAttrString(module, (char *)"__pyx_capi__");
+    if (!d)
+        goto bad;
+    cobj = PyDict_GetItemString(d, funcname);
+    if (!cobj) {
+        PyErr_Format(PyExc_ImportError,
+            "%.200s does not export expected C function %.200s",
+                PyModule_GetName(module), funcname);
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x02070000
+    if (!PyCapsule_IsValid(cobj, sig)) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
+        goto bad;
+    }
+    tmp.p = PyCapsule_GetPointer(cobj, sig);
+#else
+    {const char *desc, *s1, *s2;
+    desc = (const char *)PyCObject_GetDesc(cobj);
+    if (!desc)
+        goto bad;
+    s1 = desc; s2 = sig;
+    while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
+    if (*s1 != *s2) {
+        PyErr_Format(PyExc_TypeError,
+            "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
+             PyModule_GetName(module), funcname, sig, desc);
+        goto bad;
+    }
+    tmp.p = PyCObject_AsVoidPtr(cobj);}
+#endif
+    *f = tmp.fp;
+    if (!(*f))
+        goto bad;
+    Py_DECREF(d);
+    return 0;
+bad:
+    Py_XDECREF(d);
+    return -1;
+}
+#endif
+
+
+static int import_PyCafe(void) {
+  PyObject *module = 0;
+  module = __Pyx_ImportModule("PyCafe");
+  if (!module) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_wrapper, "void (PVDataHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_ctrl_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_ctrl_wrapper, "void (PVCtrlHolder, unsigned int, std::string)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_wrapper, "void (unsigned int)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_monid_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_monid_wrapper, "void (unsigned int, unsigned long)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_get_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_get_wrapper, "void (unsigned int)") < 0) goto bad;
+  if (__Pyx_ImportFunction(module, "py_cb_handle_put_wrapper", (void (**)(void))&__pyx_api_f_6PyCafe_py_cb_handle_put_wrapper, "void (unsigned int)") < 0) goto bad;
+  Py_DECREF(module); module = 0;
+  return 0;
+  bad:
+  Py_XDECREF(module);
+  return -1;
+}
+
+#endif /* !__PYX_HAVE_API__PyCafe */

include/cafe.h

@@ -187,7 +187,7 @@ public:
 		int  calcDBPMStatus(int, int, string);
 
 
-		int  getDBPM(DBPMHolder &dbpm);
+		int  getBS(BSDataHolder &bsd);
 		int  getDBPM(DBPMKeeper &dbpm);
 		int  readDBPMOffsets(DBPMKeeper &dbpm);
 		
@@ -990,10 +990,22 @@ public:
 		return status;
     }
 
+    //Closes channels but does not delete handle
+		vector<unsigned int> closeDisconnectedChannelsFromWithinGroupV(const unsigned int groupHandle) {	
+			  vector<unsigned int> dhV=handleHelper.getDisconnectedHandlesFromWithinGroupV(groupHandle);
+				if (dhV.size() >0) {closeChannelsKeepHandles(dhV);}
+				return dhV;
+		}
+
+		vector<unsigned int> getDisconnectedHandlesFromWithinGroupV(const unsigned int groupHandle) {
+			return handleHelper.getDisconnectedHandlesFromWithinGroupV(groupHandle);
+		}
+
 		vector<unsigned int> getHandlesFromWithinGroupV(const unsigned int groupHandle) {
 			return handleHelper.getHandlesFromWithinGroupV(groupHandle);
 		}
 
+
 		unsigned int * getHandlesFromWithinGroup(const unsigned int groupHandle) {
 			return handleHelper.getHandlesFromWithinGroup(groupHandle);
 		}

include/cafeRoast.h

@@ -383,6 +383,135 @@ int setAndMatchMany(vector<unsigned int> handleSetV, vector<string> valSetV, vec
 
 
 
+
+int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_double_t> valSet, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                dbr_double_t tolerance, double timeout, bool printFlag){										
+						cafeDoppio.setMany   (handleSet,    DBR_DOUBLE, valSet, false);						
+						cafeSoluble.setManyString  (handleAction, valAction, false);																																										
+    return cafeDoppio.compareAndMatchMany(handleSet, DBR_DOUBLE, valSet, handleMatch, tolerance, timeout, printFlag);
+}
+
+
+int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_float_t> valSet, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                dbr_float_t tolerance, double timeout, bool printFlag){										
+								cafeFrappuccino.setMany   (handleSet,    DBR_FLOAT, valSet, false);						
+						    cafeSoluble.setManyString  (handleAction, valAction, false);																																										
+    return cafeFrappuccino.compareAndMatchMany(handleSet, DBR_FLOAT, valSet, handleMatch, tolerance, timeout, printFlag);														
+}
+
+
+int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_char_t> valSet, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                dbr_char_t tolerance, double timeout, bool printFlag){	
+								cafeCappuccino.setMany   (handleSet,    DBR_CHAR, valSet, false);						
+					    	cafeSoluble.setManyString  (handleAction, valAction, false);																																										
+    return cafeCappuccino.compareAndMatchMany(handleSet, DBR_CHAR, valSet, handleMatch, tolerance, timeout, printFlag);							    
+}
+
+
+int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_enum_t> valSet, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                dbr_enum_t tolerance, double timeout, bool printFlag){	
+								cafeEspresso.setMany   (handleSet,    DBR_ENUM, valSet, false);						
+					    	cafeSoluble.setManyString  (handleAction, valAction, false);																																										
+    return cafeEspresso.compareAndMatchMany(handleSet, DBR_ENUM, valSet, handleMatch, tolerance, timeout, printFlag);																
+}
+
+int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_short_t> valSet, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                dbr_short_t tolerance, double timeout, bool printFlag){	
+								cafeSchale.setMany   (handleSet,    DBR_SHORT, valSet, false);						
+					    	cafeSoluble.setManyString  (handleAction, valAction, false);																																										
+    return cafeSchale.compareAndMatchMany(handleSet, DBR_SHORT, valSet, handleMatch, tolerance, timeout, printFlag);																 
+}
+
+
+int gameSetAndMatch(vector<unsigned int> handleSet, vector<dbr_long_t> valSet, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                dbr_long_t tolerance, double timeout, bool printFlag){
+								cafeLatte.setMany   (handleSet,    DBR_LONG, valSet, false);						
+					    	cafeSoluble.setManyString  (handleAction, valAction, false);																																										
+    return cafeLatte.compareAndMatchMany(handleSet, DBR_LONG, valSet, handleMatch, tolerance, timeout, printFlag);																	   
+}
+
+
+int gameSetAndMatch(vector<unsigned int> handleSet, vector<long long> valSet, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                long long tolerance, double timeout, bool printFlag){		
+								
+		vector<dbr_double_t> valSetDoubleV;
+		valSetDoubleV.reserve(valSet.size());
+		
+		std::copy(valSet.begin(), valSet.end(), 
+          std::back_inserter(valSetDoubleV));
+					
+    dbr_double_t toleranceDouble = tolerance;						
+														
+    return gameSetAndMatch(handleSet, valSetDoubleV,
+													handleAction, valAction,  handleMatch, toleranceDouble, timeout, printFlag);
+}
+
+
+int gameSetAndMatch(vector<unsigned int> handleSetV, vector<string> valSetV, 
+								vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatchV,
+                string tolerance, double timeout, bool printFlag){
+#define __METHOD__ "gameSetAndMatch (vector<unsigned int> handleSetV, vector<string> valSetV, \
+                vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatchV, \
+                string tolerance, double timeout, bool printFlag)"
+
+    vector<dbr_double_t> valSetDoubleV;
+
+    istringstream ss;
+    dbr_double_t d=0;  dbr_double_t toleranceDouble = 0;
+		for (size_t i=0; i< valSetV.size(); ++i) {
+			d=0;
+    	ss.clear();
+    	ss.str(valSetV[i]);
+    	ss>>d;
+		
+    	if ( !ss.fail()) {
+        valSetDoubleV.push_back(d);
+    	}
+    	else {
+        cout << __METHOD__ << __LINE__ << endl;
+        cout << "***WARNING*** NO STRING TO DBR_DOUBLE CONVERSION " << endl;
+        cout << "***WARNING*** COULD NOT CONVERT: ";
+        cout << valSetV[i];
+        cout << " TO DOUBLE!" << endl;
+        return ECAFE_NO_CONVERT;
+    	}
+		}
+		
+    d=0;
+    ss.clear();
+    ss.str(tolerance);
+    ss>>d;
+
+    if ( !ss.fail()) {
+        toleranceDouble=d;
+    }
+    else {
+        cout << __METHOD__ << __LINE__ << endl;
+        cout << "***WARNING*** NO STRING TO DBR_DOUBLE CONVERSION " << endl;
+        cout << "***WARNING*** COULD NOT CONVERT: ";
+        cout << tolerance;
+        cout << " TO DOUBLE!" << endl;
+        return ECAFE_NO_CONVERT;
+    }
+
+    return gameSetAndMatch(handleSetV, valSetDoubleV,  handleAction, valAction, handleMatchV, toleranceDouble, timeout, printFlag);
+#undef __METHOD__
+
+}
+
+
+
+
+
+
+
 int setAndMatch(const unsigned int handleSet, dbr_double_t valSet, const unsigned int handleMatch,
                 dbr_double_t tolerance, double timeout, bool printFlag){
     return cafeDoppio.setAndMatch(handleSet, DBR_DOUBLE, valSet, handleMatch, tolerance, timeout, printFlag);

include/cafeService.h

@@ -1,8 +1,8 @@
 ///
 /// \file    cafeService.h
 /// \author  Jan Chrin, PSI
-/// \date    Release July: 2017
-/// \version CAFE 1.3.0
+/// \date    Release October 2017
+/// \version CAFE 1.4.0
 ///
 
 #ifndef CAFE_SERVICE_H
@@ -16,7 +16,6 @@
 
 
 #if HAVE_ZEROMQ
-//include <zhelpers.h>
 	#include <zmq.h>
   #if HAVE_JSON
 		#include <json/json.h>
@@ -26,22 +25,331 @@
 	#endif
 #endif
 
-/*
-class BSData{
-friend class CAFE;
+
+class BSChannel {
 private:
-	double val;
-	epicsTimeStamp ets;
-	int status;
+	string name;
+	int modulo;
+	int offset;
+	HandleHelper helper;
+
 public:
-	double getValue() {return val;}
-	epicsTimeStamp getEpicsTimeStamp() {return ets;}
-	int getStatus() { return status;}	
-	
-	BSData(){};
+	PVDataHolder pvd;
+	std::vector<std::string>  pv;
+	//void setName(string _name)  { name=_name;}
+	void setOffset(int _offset) { offset=_offset;}
+	void setModulo(int _modulo) { modulo=_modulo;}
+	string getName(){return name;}
+	int getModulo(){return modulo;}
+	int getOffset(){return offset;}
+	BSChannel(string _name): modulo(1), offset(0) {
+		char pv[PVNAME_SIZE];
+		helper.removeLeadingAndTrailingSpaces(_name.c_str(), pv);
+		name=(string) pv;};
+	BSChannel(string _name, int _modulo): offset(0)	{
+		char pv[PVNAME_SIZE];
+		helper.removeLeadingAndTrailingSpaces(_name.c_str(), pv);
+		name=(string) pv; modulo=_modulo;};
+	BSChannel(string _name, int _modulo, int _offset) {
+		char pv[PVNAME_SIZE];
+		helper.removeLeadingAndTrailingSpaces(_name.c_str(), pv);
+		name=(string) pv; modulo=_modulo; offset=_offset;};
 };
 
 
+class BSDataHolder{
+friend class CAFE;
+private:	
+	int overallStatus;	
+	unsigned long long pulse_id;
+	vector<BSChannel> bsChannel;
+	HandleHelper helper;
+
+	std::vector<std::string>  pv;
+
+	bool isBS;
+	bool BSInitialized;
+	void *context;
+
+	void *receiver;
+	int rc;
+
+	#if HAVE_JSON
+	Json::Value parsedFromString;
+	Json::Reader reader;
+	#endif
+	bool parsingSuccessful;
+
+
+public:	
+	BSDataHolder(){};
+
+	void *subscriber;
+
+	vector<double> getAsDoubleV() {
+		vector<double> V;
+		V.reserve(bsChannel.size());
+		for (size_t i=0; i<bsChannel.size(); ++i){
+			V.push_back(bsChannel[i].pvd.getAsDouble());
+		}
+		return V;
+	}
+
+	vector<string> getAsStringV() {
+		vector<string> V;
+		V.reserve(bsChannel.size());
+		for (size_t i=0; i<bsChannel.size(); ++i){
+			V.push_back(bsChannel[i].pvd.getAsString());
+		}
+		return V;
+	}
+
+	vector<int> getAsIntV() {
+		vector<int> V;
+		V.reserve(bsChannel.size());
+		for (size_t i=0; i<bsChannel.size(); ++i){
+			V.push_back(bsChannel[i].pvd.getAsInt());
+		}
+		return V;
+	}
+
+	vector<double> getAttributeAsDoubleV(string attribute) {
+		vector<double> V;
+		V.reserve(bsChannel.size());
+		char pvAtt[PVNAME_SIZE];
+		helper.removeLeadingAndTrailingSpaces(attribute.c_str(), pvAtt);
+		for (size_t i=0; i<bsChannel.size(); ++i){
+			if ( ((string)pvAtt).compare((string) bsChannel[i].pvd.getAttribute()) ==0){
+				V.push_back(bsChannel[i].pvd.getAsDouble());
+			}
+		}
+		return V;
+	}
+
+	PVDataHolder   getPVData(unsigned int idx) {
+		if (idx > (bsChannel.size()-1)) {
+			idx=bsChannel.size()-1;
+		}
+		return bsChannel[idx].pvd;
+	}
+
+
+	PVDataHolder   getPVData(string name) {
+
+		for (size_t i=0; i< bsChannel.size(); ++i) {
+			if (bsChannel[i].getName().compare(name) ==0 ) {
+				return bsChannel[i].pvd;
+			}
+		}
+	}
+
+
+	int getStatus() { return overallStatus;}
+
+
+	static size_t RecvResponseCallback(char * contents, size_t size, size_t nmemb, void  * up) {
+
+		++nCBs;
+		//cout << "Callback called: " << nCBs << endl;
+		//cout << "SIZE No. of Bytes " << size*nmemb << endl;
+
+		string sLocal=contents;
+
+		//remove \n for newline
+		std::size_t found = sLocal.find('\n');
+
+		if (found != std::string::npos) {
+
+			sLocal=sLocal.substr(0, found);
+		}
+
+		contentsBS=contentsBS+sLocal;
+
+		return (size_t) size * nmemb;
+	}
+
+
+	bool setBS(bool BSFlag) {
+
+	if(MUTEX){cafeMutex.lock();}
+
+	if (BSFlag) {
+		#if HAVE_CURL
+
+		string dataChannels=string("{\"channels\":[");
+		vector<string> pvNew=pv;
+
+		#if HAVE_ZEROMQ
+
+		if (!BSInitialized) {
+
+			//size_t found;
+			dataChannels= dataChannels + string("{\"name\":\"");
+			dataChannels= dataChannels + pvNew[0];
+			dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}" );
+
+
+			for (size_t i=1; i < pvNew.size(); ++i) {
+				dataChannels= dataChannels + string(",{\"name\":\"");
+				dataChannels= dataChannels + pvNew[i];
+				dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}");
+			}
+
+			dataChannels= dataChannels + string("],");
+			dataChannels= dataChannels + "\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"keep-as-is\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
+
+			cout <<  dataChannels << endl;
+
+			const char * data = dataChannels.c_str();
+
+			///cout << "SIZE OF DATA --------------->"  << sizeof(data) << endl;
+
+			CURL *curl;
+			CURLcode res;
+			struct curl_slist * slist;
+			slist = NULL;
+
+			slist = curl_slist_append(slist, "Content-Type: application/json");
+
+			curl_global_init(CURL_GLOBAL_ALL);
+
+			curl = curl_easy_init();
+
+			if (curl) {
+
+				curl_easy_setopt(curl, CURLOPT_URL, "https://dispatcher-api.psi.ch/sf/stream");
+
+				curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); //"-F file=@./dbpm.json"); //data); //
+
+				curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
+				curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
+
+				//cout << "WAITING FOR CALLBACK... " << endl;
+
+				curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &RecvResponseCallback);
+
+				res = curl_easy_perform(curl);
+
+				if (res != CURLE_OK) {
+					cout << "curl_easy_perform failed " << curl_easy_strerror(res) << endl;
+				}
+				else {
+					cout << " CALLBACK DONE" << endl;
+
+					curl_easy_cleanup(curl);
+
+					curl_slist_free_all(slist);
+
+					slist=NULL;
+				}
+			}//if curl
+
+			cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
+			curl_global_cleanup();
+
+
+			//cout << " //1// SHOW contentS " << endl;
+			//cout << contentsBS.c_str() << endl;
+
+			Json::Value parsedFromString;
+			Json::Reader reader;
+			bool parsingSuccessful;
+
+			Json::FastWriter fastWriter;
+			string globalBSZmqStream="";
+			//printf("value= %s\n", contentsBS.c_str());
+
+			if (contentsBS.size() > 2) {
+				parsingSuccessful=reader.parse(contentsBS.c_str(), parsedFromString);
+				if (parsingSuccessful) {
+					//Json::StyledWriter styledWriter;
+					//cout << "STYLED: --------------------------------" << endl;
+					//cout << styledWriter.write(parsedFromString) << endl;
+					//cout << "----------------------------------" << endl;
+					cout << parsedFromString["stream"] << endl;
+
+					cout << "----------------------------------" << endl;
+					globalBSZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
+					cout << globalBSZmqStream << endl;
+
+					if ( parsedFromString["stream"].isNull() ) {
+						globalBSZmqStream.clear();
+					}
+				}
+				else {
+					cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
+					cout << contentsBS.c_str() << endl;
+					cout << reader.getFormattedErrorMessages() << endl;
+
+				}
+			}
+
+			if (globalBSZmqStream.empty()) {
+				 cout << "BS Data is not available " << endl;
+				 return isBS=false;
+			}
+
+			context = zmq_ctx_new ();
+
+			////  receiver = zmq_socket (context, ZMQ_PULL);
+			//HWM has no effect for PULL
+			//See documentation on zmq-socket
+			//WHEN PUSH Sender reachers HWM, then it blocks
+			////		int nhwm=10;
+			////		zmq_setsockopt (receiver,ZMQ_RCVHWM ,&nhwm, sizeof(int));
+			//			rc = zmq_bind (receiver, "tcp://129.129.145.206:5558"); //ZMQ_PULL
+			////		assert (rc == 0);
+
+			subscriber = zmq_socket (context, ZMQ_SUB);
+
+
+			globalBSZmqStream=globalBSZmqStream.substr(1,globalBSZmqStream.size()-3);
+			//cout << " globalBSZmqStream.c_str() " << globalBSZmqStream.c_str() << endl;
+
+			rc = zmq_connect (subscriber, (const char *) globalBSZmqStream.c_str());
+
+			if (rc != 0 ) {
+				cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
+			}
+
+
+			assert (rc == 0);
+
+			int nhwm=1;
+			int timeoutMS=200; //10; //-1 Wait for Ever
+
+			rc=zmq_setsockopt (subscriber,ZMQ_RCVHWM, &nhwm, sizeof(int));
+			assert (rc == 0);
+
+			rc=zmq_setsockopt (subscriber,ZMQ_RCVTIMEO, &timeoutMS, sizeof(int));
+			assert (rc == 0);
+
+			rc=zmq_setsockopt (subscriber,ZMQ_SUBSCRIBE,"",0);
+			assert (rc == 0);
+
+			BSInitialized=true;
+
+		}//is BS initialized
+
+		#endif //have zeromq
+
+		if(MUTEX){cafeMutex.unlock();}
+		return isBS=BSFlag;
+		#else //have curl
+
+		if(MUTEX){cafeMutex.unlock();}
+		return isBS=false;
+		#endif //have curl
+	}//isBSFlag
+
+
+	if(MUTEX){cafeMutex.unlock();}
+	return isBS=BSFlag;
+	} // setBS
+
+};
+
+/*
 class RFData{
 friend class CAFE;
 private:
@@ -87,6 +395,8 @@ private:
 	
 	std::vector<double> offs_x;
 	std::vector<double> offs_y;
+
+	unsigned long long pulse_id;
 	
 	bool isAllXOK;
 	bool isAllYOK;
@@ -101,25 +411,23 @@ private:
 		
 	size_t nDBPM;
 	size_t nPV;
-	
-	
-	
+			
 	bool isBS;
 	bool BSInitialized;
 	void *context; 
   
 	void *receiver;
 	int rc;
+
 	#if HAVE_JSON
 	Json::Value parsedFromString;
 	Json::Reader reader;
-	bool parsingSuccessful;
 	#endif
-	
-	
+	bool parsingSuccessful;
+
 public:	
 
-  std::vector<DBPMData> getX() { return x;}
+	std::vector<DBPMData> getX() { return x;}
 	std::vector<DBPMData> getY() { return y;}
 	std::vector<DBPMData> getQ() { return q;}
 	std::vector<DBPMData> getEnergy() { return energy;}
@@ -135,7 +443,7 @@ public:
 	bool getIsAllOK()  {return isAllOK;}	
 		
 	std::vector<std::string>  getPV(){ return pv;}
-  std::vector<unsigned int> getHandle() { return handle;}
+	std::vector<unsigned int> getHandle() { return handle;}
 	std::vector<std::string>  getDevice() { return device;}
 	std::vector<float>        getS() { return s;} 
 	size_t getNDBPM() {return nDBPM;}
@@ -143,17 +451,19 @@ public:
 	int getStatus()   {return status;}
 	
 	
-	int getPVIdx(string _pv) {	
-			
-		for (size_t i=0;  i< pv.size(); ++i) {
-		 
+	int getPVIdx(string _pv) {				
+		for (size_t i=0;  i< pv.size(); ++i) {	 
 			if ( pv[i].compare(_pv) == 0) {			
-			 return i;
+				return i;
 			}		
 		}
 		return -1;
 	}
 	
+	
+	unsigned long long getPulse_id(){return pulse_id;}
+	void setPulse_id(unsigned long long _pulse_id){pulse_id=_pulse_id;}
+	
 	PVDataHolder * pvd;
 	int status;
 				
@@ -168,26 +478,15 @@ public:
 	
 	void *subscriber;
 
-	//struct MemoryStruct {
- 	// char *memory;
-  //	size_t size;
-	//};
-	
 	static size_t RecvResponseCallback(char * contents, size_t size, size_t nmemb, void  * up) {
 
 		++nCBs;
-		cout << "Callback called: " << nCBs << endl;
-
-		///Json::Value parsedFromString;
-		///Json::Reader reader;
-		///bool parsingSuccessful;
-	
-		///Json::FastWriter fastWriter;
-		
-		cout << "SIZE No. of Bytes " << size*nmemb << endl;
+		//cout << "Callback called: " << nCBs << endl;
+		//cout << "SIZE No. of Bytes " << size*nmemb << endl;
 
 		string sLocal=contents;
 
+		//remove \n for newline
 		std::size_t found = sLocal.find('\n');
 
 		if (found != std::string::npos) {
@@ -196,86 +495,13 @@ public:
 		}
 
 		contentsS=contentsS+sLocal;
-
-
-
-		//if (nCBs%3==1) {
-		//	return size*nmemb;
-		//}
-
-
-		//printf("value= %s\n", contents);
-		/*
-		if (contents != NULL) {
-				parsingSuccessful=reader.parse(contentsS.c_str(), parsedFromString);
-				if (parsingSuccessful) {
-					//Json::StyledWriter styledWriter;
-					cout << "STYLED: --------------------------------" << endl;
-					//cout << styledWriter.write(parsedFromString) << endl;
-					//cout << "----------------------------------" << endl;
-					cout << parsedFromString["stream"] << endl;
-					
-					cout << "----------------------------------" << endl;
-					globalZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
-				  cout << globalZmqStream << endl;
-					
-					if ( parsedFromString["stream"].isNull() ) {
-						globalZmqStream.clear();
-					}
-				}
-				else {
-					cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
-				
-					cout << reader.getFormattedErrorMessages() << endl;
-				}
-		}	
-		contentsS="";
-		*/
-		
-	/*
-	size_t realsize = size * nmemb;
-  struct MemoryStruct *mem = (struct MemoryStruct *)data;
- 
-  mem->memory = (char *) realloc(mem->memory, (mem->size + realsize + 1));
-	
-  if(mem->memory == NULL) {
-   
-    printf("not enough memory (realloc returned NULL)\n");
-    return 0;
-  }
- 
-  memcpy(&(mem->memory[mem->size]), contents, realsize);
-  mem->size += realsize;
-  mem->memory[mem->size] = 0;
- 
-  //return realsize;
-	
-			printf("value= %s\n",mem->memory);
-		if (mem->memory != NULL) {
-				parsingSuccessful=reader.parse(mem->memory, parsedFromString);
-				if (parsingSuccessful) {
-					Json::StyledWriter styledWriter;
-					cout << "STYLED: --------------------------------" << endl;
-					cout << styledWriter.write(parsedFromString) << endl;
-					cout << "----------------------------------" << endl;
-					cout << parsedFromString["stream"] << endl;
-					
-					cout << "----------------------------------" << endl;
-				
-		
-				}
-		}
-	*/	
 		
 		return (size_t) size * nmemb;
 	}
 
 	
-	
-//	
 
-
-  bool resetBS() {
+	bool resetBS() {
 		closeBS();
 		return setBS(true);	
 	}
@@ -283,93 +509,50 @@ public:
 
 	bool setBS(bool BSFlag) {
 
-   if(MUTEX){cafeMutex.lock();}
+	if(MUTEX){cafeMutex.lock();}
 
+	if (BSFlag) {
+		#if HAVE_CURL
+
+		string dataChannels=string("{\"channels\":[");
+		vector<string> pvNew=pv;
+
+		#if HAVE_ZEROMQ
+
+		if (!BSInitialized) {
 
-		if (BSFlag) {		
-			#if HAVE_CURL
-			/*
-			//Complete all or complete latest	
-			//const char * data="{\"channels\":[{\"name\":\"S10BC01-DBPM010:X1\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}, \
-			{\"name\":\"S10BC01-DBPM010:X1-VALID\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0} \
-		],\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"adjust-global\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
-*/
-			string dataChannels=string("{\"channels\":[");
-							
-			vector<string> pvNew=pv;
-#if HAVE_ZEROMQ
-if (!BSInitialized) {
-		//pvNew.push_back("SINEG01-DBPM340:X1") ;
-		//pvNew.push_back("SINSB01-DBPM150:X1") ;
-		//pvNew.push_back("SINSB02-DBPM150:X1") ;
-		//pvNew.push_back("SINLH01-DBPM060:X1") ;
-		//pvNew.push_back("SINLH02-DBPM210:X1") ; 
-		//pvNew.push_back("SINLH02-DBPM240:X1") ; 
-		//pvNew.push_back("SINLH03-DBPM010:X1") ; 
-		//pvNew.push_back("SINLH03-DBPM050:X1") ; 
-		//pvNew.push_back("SINLH03-DBPM090:X1") ; 
-		//pvNew.push_back("SINSB03-DBPM120:X1") ; 
-		//pvNew.push_back("SINSB03-DBPM220:X1") ; 
-		//pvNew.push_back("SINSB04-DBPM120:X1") ; 
-		//pvNew.push_back("SINSB04-DBPM220:X1") ; 
-					
-		//pvNew.push_back("SINEG01-DBPM340:X1-VALID") ;
-		//pvNew.push_back("SINSB01-DBPM150:X1-VALID") ;
-		//pvNew.push_back("SINSB02-DBPM150:X1-VALID") ;
-		//pvNew.push_back("SINLH01-DBPM060:X1-VALID") ;
-		//pvNew.push_back("SINLH02-DBPM210:X1-VALID") ; 
-		//pvNew.push_back("SINLH02-DBPM240:X1-VALID") ; 
-		//pvNew.push_back("SINLH03-DBPM010:X1-VALID") ; 
-		//pvNew.push_back("SINLH03-DBPM050:X1-VALID") ; 
-		//pvNew.push_back("SINLH03-DBPM090:X1-VALID") ; 
-		//pvNew.push_back("SINSB03-DBPM120:X1-VALID") ; 
-		//pvNew.push_back("SINSB03-DBPM220:X1-VALID") ; 
-		//pvNew.push_back("SINSB04-DBPM120:X1-VALID") ; 
-		//pvNew.push_back("SINSB04-DBPM220:X1-VALID") ; 
 			size_t found;
-			  dataChannels= dataChannels + string("{\"name\":\"");
-				dataChannels= dataChannels + pvNew[0];
-				//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}"		);
-				dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}" );
+			dataChannels= dataChannels + string("{\"name\":\"");
+			dataChannels= dataChannels + pvNew[0];
+			//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}"		);
+			dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}" );
 
 				
 			for (size_t i=1; i < pvNew.size(); ++i) {
-			
-			
-			  found = pvNew[i].find("SARUN08-DBPM210");
+					
+				found = pvNew[i].find("SARUN08-DBPM210");
 				if (found != std::string::npos) continue;
 				found = pvNew[i].find("SARUN08-DBPM410");
 				if (found != std::string::npos) continue;
-				//found = pvNew[i].find("Y1");
-				//if (found != std::string::npos) continue;
-				//found = pvNew[i].find("X1");
-				//if (found != std::string::npos) continue;
+
 				found = pvNew[i].find("ENERGY");
 				if (found != std::string::npos) continue;
 				
 			
-			   dataChannels= dataChannels + string(",{\"name\":\"");
+				dataChannels= dataChannels + string(",{\"name\":\"");
 				dataChannels= dataChannels + pvNew[i];
-				
-				//found = pv[i+1].find("ENERGY");
-				//if (found != std::string::npos) break;
-				//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}");
+
 				dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\",\"modulo\":1,\"offset\":0}");
 					
 			}
- 				//dataChannels= dataChannels + string("{\"name\":\"");
-				//dataChannels= dataChannels + pv[pv.size()-1];
-				//dataChannels= dataChannels + string("\",\"backend\":\"sf-databuffer\"}],");
-				dataChannels= dataChannels + string("],");
-				dataChannels= dataChannels + "\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"keep-as-is\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
+
+			dataChannels= dataChannels + string("],");
+			dataChannels= dataChannels + "\"mapping\":{\"incomplete\":\"fill-null\"},\"channelValidation\":{\"inconsistency\":\"keep-as-is\"},\"sendBehaviour\":{\"strategy\":\"complete-all\"}}";
 
 			cout <<  dataChannels << endl;
-	
-			//sleep(1);
+
 			const char * data = dataChannels.c_str();
 
-
-
 			///cout << "SIZE OF DATA --------------->"  << sizeof(data) << endl;
 
 			CURL *curl;
@@ -379,27 +562,22 @@ if (!BSInitialized) {
 			
 			slist = curl_slist_append(slist, "Content-Type: application/json");
 		
-			curl_global_init(CURL_GLOBAL_ALL);	
-						
-			
+			curl_global_init(CURL_GLOBAL_ALL);
+								
 			curl = curl_easy_init();
-			
-		
-				
+							
 			if (curl) {
 			
 				curl_easy_setopt(curl, CURLOPT_URL, "https://dispatcher-api.psi.ch/sf/stream");
 			
-				curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); //"-F file=@./request.json"); //data); //
+				curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data); //"-F file=@./dbpm.json"); //data); //
 			
 				curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
 				curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
 				
-				cout << "WAITING FOR CALLBACK " << endl;
+				//cout << "WAITING FOR CALLBACK... " << endl;
 
 				curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &RecvResponseCallback);
-				
-
 
 				res = curl_easy_perform(curl);
 				
@@ -407,148 +585,122 @@ if (!BSInitialized) {
 					cout << "curl_easy_perform failed " << curl_easy_strerror(res) << endl;
 				}
 				else {
-				cout << " CALLBACK DONE" << endl;
+					cout << " CALLBACK DONE" << endl;
 
-				cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
+					curl_easy_cleanup(curl);
 
-				curl_easy_cleanup(curl);
+					curl_slist_free_all(slist);
 
-				cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
-				curl=NULL;
-
-				curl_slist_free_all(slist);
-				cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
-				slist=NULL;
+					slist=NULL;
 				}
-			}
+			}//if curl
 			
 			cout << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" << endl;
 			curl_global_cleanup();
 			
-			#endif
-		
+
 			//cout << " //1// SHOW contentS " << endl;
 			//cout << contentsS.c_str() << endl;
 
-			
-			//sleep(1);
-
 			Json::Value parsedFromString;
 			Json::Reader reader;
 			bool parsingSuccessful;
 
 			Json::FastWriter fastWriter;
+			string globalZmqStream;
+
 
 			//printf("value= %s\n", contentsS.c_str());
-
 			
 			if (contentsS.size() > 2) {
-					parsingSuccessful=reader.parse(contentsS.c_str(), parsedFromString);
-					if (parsingSuccessful) {
-						//Json::StyledWriter styledWriter;
-						cout << "STYLED: --------------------------------" << endl;
-						//cout << styledWriter.write(parsedFromString) << endl;
-						//cout << "----------------------------------" << endl;
-						cout << parsedFromString["stream"] << endl;
+				parsingSuccessful=reader.parse(contentsS.c_str(), parsedFromString);
+				if (parsingSuccessful) {
+					//Json::StyledWriter styledWriter;
+					cout << "STYLED: --------------------------------" << endl;
+					//cout << styledWriter.write(parsedFromString) << endl;
+					//cout << "----------------------------------" << endl;
+					cout << parsedFromString["stream"] << endl;
 
-						cout << "----------------------------------" << endl;
-						globalZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
-					  cout << globalZmqStream << endl;
+					cout << "----------------------------------" << endl;
+					globalZmqStream = fastWriter.write(parsedFromString["stream"]).c_str();
+					cout << globalZmqStream << endl;
 
-						if ( parsedFromString["stream"].isNull() ) {
-							globalZmqStream.clear();
-						}
+					if ( parsedFromString["stream"].isNull() ) {
+						globalZmqStream.clear();
 					}
-					else {
-						cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
-						cout << contentsS.c_str() << endl;
-						cout << reader.getFormattedErrorMessages() << endl;
+				}
+				else {
+					cout << "PARSING IN CURL CALLBACK FUNCTION WAS UNSUCCESSFUL !!!" << endl;
+					cout << contentsS.c_str() << endl;
+					cout << reader.getFormattedErrorMessages() << endl;
 
-					}
+				}
+			}	
+						
+			if (globalZmqStream.empty()) {
+				 cout << "BS Data is not available " << endl;
+				 return isBS=false;
 			}
 
-
-
-//
-//#if HAVE_ZEROMQ
-//if (!BSInitialized) {
-
-
-			   cout << "TESTING STREAM... " << endl;
+			context = zmq_ctx_new ();
 			
-				
-				 if (globalZmqStream.empty()) {
-				 		cout << "BS Data is not available " << endl;
-				   return isBS=false;
-				 }
-				// else {
-				//   cout << globalZmqStream.c_str() << " is not empty " << endl;
-				 
-				// }
-			
-			
-				context = zmq_ctx_new ();
-			
-		///  	receiver = zmq_socket (context, ZMQ_PULL);
-				//HWM has no effect for PULL
-				//See documentation on zmq-socket
-				//WHEN PUSH Sender reachers HWM, then it blocks
-		///		int nhwm=10;
-		///		zmq_setsockopt (receiver,ZMQ_RCVHWM ,&nhwm, sizeof(int));
-				//rc = zmq_bind (receiver, "tcp://129.129.145.206:5558"); //ZMQ_PULL
-		///		rc = zmq_bind (receiver, "tcp://SIN-CVME-DBPM0421:9000");
-		///		assert (rc == 0);
-			
-				
-				subscriber = zmq_socket (context, ZMQ_SUB);
-				//rc = zmq_connect (subscriber, "tcp://129.129.145.206:5556");
-				//rc = zmq_connect (subscriber, "tcp://SIN-CVME-DBPM0421:9000");
-		
-				
-				
-				globalZmqStream=globalZmqStream.substr(1,globalZmqStream.size()-3);
-				//cout << " globalZmqStream.c_str() " << globalZmqStream.c_str() << endl;
-				//sleep(1);
-				
-				
-				
-				rc = zmq_connect (subscriber, (const char *) globalZmqStream.c_str()); // "tcp://sf-daqbuf-28.psi.ch:42465"); //  //"tcp://sf-daqbuf-30.psi.ch:39927");
-				
-				if (rc != 0 ) {
-					cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
-				}
-				
-				//rc = zmq_connect (subscriber, "tcp://*:9999");
-				assert (rc == 0);	
-			
-				int nhwm=1;
-				int timeoutMS=400; //10; //-1 Wait for Ever
-				
-				rc=zmq_setsockopt (subscriber,ZMQ_RCVHWM ,&nhwm, sizeof(int));
-				assert (rc == 0);	
-				
-				rc=zmq_setsockopt (subscriber,ZMQ_RCVTIMEO ,&timeoutMS, sizeof(int));
-				assert (rc == 0);		
+			////  receiver = zmq_socket (context, ZMQ_PULL);
+			//HWM has no effect for PULL
+			//See documentation on zmq-socket
+			//WHEN PUSH Sender reachers HWM, then it blocks
+			////		int nhwm=10;
+			////		zmq_setsockopt (receiver,ZMQ_RCVHWM ,&nhwm, sizeof(int));
+			//			rc = zmq_bind (receiver, "tcp://129.129.145.206:5558"); //ZMQ_PULL
+			////		assert (rc == 0);
 						
-				rc=zmq_setsockopt (subscriber,ZMQ_SUBSCRIBE,"",0);				
-				assert (rc == 0);
+			subscriber = zmq_socket (context, ZMQ_SUB);
+			//rc = zmq_connect (subscriber, "tcp://129.129.145.206:5556");
+			//rc = zmq_connect (subscriber, "tcp://SIN-CVME-DBPM0421:9000");
+									
+			globalZmqStream=globalZmqStream.substr(1,globalZmqStream.size()-3);
+			//cout << " globalZmqStream.c_str() " << globalZmqStream.c_str() << endl;
+
+			rc = zmq_connect (subscriber, (const char *) globalZmqStream.c_str());   //"tcp://sf-daqbuf-30.psi.ch:39927");
+				
+			if (rc != 0 ) {
+				cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
+			}
+				
+			//rc = zmq_connect (subscriber, "tcp://*:9999");
+			assert (rc == 0);
+			
+			int nhwm=1;
+			int timeoutMS=200; //10; //-1 Wait for Ever
+				
+			rc=zmq_setsockopt (subscriber,ZMQ_RCVHWM, &nhwm, sizeof(int));
+			assert (rc == 0);
+				
+			rc=zmq_setsockopt (subscriber,ZMQ_RCVTIMEO, &timeoutMS, sizeof(int));
+			assert (rc == 0);
+						
+			rc=zmq_setsockopt (subscriber,ZMQ_SUBSCRIBE,"",0);
+			assert (rc == 0);
 							
-				BSInitialized=true;								
-		}
-		
+			BSInitialized=true;
+
+		}//is BS initialized
+
+		#endif //have zeromq
+
 		if(MUTEX){cafeMutex.unlock();}
 		return isBS=BSFlag;
-		#else
+		#else //have curl
 		
 		if(MUTEX){cafeMutex.unlock();}
 		return isBS=false;
-		#endif
-		}	
+		#endif //have curl
+	}//isBSFlag
 		 
-		if(MUTEX){cafeMutex.unlock();}
-		return isBS=BSFlag;
-	}	
+	if(MUTEX){cafeMutex.unlock();}
+	return isBS=BSFlag;
+	} // setBS
 	
+
 	bool setCA(bool CAFlag) {	
 		return CAFlag;
 	}
@@ -582,13 +734,13 @@ if (!BSInitialized) {
 			s.push_back(pos->first);  device.push_back(pos->second);					
 		}		
 	
-	  pvd = new PVDataHolder[handle.size()];
+		pvd = new PVDataHolder[handle.size()];
 				
 		//for (int i=0; i< handle.size(); ++i) {		
 		//	pvd[i].setNelem(1);		
 		//}
 		
-	  nDBPM=device.size();
+		nDBPM=device.size();
 		nPV=_pv.size();	
 		status=ICAFE_NORMAL;	
 					
@@ -612,13 +764,13 @@ if (!BSInitialized) {
 		device.assign(_dev.begin(), _dev.end());
 		s.assign(_pos.begin(), _pos.end());
 	
-	  pvd = new PVDataHolder[handle.size()];
+		pvd = new PVDataHolder[handle.size()];
 		
 		//for (int i=0; i< handle.size(); ++i) {		
 		//	pvd[i].setNelem(1);		
 		//}
 		
-	  nDBPM=device.size();
+		nDBPM=device.size();
 		nPV=_pv.size();	
 		status=ICAFE_NORMAL;	
 					

include/channelRegalia.h

@@ -38,7 +38,7 @@ public:
     friend struct change_connectionHandlerArgs; 
     friend struct change_eventHandlerArgs;
     //friend struct change_channelRegalia;
-    //friend class  Connect;
+    friend class  Connect;
     friend class  HandleHelper;
     friend class  Conduit;
     friend class  ConduitGroup;
@@ -64,8 +64,8 @@ protected:
     void                setReadAccess (unsigned short r){accessRead=r;};
     void                setWriteAccess(unsigned short w){accessWrite=w;};
     void                setNelem      (unsigned int  n) {nelem=n;};
-    void                setConnectionState     (long cs)   {connectionState=cs;};
-    void                setCafeConnectionState (long ccs)  {cafeConnectionState=ccs;};
+    void                setConnectionState     (int cs)   {connectionState=cs;};
+    void                setCafeConnectionState (int ccs)  {cafeConnectionState=ccs;};
 
 public:
     chid                getChannelID()  const   {return channelID;};

include/conduitConnectionHandlerArgs.h

@@ -240,6 +240,7 @@ struct change_connectionHandlerArgs
             c.channelRegalia.cafeConnectionState   =ICAFE_CS_DISCONN;
             c.channelRegalia.connectFlag = false;                   
             c.status             = ICAFE_CA_OP_CONN_DOWN;
+						
         }
 					
 				

include/conduitGroup.h

@@ -59,6 +59,7 @@ public:
     bool    * mRule;
 
     unsigned int  * mHandle;
+		
 
     virtual ~ConduitGroup();
 	
@@ -80,6 +81,7 @@ public:
     unsigned int        getGroupHandle(void) const {return groupHandle;};
     ChannelTimeoutPolicy getChannelTimeoutPolicySGPut(void) const {return channelTimeoutPolicySGPut;};
     ChannelTimeoutPolicy getChannelTimeoutPolicySGGet(void) const {return channelTimeoutPolicySGGet;};
+		
  };
 
 

include/connect.h

@@ -25,6 +25,8 @@
 #include <policyHelper.h>
 #include <hashConduitGroup.h>
 
+#include <boost/date_time/posix_time/posix_time.hpp>
+
 #if HAVE_BOOST_THREAD
 #include <boost/thread/thread_only.hpp>
 #include <boost/chrono.hpp>
@@ -51,7 +53,7 @@ class Connect
 
   ExceptionsHelper exceptionsHelper;
 
-  ChannelCreatePolicy channelCreatePolicy;
+  
 	
   PolicyHelper policyHelper;
   HandleHelper handleHelper;
@@ -94,11 +96,17 @@ class Connect
 
     channelOpenGroupPolicy.setPolicy(
                                      CAFENUM::FLUSH_AFTER_EACH_GROUP_CREATION,
-                                     CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_SG_PEND_EVENT);
+																		 CAFENUM::WITH_POLL, DEFAULT_TIMEOUT_SG_PEND_EVENT);
+                                     //CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_SG_PEND_EVENT);
 
     channelOpenPolicy.setPolicy(
                                 CAFENUM::FLUSH_AFTER_EACH_CHANNEL_CREATION,
-                                CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_PEND_EVENT);
+																CAFENUM::WITH_POLL, DEFAULT_TIMEOUT_PEND_EVENT);													
+                                //CAFENUM::WITH_PEND_EVENT, DEFAULT_TIMEOUT_PEND_EVENT);
+																
+		channelClosePolicy.setPolicy(
+                                CAFENUM::FLUSH_AFTER_EACH_CHANNEL_CREATION,
+                                CAFENUM::WITH_PEND_IO, DEFAULT_TIMEOUT_PEND_IO);														
 
     deviceAttributeDeliminator=DEFAULT_DEVICE_ATTRIBUTE_DELIMINATOR;
 		
@@ -113,6 +121,8 @@ class Connect
 
   PrintErrorPolicy printErrorPolicy;
 
+  ChannelCreatePolicy channelCreatePolicy;
+
   ChannelOpenPolicy channelOpenPolicy;
   ChannelOpenPolicy channelClosePolicy; //can also use for close
   ChannelOpenPolicy channelMonitorPolicy;
@@ -148,7 +158,6 @@ class Connect
   CAFEGlobalAlarmCondition   getEpicsAlarmCondition() {return epicsAlarmStatus;}
 	CAFEGlobalAlarmSeverity    getEpicsAlarmSeverity() {return epicsAlarmSeverity;}
 	
-	
 	int flushNow() {return ca_flush_io();}
 	
 	int _ca_flush_io(){return ca_flush_io();}
@@ -191,39 +200,49 @@ class Connect
 
   	
 	void openGroupPrepare(){
-		channelOpenGroupPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
+		channelOpenGroupPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
 		channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
 		return;	
 	}
-		
-	void openMonitorPrepare(){
-	  channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO);
-	  channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
+						
+	void openGroupNowAndWait(double _timeout);
+	
+	void openGroupNowAndWaitForInputGroups(double _timeout, vector<unsigned int> gHandles);
+	
+	
+	//Pends for default amount of time
+  void openGroupNow() {	
+	  openGroupNowAndWait(channelOpenGroupPolicy.getTimeout());		
+		return;
+	} 
+	
+	
+	//Same as above - change nanmin convetnion	
+	void groupOpenPrepare(){
+		channelOpenGroupPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
+		channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
+		return;	
+	}
+						
+	void groupOpenNowAndWait(double _timeout) { openGroupNowAndWait(_timeout); return; };
+	void groupOpenNowAndWait(double _timeout, vector<unsigned int> gH) 
+	   { openGroupNowAndWaitForInputGroups(_timeout, gH); return; };
+	
+	//Pends for default amount of time
+  void groupOpenNow() {	
+	  openGroupNowAndWait(channelOpenGroupPolicy.getTimeout());		
+		return;
+	} 
+	
+	
+	
+  //-------------------------------------------------------------------------
+  void openMonitorPrepare(){
+  	channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
+	  channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO);	  
 		return;
 	}	
 
-	double setOpenDefaultPendTime(double _timeout){
-		return channelOpenPolicy.setDefaultTimeout(_timeout);
-	}
-	
-	double getOpenDefaultPendTime(){
-		return channelOpenPolicy.getDefaultTimeout();
-	}
-
-				
-	void openGroupNowAndWait(double _timeout){
-		double dto = channelOpenGroupPolicy.getTimeout();
-		channelOpenGroupPolicy.setTimeout(_timeout);
-		channelOpenGroupPolicy.flushSendBufferNow();
-		//	
-		//reset
-		channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
-		channelOpenGroupPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);	
-		//channelOpenGroupPolicy.setTimeoutToDefault();
-		channelOpenGroupPolicy.setTimeout(dto);
-		return;
-	}
-
 	void openMonitorNow(){
 		channelMonitorPolicy.flushSendBufferNow();
 		//reset
@@ -233,44 +252,57 @@ class Connect
 	}
 	
 	void openMonitorNowAndWait(double _timeout){
-		channelMonitorPolicy.setTimeout(_timeout);
+		channelMonitorPolicy.setTimeout(_timeout);	 
+		channelMonitorPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
 		channelMonitorPolicy.flushSendBufferNow();		
 		//reset
 		channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
 		channelMonitorPolicy.setFlushSendBufferKind(WITH_FLUSH_IO);		
 		return;
   }
+  //------------------------------------------------------------------------
 
+
+	double setOpenDefaultPendTime(double _timeout){
+		return channelOpenPolicy.setDefaultTimeout(_timeout);
+	}
+	
+	double getOpenDefaultPendTime(){
+		return channelOpenPolicy.getDefaultTimeout();
+	}
+
+  //------------------------------------------------------------------------
   void openPrepare() {
-     channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
+     channelOpenPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
 		 channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
 		 return;
 	} 
 	
-  void openNowAndWait(double _timeout) {
-	  double dto = channelOpenPolicy.getTimeout();
-	  channelOpenPolicy.setTimeout(_timeout);
-	  channelOpenPolicy.flushSendBufferNow();
-		//reset 
-		channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
-		channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
-		//channelOpenPolicy.setTimeoutToDefault();
-		channelOpenPolicy.setTimeout(dto);
-		return;
-	} 
-	
-  void openNow() {
-	  channelOpenPolicy.flushSendBufferNow();
-		channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
-		channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);
-		return;
-	} 
-	
+	//Same as openPrepare
 	void openNoWait(){
 		channelOpenPolicy.setFlushSendBufferKind(WITH_PEND_EVENT);		
 		channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_DESIGNATED_TO_CLIENT);
 		return;
 	}
+		
+	//Pends for a maximimum of timeout seconds
+  void openNowAndWait(double _timeout);
+	 
+	
+	//Pends for default amount of time
+  void openNow() {	
+	  openNowAndWait(channelOpenPolicy.getTimeout());
+		/*
+	  channelOpenPolicy.flushSendBufferNow();
+		//reset
+		channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
+		channelOpenPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
+		*/
+		return;
+	} 
+
+//-------------------------------------------------------------------------
+
 	
 	bool initCallbackComplete(vector<unsigned int> hV) {
 		return initCallbackComplete(&hV[0], hV.size());
@@ -292,9 +324,7 @@ class Connect
   void printCAFEException_pv(CAFEException_pv & e){exceptionsHelper.printCAFEException_pv(e);};
   
 	
-	
-	
-	
+
 	
   //closeChannel(s) only close within a context
 	int  closeChannels(unsigned int * handleArray, unsigned int nHandles);
@@ -329,6 +359,12 @@ class Connect
   int  closeHandles(unsigned int * handleArray, unsigned int nHandles);
   int  closeHandle(unsigned int  handle);
   int  closeHandles();
+	
+	//Close Channel Keep Handle
+	int  closeChannelKeepHandle(unsigned int  handle);
+	int  closeChannelsKeepHandles(unsigned int  * handleArray,  unsigned int nHandles);
+	int  closeChannelsKeepHandlesV(vector<unsigned int> v){ return closeChannelsKeepHandles(&v[0], v.size());}
+	int  closeChannelsKeepHandles (vector<unsigned int> v){ return closeChannelsKeepHandles(&v[0], v.size());}	
  
   // Monitors
   int  monitorStart(unsigned int  handle, MonitorPolicy &mp);

include/defines.h

@@ -55,7 +55,7 @@ typedef char pv_string_t[PVNAME_SIZE];
 const bool              DEFAULT_SELF_GOVERNING_TIMEOUT    = true;
 
 const double            DEFAULT_TIMEOUT_PEND_IO_WF        =  5.0;
-const double                    TIMEOUT_PEND_IO_MIN       =  0.00001;
+const double                    TIMEOUT_PEND_IO_MIN       =  0.0001;
 const double                    TIMEOUT_PEND_IO_MAX       = 20.0; // max timeout for first attempt (ntries=1)
 const unsigned short    DEFAULT_PEND_IO_NO_TRIES          =  2;
 const unsigned short            PEND_IO_MAX_TRIES         = 10;   // safety net
@@ -63,7 +63,7 @@ const double            DEFAULT_PEND_IO_INCREMENT_TIME    =  2.0;
 const double                    PEND_IO_INCREMENT_TIME_MIN=  0.05;
 const double                    PEND_IO_INCREMENT_TIME_MAX= 10.0;
 const double            DEFAULT_TIMEOUT_PEND_EVENT        =  0.4;
-const double            DEFAULT_TIMEOUT_PEND_IO           =  3.0;
+const double            DEFAULT_TIMEOUT_PEND_IO           =  0.4;  // previously 3.0
 const double            DEFAULT_TIMEOUT_SG_PEND_EVENT     =  0.5; // plus nMember/NMEMBER_PER_SEC_SG_PEND_EVENT
 const double            NMEMBER_PER_SEC_SG_PEND_EVENT     =  400; // 
 const double            DEFAULT_TIMEOUT_SG_PEND_IO        =  5.0;

include/global.h

@@ -20,6 +20,9 @@
 extern bool CHECK_CONSISTENCY_CA_STATE;
 extern bool MUTEX;
 extern epicsMutex cafeMutex;
+
+
+
 extern cafeConduit_set cs;
 extern cafeGroup_set gs;
 extern vector<PVGroup> PVGroupV;
@@ -29,8 +32,9 @@ extern map<vector<unsigned int>, string> groupPseudoMap;
 
 extern vector<string> globalChannelList;
 
-extern string globalZmqStream;
+
 extern string contentsS;
+extern string contentsBS;
 extern unsigned long nCBs;
 
 #endif // GLOBAL_H

include/handleHelper.h

@@ -86,6 +86,8 @@ class HandleHelper : public Helper {
 				vector<unsigned int> getHandlesFromPVs(vector<string> pvV,  ca_client_context * ccc);
 				vector<unsigned int> getHandlesFromPVs(vector<string> pvV); 
 
+				vector<unsigned int>  getDisconnectedHandlesFromWithinGroupV(unsigned int  gh);				
+
 		    vector<unsigned int>  getHandlesFromWithinGroupV(unsigned int  gh);
         unsigned int * getHandlesFromWithinGroup(unsigned int  gh);
 
@@ -167,6 +169,9 @@ class HandleHelper : public Helper {
         unsigned int  getNextFreeHandle();
 
         bool isChannelConnected(unsigned int handle);
+				bool allChannelsConnected();
+				bool allChannelsWithinGroupConnected();
+				bool allChannelsWithinGroupConnectedV(vector<unsigned int>);
 
         int  printHandle (unsigned int  h);
 		    int  printHandlesV(vector<unsigned int> handleV);

include/instant.cpp

@@ -237,6 +237,11 @@ template <class CTYPE> int  Instant<CTYPE>::getCache(const unsigned int  _handle
 						
             return ICAFE_CS_NEVER_CONN;
         }
+ 				else if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+            return ICAFE_CS_CLOSED;
+        }
+				
+ 
  
 
         if (_dbrType > DBR_CTRL_DOUBLE) {
@@ -764,15 +769,15 @@ template <class CTYPE> int  Instant<CTYPE>::clientRequests(
 
     if (it_handle != handle_index.end()) {
 
-        //union db_access_val * PVDataL;
-        //unsigned int   nelem;
-       
-        //chtype dbrTypeRequest_DataBuffer;
+        union db_access_val * PVDataL;
+        unsigned int   nelem;
+        //unsigned int   offset;
+        chtype dbrTypeRequest_DataBuffer;
 
-        //PVDataL  = (*it_handle).getPutBuffer  ();
-        //nelem    = (*it_handle).getChannelRequestMetaPrimitive().getNelem();
+        PVDataL  = (*it_handle).getPutBuffer  ();
+        nelem    = (*it_handle).getChannelRequestMetaPrimitive().getNelem();
 
-        //dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaPrimitive().getDbrDataType();
+        dbrTypeRequest_DataBuffer = (*it_handle).getChannelRequestMetaPrimitive().getDbrDataType();
 
         switch(_dbrType) {
         case DBR_STRING:
@@ -805,7 +810,15 @@ template <class CTYPE> int  Instant<CTYPE>::clientRequests(
             return ECAFE_INVALID_SWITCH_CASE;
             break;
         }
-		
+		/*
+		epicsTimeStamp ts;
+		ts.secPastEpoch= 0; // default value if cache does not have timeStamp
+		ts.nsec        = 0; // default value if cache does not have timeStamp
+		dbr_short_t alarmStatus    =-1; // default value if cache does not have alarmStatus
+		dbr_short_t alarmSeverity  =-1; // default value if cache does not have alarmSeverity
+		//helper function to set TimeStamps!
+		helper.setSTS(_handle, alarmStatus, alarmSeverity, ts);
+		*/
     }
 
     else {
@@ -876,6 +889,549 @@ template <class CTYPE> int  Instant<CTYPE>::setAndGet(const unsigned int handleS
 
 
 
+template <class CTYPE> int  Instant<CTYPE>::setMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, bool printFlag) {
+
+#define __METHOD__ "Instant<CTYPE>::setMany(vector<unsigned int>handleSet, chtype, vector<CTYPE>valSet)"
+
+    CAFEStatus cstat;
+
+    CTYPE valSetA[1];
+
+		status=ICAFE_NORMAL;
+   
+    if (handleSet.size() != valSet.size() ) {
+		   return ECAFE_HANDLE_MISMATCH_SET_AND_MATCH;
+		}
+		
+		for (size_t i=0; i< handleSet.size(); ++i) {
+
+    	if (!helper.isChannelConnected(handleSet[i])) {
+        cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+        cout << "NOT ALL CHANNELS CONNECTED: " << endl;
+        if (!helper.isChannelConnected(handleSet[i])) {
+				  helper.printHandle(handleSet[i]); 
+				  status=helper.getStatus(handleSet[i]);
+				}       
+    	}		
+	  
+		}
+	
+		
+		if (status!=ICAFE_NORMAL) {return status;}
+	
+	  if(printFlag) {
+			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+		}
+	
+	
+	 	if (printFlag) {
+		
+			for (size_t i=0; i< handleSet.size(); ++i) {	
+							
+				if (dbrType==DBR_CHAR) {				
+       		 cout << "SETTING  PV=" << helper.getPVFromHandle(handleSet[i]) << " to " << (unsigned short) valSet[i] << endl; 
+				}       
+				else {				
+       	   cout << "SETTING  PV=" << helper.getPVFromHandle(handleSet[i]) << " to " << valSet[i] << endl;
+				}
+							
+  	  } //for
+   
+		} //if
+		
+						
+		for (size_t i=0; i< handleSet.size(); ++i) {
+		
+		
+		
+    	//set No of Elements to 1
+
+    	unsigned int  nelemPrevious, nelemRequestedCheck=0;
+    	unsigned int  nelemRequested=1;
+					
+    	nelemPrevious=helper.getNelemClient(handleSet[i]);
+    	//Check the number of elements requested?
+    	if (nelemPrevious>1) {
+        nelemRequestedCheck = helper.setNelem(handleSet[i],nelemRequested);
+        if (nelemRequestedCheck != nelemRequested) {
+            cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+            cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
+                    << nelemPrevious << endl;
+            cout << "to: " << nelemRequested << " but got instead: "
+                    << nelemRequestedCheck  << endl;
+        }
+    	}
+		
+		
+		
+    	//policy set synchronous
+    	ChannelRequestPolicy polPrevious, polNow;
+
+    	policyHelper.getChannelRequestPolicyPut(handleSet[i], polPrevious);
+
+   		polNow.setMethodKind(WITHOUT_CALLBACK);
+    	polNow.setWaitKind(WAIT);
+    	polNow.setWhenToFlushSendBuffer(FLUSH_AUTOMATIC);
+
+    	policyHelper.setChannelRequestPolicyPut(handleSet[i], polNow);
+     
+      valSetA[0] = (CTYPE) valSet[i];
+
+    	status=set(handleSet[i], dbrType, valSetA);
+
+    	if (status!=ICAFE_NORMAL) {
+        cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+        cstat.report(status);
+    	}
+
+    	policyHelper.setChannelRequestPolicyPut(handleSet[i], polPrevious);
+			
+			
+    	unsigned int  nelemPreviousCheck=nelemPrevious;
+    	nelemRequested=1;
+    	//Switch back to previous value
+    	//if (nelemPrevious>1) {
+    	if(helper.getNelemRequest(handleSet[i])!= nelemPrevious) {
+        nelemPreviousCheck= helper.setNelem(handleSet[i],nelemPrevious);
+        if (nelemPreviousCheck != nelemPrevious) {
+            cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+            cout << "Internal CAFE FUNNY: Wanted to re-set the no. elements from: "
+                    << nelemRequested << endl;
+            cout << "to the previous: " << nelemPrevious << " but got instead: "
+                    << nelemPreviousCheck  << endl;
+        }
+    	}
+			
+
+		} //for size_t
+
+
+return status;
+} 
+#undef __METHOD__
+	
+
+
+/**
+ *  \brief Set Channels followed by a corresponding readback of Channels \n
+ *  Method verifies whether or not the set/readback values agree within the given tolerance and timeout \n
+ *  Method returns with ECA_NORMAL as soon as a match is reached
+ *  \param handleSet input: vector of handleSet
+ *  \param dbrType input: chtype of set value
+ *  \param valSet input:  vector of CTYPE values to set
+ *  \param handleMatch input: vector of handles of readback channel
+ *  \param tolerance input: CTYPE of tolerance  margin
+ *  \param timeout input:  double value; maximum time allowed for agreement to occur
+ *  \param printFlag input: bool, set to true for diagnostics
+ *  \return ECA_NORMAL if all OK, else first ECAFE error encountered, else ECAFE_TIMEOUT_SET_AND_MATCH
+ */
+ 																										
+template <class CTYPE> int  Instant<CTYPE>::compareAndMatchMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch, 
+															CTYPE tolerance, double timeout, bool printFlag){ 
+//template <class CTYPE> int  Instant<CTYPE>::setTriggerAndMatchMany(vector<unsigned int> handleSet, chtype dbrType, vector<CTYPE> valSet, 
+//											vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+//                     CTYPE tolerance, double timeout, bool printFlag){
+#define __METHOD__ "Instant<CTYPE>::compareAndMatchMany(chtype, vector<CTYPE>valSet, vector<unsigned int>handleMatch, tolerance, timeout, printFlag)"
+
+
+    Connect connect;
+    CAFEStatus cstat;
+
+	CTYPE valGetA[1];  //CTYPE valSetA[1];
+
+		status=ICAFE_NORMAL;
+
+   
+    if (handleMatch.size() != valSet.size() ) {
+		   return ECAFE_HANDLE_MISMATCH_SET_AND_MATCH;
+		}
+		
+		for (size_t i=0; i< handleMatch.size(); ++i) {
+
+    	if (!helper.isChannelConnected(handleMatch[i])) {
+        cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+        cout << "NOT ALL CHANNELS CONNECTED: " << endl;
+               
+                if (!helper.isChannelConnected(handleMatch[i])) {helper.printHandle(handleMatch[i]); status=helper.getStatus(handleMatch[i]);}
+    	}		
+	  
+		}
+	
+		
+		if (status!=ICAFE_NORMAL) {return status;}
+	
+	  if(printFlag) {
+			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+		}
+	
+		if (printFlag) {
+		
+		
+			for (size_t i=0; i< handleMatch.size(); ++i) {	
+		
+						
+				if (dbrType==DBR_CHAR) {				
+       		cout << "SETTING  PV= " << helper.getPVFromHandle(handleSet[i]) << " to " << (unsigned short) valSet[i] << endl; 
+				}       
+				else {				
+       	  cout << "SETTING  PV= " << helper.getPVFromHandle(handleSet[i]) << " to " << valSet[i] << endl;
+				}
+				
+        cout << "READBACK PV=" << helper.getPVFromHandle(handleMatch[i])
+             << " tolerance= " << fabs( (double) tolerance) << endl;
+        cout << "TIME ALLOWED FOR MATCH IS " << timeout << " (sec) " << endl;
+							
+  	  } //for
+   
+		} //if
+
+		
+		vector<CTYPE> valSetUpper; vector<CTYPE> valSetLower;
+	
+		vector<unsigned int> monitorID; 
+		vector<int> statMonitor;
+		vector<unsigned short> nMonitors;
+		vector<CTYPE> valGet;
+	
+			
+		vector<unsigned int> nelemPreviousCache;	
+							
+		valSetUpper.reserve( valSet.size());
+		
+		
+		valSetLower.reserve( valSet.size());
+		monitorID.reserve( valSet.size());
+		statMonitor.reserve( valSet.size());
+		valGet.reserve( valSet.size());
+		nMonitors.reserve( valSet.size() );
+		
+		
+		nelemPreviousCache.reserve( valSet.size());
+		
+	
+		for (size_t i=0; i< valSet.size(); ++i) {
+		
+					
+    	switch (dbrType) {
+    		case DBR_LONG :
+    		case DBR_SHORT :
+    		case DBR_ENUM:
+        	valSetUpper[i]  = valSet[i] + abs((int)tolerance);
+        	valSetLower[i]  = valSet[i] - abs((int)tolerance);
+        break;
+    		case DBR_CHAR :
+        	valSetUpper[i]  = (unsigned short) valSet[i] + abs((unsigned short) tolerance);
+        	valSetLower[i]  = (unsigned short) valSet[i] - abs((unsigned short) tolerance);
+        break;
+    		case DBR_FLOAT:
+    		case DBR_DOUBLE:
+    		default:
+				
+        	valSetUpper[i]  = (CTYPE) (valSet[i] + fabs((double)tolerance));
+        	valSetLower[i]  = (CTYPE) (valSet[i] - fabs((double)tolerance));
+					
+        break;
+    	}
+
+	
+	  	
+		vector<MonitorPolicy> mpVMatch;
+		mpVMatch.clear();
+					
+    	helper.getMonitorPolicyVector(handleMatch[i], mpVMatch);
+
+     
+    	nMonitors[i]=mpVMatch.size();
+						
+    	monitorID[i]=0;
+			
+    	////valGetA[0][i]=0; 
+			valGet[i]=0;
+
+    	statMonitor[i]=ICAFE_NORMAL;
+				
+		}
+		
+		
+			
+		for (size_t i=0; i< handleMatch.size(); ++i) {
+			
+    	//what is monitorpolicy??
+   	  if (nMonitors[i]==0) {
+
+			unsigned int  _nelemPrevious, _nelemRequestedCheck=0;
+			unsigned int  _nelemRequested=1;
+			_nelemPrevious=helper.getNelemClient(handleMatch[i]);
+			//Check the number of elements requested?
+			  if (_nelemPrevious>1) {
+				  _nelemRequestedCheck = helper.setNelem(handleMatch[i],_nelemRequested); 
+				  if (_nelemRequestedCheck != _nelemRequested) {
+					  cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+					  cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
+						<< _nelemPrevious << endl;
+					  cout << "to: " << _nelemRequested << " but got instead: "
+						<< _nelemRequestedCheck  << endl;
+				  }
+			  }
+
+        //first do get to update cache before monitor starts
+			  status=Instant::get(handleMatch[i], dbrType, valGetA);
+					
+			  valGet[i]=valGetA[0];
+
+			  if (_nelemPrevious>1) {
+				  helper.setNelem(handleMatch[i],_nelemPrevious);  
+			  }
+
+
+        if (status!=ICAFE_NORMAL) {
+           cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+           cstat.report(status);
+        }
+
+        ChannelWhenToFlushSendBufferPolicyKind whenKind=
+                connect.channelMonitorPolicy.getWhenToFlushSendBuffer();
+        connect.channelMonitorPolicy.setWhenToFlushSendBuffer(FLUSH_AUTOMATIC);
+
+        statMonitor[i]=connect.monitorStart(handleMatch[i], monitorID[i]);
+
+        if (statMonitor[i]!=ICAFE_NORMAL) {
+          cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+          cstat.report(statMonitor[i]);
+        }
+			  else {
+					if(printFlag) {cout << "MONITOR NOW IN PLACE FOR READBACK CHANNEL " << helper.getPVFromHandle(handleMatch[i]) << " WITH ID=" << monitorID[i] << endl;}
+			  }
+        //revert to previous
+        if (whenKind != FLUSH_AUTOMATIC) {
+          connect.channelMonitorPolicy.setWhenToFlushSendBuffer(whenKind);
+        }
+   	 
+		  } //if nMonitors
+		 	
+    	
+
+
+
+			//No of elements to get from Cache
+
+			//unsigned int  nelemPreviousCheck=0;
+			unsigned int  nelemRequested=1; unsigned int  nelemRequestedCheck=0;
+			nelemPreviousCache[i]=helper.getNelemRequest(handleMatch[i]);
+
+			//Check the number of elements requested
+			//See set and Match; this needs to be checked
+			//Avoid problem when readback channel is the very same as the set(!)
+			if (nelemPreviousCache[i]>0  && helper.getNelemNative(handleMatch[i])>1) {
+				nelemRequestedCheck = helper.setNelemToRetrieveFromCache(handleMatch[i],nelemRequested);
+				if (nelemRequestedCheck != nelemRequested) {
+					cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+					cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
+					<< nelemPreviousCache[i] << endl;
+					cout << "to: " << nelemRequested << " but got instead: "
+					<< nelemRequestedCheck  << endl;
+				}
+			}
+
+
+	} //for size_t
+	
+	
+
+
+	//start time
+
+ 
+
+
+	double timeElapsed=0; double timeElapsed2=0;
+	double timeElapsedBase=0;
+	using namespace boost::posix_time;
+
+	ptime timeStart(microsec_clock::local_time());
+
+
+	for (size_t i=0; i< handleMatch.size(); ++i) {
+
+  	valGetA[0]=0;
+
+		status=Instant::getCache(handleMatch[i], dbrType, valGetA);
+
+		valGet[i]=valGetA[0];
+
+
+		if (status !=ICAFE_NORMAL) {
+			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+			cstat.report(status);
+		}
+
+		///valGet[i]=valGetA[0][i];
+		if (dbrType==DBR_CHAR) {valGet[i] = (unsigned short) valGetA[0];}
+
+		if(printFlag) {
+			//cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+			if (dbrType==DBR_CHAR) {
+			cout << "Current Cached Value = " << (unsigned short) valGet[i] << endl;
+			cout << "Lower/Upper Target Values = " << (unsigned short)  valSetLower[i] << " and " << (unsigned short)  valSetUpper[i] << endl;
+			}
+			else {
+			cout << "Current Cached Value = " << valGet[i] << endl;
+			cout << "Lower/Upper Target Values = " << valSetLower[i] << " and " << valSetUpper[i] << endl;
+			}
+		}
+
+	} //for size_t
+	
+	
+	
+	ptime timeEnd(microsec_clock::local_time());
+	time_duration duration(timeEnd-timeStart);
+	timeElapsed= (double) duration.total_microseconds()/1000000.0;
+	
+	
+	for (size_t i=0; i< valSet.size(); ++i) {
+	
+
+		while ( (valGet[i]>valSetUpper[i] || valGet[i]<valSetLower[i] )   
+            && timeElapsed < timeout ) {
+
+      valGetA[0]=0; 
+
+			status=Instant::getCache(handleMatch[i], dbrType, valGetA);
+
+      valGet[i]=valGetA[0];
+			
+			
+			//cout <<"Cached value " << valGet[i] << endl;
+			
+						
+			if (dbrType==DBR_CHAR) {valGet[i] = (unsigned short) valGetA[0];}
+            
+            //cout << valSetUpper[i] << " U/L " << valSetLower[i] << endl;
+
+            ptime timeEnd(microsec_clock::local_time());
+            time_duration duration(timeEnd-timeStart);
+            timeElapsed= (double) duration.total_microseconds()/1000000.0;
+
+            timeElapsed2=timeElapsed-timeElapsedBase;
+
+            if (printFlag && timeElapsed2>1 && status==ICAFE_NORMAL) {
+												
+						
+							for (size_t ij=0; ij< handleMatch.size(); ++ij) {							
+								 status=Instant::getCache(handleMatch[ij], dbrType, valGetA);
+      					 valGet[ij]=valGetA[0];
+								 if (valGet[ij]>valSetUpper[ij] || valGet[ij]<valSetLower[ij]) { 
+								 
+								 					if (dbrType==DBR_CHAR) {
+								 
+													cout << "REPORTING " << helper.getPVFromHandle(handleSet[ij]) 
+													<< " SET VALUE=" << (unsigned short) valSet[ij] 
+													<< "; READBACK " << helper.getPVFromHandle(handleMatch[ij]) 
+													<< " HAS CURRENT VALUE=" << (unsigned short) valGet[ij] 
+               		  	    << " TimeElapsed " << timeElapsed << " (sec) " << endl;    
+													}
+													else {
+													cout << "REPORTING "  << helper.getPVFromHandle(handleSet[ij]) 
+													<< " SET VALUE=" << valSet[ij] 
+													<< "; READBACK " << helper.getPVFromHandle(handleMatch[ij]) 
+													<< " HAS CURRENT VALUE=" <<  valGet[ij] 
+               		  	    << " TimeElapsed " << timeElapsed << " (sec) " << endl;   
+													
+													}
+													      				
+								 }
+							}
+							timeElapsedBase=timeElapsed;
+						
+            //cout << "REPORTING ON CHANNEL " << helper.getPVFromHandle(handleSet[i]) << " SET VALUE=" << valSet[i] << " // CURRENT READBACK VALUE=" << valGet[i] 
+            //        << " TimeElapsed " << timeElapsed << " (sec) " << endl;
+            //timeElapsedBase=timeElapsed;
+
+            }
+   
+				 
+			   #if HAVE_BOOST_THREAD
+			   boost::this_thread::sleep_for(boost::chrono::microseconds(20));
+				 #else
+				  #if HAVE_LINUX
+	        usleep(20); 	
+			    #endif
+			   #endif
+		}
+	
+
+	
+	} //for size_t
+		
+	
+
+		if (timeout <=timeElapsed ) {
+			cout << "*****TIMEOUT REACHED****** AFTER " << timeout << " (sec) " << endl;
+			cout << "*****NOT ALL READBACK CHANNELS REACHED THEIR DESIRED VALUES WITHIN THE GIVEN TOLERANCE AND TIME PERIOD*****" << endl;
+ 			status=ECAFE_TIMEOUT_SET_AND_MATCH;					
+		}
+		else {
+      			
+					if (printFlag) {	
+						
+						for (size_t i=0; i< handleMatch.size(); ++i) {
+				  	    		
+					      valGetA[0]=0; 
+								status=Instant::getCache(handleMatch[i], dbrType, valGetA);
+								valGet[i]=valGetA[0];
+								if (dbrType==DBR_CHAR) {
+                cout << "GAME SET AND MATCH: " << helper.getPVFromHandle(handleSet[i]) << " SET VALUE= " << (unsigned short) valSet[i] 
+								<< " // " << helper.getPVFromHandle(handleMatch[i])  << " READBACK VALUE= " << (unsigned short) valGet[i] //pvdMatch.getAsDouble()
+                     << " TimeElapsed " << timeElapsed << " (sec) " << endl;
+								}
+								else {
+								cout << "GAME SET AND MATCH: " << helper.getPVFromHandle(handleSet[i]) << " SET VALUE= " << valSet[i] 
+								     << " // " << helper.getPVFromHandle(handleMatch[i])  << " READBACK VALUE= " << valGet[i] //pvdMatch.getAsDouble()
+                     << " TimeElapsed " << timeElapsed << " (sec) " << endl;
+								
+								}
+    		  	} //for
+					
+					} //printFlag
+		}
+//
+
+		for (size_t i=0; i< handleMatch.size(); ++i) {
+			unsigned int  nelemPreviousCheck; 
+			unsigned int  nelemRequested=1;
+			
+		
+	  	if (nelemPreviousCache[i]>1) {
+            nelemPreviousCheck= helper.setNelemToRetrieveFromCache(handleMatch[i],nelemPreviousCache[i]);
+            if (nelemPreviousCheck != nelemPreviousCache[i]) {
+                cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+                cout << "Internal CAFE FUNNY: Wanted to re-set the no. elements from: "
+                        << nelemRequested << endl;
+                cout << "to the previous: " << nelemPreviousCache[i] << " but got instead: "
+                        << nelemPreviousCheck  << endl;
+            }
+	  	}
+
+
+
+    	if (nMonitors[i]==0 && statMonitor[i]==ICAFE_NORMAL && printFlag) {
+        cout << "MONITOR NOW STOPPED FOR READBACK CHANNEL " << helper.getPVFromHandle(handleMatch[i]) << " WITH ID =" << monitorID[i] << endl;
+								int statm;
+                statm=connect.monitorStop(handleMatch[i], monitorID[i]);
+			          if (status==ICAFE_NORMAL) {status=statm;}
+    	}
+
+		} //for
+		
+		
+return status;
+#undef __METHOD__
+
+}
+
+
+
 
 
 /**
@@ -895,7 +1451,6 @@ template <class CTYPE> int  Instant<CTYPE>::setAndMatchMany(vector<unsigned int>
                      CTYPE tolerance, double timeout, bool printFlag){
 #define __METHOD__ "Instant<CTYPE>::setAndMatchMany(vector<unsigned int>handleSet, chtype, vector<CTYPE>valSet, vector<unsigned int>handleMatch, tolerance, timeout, printFlag)"
 
-
     Connect connect;
     CAFEStatus cstat;
 
@@ -1296,10 +1851,10 @@ template <class CTYPE> int  Instant<CTYPE>::setAndMatchMany(vector<unsigned int>
 		}
 		else {
       			
-			for (size_t i=0; i< handleSet.size(); ++i) {
-				     
-					//if (printFlag) {cout << "MONITOR STARTED WITH ID/2-/=" << monitorID[i] << endl;}
-      		if (printFlag) {
+					if (printFlag) {	
+						
+						for (size_t i=0; i< handleSet.size(); ++i) {
+				  	    		
 					      valGetA[0]=0; 
 								status=Instant::getCache(handleMatch[i], dbrType, valGetA);
 								valGet[i]=valGetA[0];
@@ -1314,9 +1869,9 @@ template <class CTYPE> int  Instant<CTYPE>::setAndMatchMany(vector<unsigned int>
                      << " TimeElapsed " << timeElapsed << " (sec) " << endl;
 								
 								}
-    		  }
+    		  	} //for
 					
-			} //for
+					} //printFlag
 		}
 //
 
@@ -1595,7 +2150,7 @@ template <class CTYPE> int  Instant<CTYPE>::setAndMatch(const unsigned int handl
 		//cout << __METHOD__ << endl;
 		cout << "Current Cached Value = " ;
 		if (dbrType==DBR_CHAR) {
-		cout << (unsigned short) valGetA[0] << cout << endl;
+		cout << (unsigned short) valGetA[0] << endl;
 		cout << "Lower/Upper Target Values = " << (unsigned short) valSetLower << " and " << (unsigned short) valSetUpper << endl;
 		}
 		else {
@@ -2083,7 +2638,7 @@ template <class CTYPE> int  Instant<CTYPE>::matchMany(const chtype dbrType, vect
 					      valGetA[0]=0; 
 								status=Instant::getCache(handleMatch[i], dbrType, valGetA);
 								valGet[i]=valGetA[0];
-                cout << "GAME SET AND MATCH: "  << " SET VALUE= " << valSet[i] << " // " << helper.getPVFromHandle(handleMatch[i])  << " READBACK VALUE= " << valGet[i] //pvdMatch.getAsDouble()
+                cout << "GAME SET AND MATCH: "   << " SET VALUE= " << valSet[i] << " // " << helper.getPVFromHandle(handleMatch[i])  << " READBACK VALUE= " << valGet[i] //pvdMatch.getAsDouble()
                      << " TimeElapsed " << timeElapsed << " (sec) " << endl;
     		  }
 					

include/instant.h

@@ -108,14 +108,145 @@ public:
 																									
     int  setAndMatchMany(vector<unsigned int> handleSetV, const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch,
                           CTYPE tolerance, double timeout, bool printFlag);
+													
+		int  setTriggerAndMatchMany(vector<unsigned int> handleSetV, const chtype dbrType, vector<CTYPE> valSet, 
+													vector<unsigned int> handleAction, vector<string> valAction, vector<unsigned int> handleMatch,
+                          CTYPE tolerance, double timeout, bool printFlag);											
 
 		int  matchMany( 													          	const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch,
                           CTYPE tolerance, double timeout, bool printFlag);
 
 		int  match( 													          	const chtype dbrType, CTYPE valSet, unsigned int handleMatch,
                           CTYPE tolerance, double timeout, bool printFlag);
+													
+		int  setMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, bool printFlag); 
+													
+	
+																										
+    int  compareAndMatchMany(vector<unsigned int> handleSet, const chtype dbrType, vector<CTYPE> valSet, vector<unsigned int> handleMatch, 
+															CTYPE tolerance, double timeout, bool printFlag);																							
 
 
+
+		int  setManyString(vector<unsigned int> handleSet, vector<string> valSet, bool printFlag) {
+
+	#define __METHOD__ "Instant<CTYPE>::setMany(vector<unsigned int>handleSet, chtype, vector<CTYPE>valSet)"
+
+    CAFEStatus cstat;
+
+   
+		status=ICAFE_NORMAL;
+   
+    if (handleSet.size() != valSet.size() ) {
+		   return ECAFE_HANDLE_MISMATCH_SET_AND_MATCH;
+		}
+		
+		for (size_t i=0; i< handleSet.size(); ++i) {
+
+    	if (!helper.isChannelConnected(handleSet[i])) {
+        cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+        cout << "NOT ALL CHANNELS CONNECTED: " << endl;
+        if (!helper.isChannelConnected(handleSet[i])) {
+				  helper.printHandle(handleSet[i]); 
+				  status=helper.getStatus(handleSet[i]);
+				}       
+    	}		
+	  
+		}
+	
+		
+		if (status!=ICAFE_NORMAL) {return status;}
+	
+	  if(printFlag) {
+			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+		}
+	
+	
+	 	if (printFlag) {
+		
+			for (size_t i=0; i< handleSet.size(); ++i) {	
+							
+       	   cout << "SETTING  PV=" << helper.getPVFromHandle(handleSet[i]) << " to " << valSet[i] << endl;
+				
+							
+  	  } //for
+   
+		} //if
+		
+						
+		for (size_t i=0; i< handleSet.size(); ++i) {
+		
+		
+		
+    	//set No of Elements to 1
+
+    	unsigned int  nelemPrevious, nelemRequestedCheck=0;
+    	unsigned int  nelemRequested=1;
+					
+    	nelemPrevious=helper.getNelemClient(handleSet[i]);
+    	//Check the number of elements requested?
+    	if (nelemPrevious>1) {
+        nelemRequestedCheck = helper.setNelem(handleSet[i],nelemRequested);
+        if (nelemRequestedCheck != nelemRequested) {
+            cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+            cout << "Internal CAFE FUNNY: Wanted to set the no. elements from: "
+                    << nelemPrevious << endl;
+            cout << "to: " << nelemRequested << " but got instead: "
+                    << nelemRequestedCheck  << endl;
+        }
+    	}
+		
+		
+		
+    	//policy set synchronous
+    	ChannelRequestPolicy polPrevious, polNow;
+
+    	policyHelper.getChannelRequestPolicyPut(handleSet[i], polPrevious);
+
+   		polNow.setMethodKind(WITHOUT_CALLBACK);
+    	polNow.setWaitKind(WAIT);
+    	polNow.setWhenToFlushSendBuffer(FLUSH_AUTOMATIC);
+
+    	policyHelper.setChannelRequestPolicyPut(handleSet[i], polNow);
+     
+		  dbr_string_t valSetA[1];
+
+    
+      helper.removeLeadingAndTrailingSpaces(valSet[i].c_str(), valSetA[0]);
+		 
+     
+    	status=set(handleSet[i], DBR_STRING, valSetA);
+
+    	if (status!=ICAFE_NORMAL) {
+        cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+        cstat.report(status);
+    	}
+
+    	policyHelper.setChannelRequestPolicyPut(handleSet[i], polPrevious);
+			
+			
+    	unsigned int  nelemPreviousCheck=nelemPrevious;
+    	nelemRequested=1;
+    	//Switch back to previous value
+    	//if (nelemPrevious>1) {
+    	if(helper.getNelemRequest(handleSet[i])!= nelemPrevious) {
+        nelemPreviousCheck= helper.setNelem(handleSet[i],nelemPrevious);
+        if (nelemPreviousCheck != nelemPrevious) {
+            cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+            cout << "Internal CAFE FUNNY: Wanted to re-set the no. elements from: "
+                    << nelemRequested << endl;
+            cout << "to the previous: " << nelemPrevious << " but got instead: "
+                    << nelemPreviousCheck  << endl;
+        }
+    	}
+			
+
+		} //for size_t
+
+return status;
+#undef __METHOD__
+} 
+
 /**
  *  \brief Set followed by an immediate get
  *  \param handleSet input: handle

include/makefile

@@ -186,7 +186,7 @@ htmldir = ${docdir}
 includedir = ${prefix}/include
 infodir = ${datarootdir}/info
 install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh
-libdir = /opt/gfa/cafe/cpp/cafe-1.3.0-final-2/lib
+libdir = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1/lib
 libexecdir = ${exec_prefix}/libexec
 localedir = ${datarootdir}/locale
 localstatedir = ${prefix}/var
@@ -195,7 +195,7 @@ mandir = ${datarootdir}/man
 mkdir_p = /bin/mkdir -p
 oldincludedir = /usr/include
 pdfdir = ${docdir}
-prefix = /opt/gfa/cafe/cpp/cafe-1.3.0-final-2
+prefix = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1
 program_transform_name = s,x,x,
 psdir = ${docdir}
 sbindir = ${exec_prefix}/sbin

include/policies.h

@@ -64,10 +64,11 @@ public:
 class ChannelCreatePolicy{
 private:
     unsigned short priority;
-    static void callbackHandlerCreate(struct connection_handler_args args);
+    
     //special method to find handle thru conduit_set iterator
     pCallbackConnection handler;
 public:
+		static void callbackHandlerCreate(struct connection_handler_args args);
     pCallbackConnection getHandler(){return handler;};
     void setHandler(pCallbackConnection h){handler=h;};
     unsigned short getPriority() const {return priority;}
@@ -411,7 +412,7 @@ private:
     int           status;        //output
     unsigned int  id;
 
-    static void callbackHandlerMonitor(struct event_handler_args args);
+   
 	  static void PyCallbackHandlerMonitorData(struct event_handler_args args); //pushes pvd,handle,pvname
 	  static void PyCallbackHandlerMonitor(struct event_handler_args args); //pushes handle
 
@@ -427,6 +428,9 @@ public:
         ++idNext;
         id = idNext;
     };
+		//Make public
+		static void callbackHandlerMonitor(struct event_handler_args args);
+		
     chtype getDataType() const {return dataType;};
     chtype getDbrDataType() const {return dbrDataType;};
     CAFENUM::DBR_TYPE getCafeDbrType() const {return cafeDbrType;};

include/statusCodes.h

@@ -36,7 +36,7 @@ const unsigned short ICAFE_STATUS_CA_OP =  800;
 const unsigned short ICAFE_STATUS_ERROR = 1000;
 const unsigned short ICAFE_FILE_ERROR   = 1100;
 const unsigned short ICAFE_SERVICE_ERROR =1200;
-const unsigned short ICAFE_LINUX_ERROR  = 5000;
+const unsigned short ICAFE_ERRNO_BASE  = 5000;
 const unsigned short ICAFE_SUCCESS      = ECA_NORMAL;
 const unsigned short ICAFE_NORMAL       = ECA_NORMAL;
 
@@ -119,11 +119,11 @@ enum CAFE_FILE_ERROR  { ECAFE_LOAD_COLLECTION=ICAFE_FILE_ERROR,
 enum CAFE_SERVICE_ERROR { ECAFE_BPM_DATA_IS_INVALID=ICAFE_SERVICE_ERROR
 												};
 //Used by zeromq
-enum CAFE_LINUX_ERROR { LINUX_EINTR =ICAFE_LINUX_ERROR+4,
-						LINUX_EAGAIN=ICAFE_LINUX_ERROR+11,
-						LINUX_EFAULT=ICAFE_LINUX_ERROR+14,
-						LINUX_ENOTSOCK=ICAFE_LINUX_ERROR+88,
-						LINUX_EPROTONOSUPPORT=ICAFE_LINUX_ERROR+93
+enum CAFE_ERRNO_ERROR { ERRNO_EINTR =ICAFE_ERRNO_BASE+4,
+						ERRNO_EAGAIN=ICAFE_ERRNO_BASE+11,
+						ERRNO_EFAULT=ICAFE_ERRNO_BASE+14,
+						ERRNO_ENOTSOCK=ICAFE_ERRNO_BASE+88,
+						ERRNO_EPROTONOSUPPORT=ICAFE_ERRNO_BASE+93
 					  };
 													
 
@@ -420,11 +420,11 @@ public:
 * 1100 ECAFE_LOAD_COLLECTION \n
 * 1101 ECAFE_LOAD_GROUP \n
 * 1200 ECAFE_BPM_DATA_IS_INVALID \n														
-* 5004 LINUX_EINTR \n
-* 5011 LINUX_EGAIN \n
-* 5014 LINUX_EFAULT \n
-* 5088 LINUX_ENOTSOCK \n
-* 5093 LINUX_EPROTONOSUPPORT \n
+* 5004 ERRNO_EINTR \n
+* 5011 ERRNO_EGAIN \n
+* 5014 ERRNO_EFAULT \n
+* 5088 ERRNO_ENOTSOCK \n
+* 5093 ERRNO_EPROTONOSUPPORT \n
 */
 class CAFEStatusInfo {
     typedef std::map<int, std::string> mapLongString;
@@ -510,18 +510,17 @@ public:
 
 		mapStatusInfo.insert(std::make_pair((int)  ECAFE_HANDLE_MISMATCH_SET_AND_MATCH, "Number of set/readback handles do not match"));
     mapStatusInfo.insert(std::make_pair((int)  ECAFE_INCONSISTENT_CONTAINER_CORRECTED, "Boost container required update after consistency check"));
-	 
-	 
+	 	 
 	  mapStatusInfo.insert(std::make_pair((int)  ECAFE_LOAD_COLLECTION,     "CAFE collection could not be loaded from xml configuration file " ));
     mapStatusInfo.insert(std::make_pair((int)  ECAFE_LOAD_GROUP,          "CAFE group could not be loaded from group xml configuration file " ));
 
-	mapStatusInfo.insert(std::make_pair((int)  ECAFE_BPM_DATA_IS_INVALID, "CAFE BPM Service: Data Validity channel reports BPM data is INVALID " ));
+	  mapStatusInfo.insert(std::make_pair((int)  ECAFE_BPM_DATA_IS_INVALID, "CAFE BPM Service: Data Validity channel reports BPM data is INVALID " ));
 		
-	mapStatusInfo.insert(std::make_pair((int)  LINUX_EINTR,    "C ERROR CODE IN LINUX: Interrupted system call" ));
-	mapStatusInfo.insert(std::make_pair((int)  LINUX_EAGAIN,   "C ERROR CODE IN LINUX: Try again" ));
-	mapStatusInfo.insert(std::make_pair((int)  LINUX_EFAULT,   "C ERROR CODE IN LINUX: Bad address" ));
-	mapStatusInfo.insert(std::make_pair((int)  LINUX_ENOTSOCK, "C ERROR CODE IN LINUX: Socket operation on non-socket" ));
-	mapStatusInfo.insert(std::make_pair((int)  LINUX_EPROTONOSUPPORT,   "C ERROR CODE IN LINUX: Protocol not supported" ));
+	  mapStatusInfo.insert(std::make_pair((int)  ERRNO_EINTR,    "C ERRNO CODE: Interrupted system call" ));
+	  mapStatusInfo.insert(std::make_pair((int)  ERRNO_EAGAIN,   "C ERRNO CODE: Try again" ));
+	  mapStatusInfo.insert(std::make_pair((int)  ERRNO_EFAULT,   "C ERRNO CODE: Bad address" ));
+	  mapStatusInfo.insert(std::make_pair((int)  ERRNO_ENOTSOCK, "C ERRNO CODE: Socket operation on non-socket" ));
+	  mapStatusInfo.insert(std::make_pair((int)  ERRNO_EPROTONOSUPPORT,   "C ERRNO CODE: Protocol not supported" ));
 }
 
   ~CAFEStatusInfo() {};
@@ -678,11 +677,11 @@ public:
 		
 	  mapStatusCode.insert(std::make_pair((int)  ECAFE_BPM_DATA_IS_INVALID, "CAFE_ERROR: ECAFE_BPM_DATA_IS_INVALID" ));
 
-		mapStatusCode.insert(std::make_pair((int)  LINUX_EINTR,    "CAFE_ERROR: LINUX_EINTR" ));
-		mapStatusCode.insert(std::make_pair((int)  LINUX_EAGAIN,   "CAFE_WARN: LINUX_EAGAIN " ));
-		mapStatusCode.insert(std::make_pair((int)  LINUX_EFAULT,   "CAFE_ERROR: LINUX_EFAULT" ));
-		mapStatusCode.insert(std::make_pair((int)  LINUX_ENOTSOCK, "CAFE_ERROR: LINUX_ENOTSOCK" ));
-		mapStatusCode.insert(std::make_pair((int)  LINUX_EPROTONOSUPPORT,   "CAFE_ERROR: LINUX_EPROTONOSUPPORT" ));
+		mapStatusCode.insert(std::make_pair((int)  ERRNO_EINTR,    "CAFE_ERROR: ERRNO_EINTR" ));
+		mapStatusCode.insert(std::make_pair((int)  ERRNO_EAGAIN,   "CAFE_WARN: ERRNO_EAGAIN " ));
+		mapStatusCode.insert(std::make_pair((int)  ERRNO_EFAULT,   "CAFE_ERROR: ERRNO_EFAULT" ));
+		mapStatusCode.insert(std::make_pair((int)  ERRNO_ENOTSOCK, "CAFE_ERROR: ERRNO_ENOTSOCK" ));
+		mapStatusCode.insert(std::make_pair((int)  ERRNO_EPROTONOSUPPORT,   "CAFE_ERROR: ERRNO_EPROTONOSUPPORT" ));
 																						
 };
 
@@ -887,11 +886,11 @@ public:
 	
 		mapStatusSeverity.insert(std::make_pair((int)  ECAFE_BPM_DATA_IS_INVALID, 						"WARN" ));
 	
-		mapStatusSeverity.insert(std::make_pair((int)  LINUX_EINTR,    "ERROR" ));
-		mapStatusSeverity.insert(std::make_pair((int)  LINUX_EAGAIN,   "WARN" ));
-		mapStatusSeverity.insert(std::make_pair((int)  LINUX_EFAULT,   "ERROR"));
-		mapStatusSeverity.insert(std::make_pair((int)  LINUX_ENOTSOCK,  "ERROR"));
-		mapStatusSeverity.insert(std::make_pair((int)  LINUX_EPROTONOSUPPORT, "ERROR"  ));
+		mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EINTR,    "ERROR" ));
+		mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EAGAIN,   "WARN" ));
+		mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EFAULT,   "ERROR"));
+		mapStatusSeverity.insert(std::make_pair((int)  ERRNO_ENOTSOCK,  "ERROR"));
+		mapStatusSeverity.insert(std::make_pair((int)  ERRNO_EPROTONOSUPPORT, "ERROR"  ));
 	
 	
 		

include/transpose.h

@@ -311,12 +311,6 @@ template <class CTYPE> int  Transpose<CTYPE>::put(const unsigned int  _handle,
             }//if noStrings>0
 
         }//if
-				
-				
-				//cout << "dbrTypeRequest_DataBuffer " << dbrTypeRequest_DataBuffer << endl;
-				//cout << "_dbrType " << _dbrType << endl;
-				
-				//cout << "nelem " << nelem << endl;
 
         switch (dbrTypeRequest_DataBuffer)
         {
@@ -450,12 +444,9 @@ template <class CTYPE> int  Transpose<CTYPE>::put(const unsigned int  _handle,
                 }
                 break;
             case DBR_DOUBLE:  //6
-						   
                 for (unsigned int  i=0; i<nelem; ++i) {
                     *((dbr_float_t *) (PVDataL) + i ) =   (dbr_float_t)   val[i] ;
-										
                 }
-								
                 break;
             case DBR_STRING:  //0
                 status=putString(_handle, (dbr_string_t *) val);
@@ -697,7 +688,7 @@ template <class CTYPE> int  Transpose<CTYPE>::put(const unsigned int  _handle,
         return ECAFE_INVALID_HANDLE;
     }
 
-    cout << "status " << status << endl;
+
 
     return status;
 

include/zhelpers.h

@@ -1,51 +1,24 @@
-/*  =====================================================================
-    zhelpers.h
 
-    Helper header file for example applications.
-    =====================================================================
-*/
+#ifndef ZHELPERS_H
+#define ZHELPERS_H
 
 
-
-#ifndef __ZHELPERS_H_INCLUDED__
-#define __ZHELPERS_H_INCLUDED__
-
-#if HAVE_ZEROMQ
-
-
-//  Include a bunch of headers that we will need in the examples
-
 #include <zmq.h>
 
+/*
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
-
-#if (defined (WIN32))
-#   include <time.h>
-#else
-#   include <sys/time.h>
-#endif
+*/
 
 #include <assert.h>
 #include <signal.h>
 
-//  Version checking, and patch up missing constants to match 2.1
-#if ZMQ_VERSION_MAJOR == 2
-#   error "Please upgrade to ZeroMQ/3.2 for these examples"
-#endif
-
-//  Provide random number from 0..(num-1)
-#if (defined (WIN32))
-#   define randof(num)  (int) ((float) (num) * rand () / (RAND_MAX + 1.0))
-#else
-#   define randof(num)  (int) ((float) (num) * random () / (RAND_MAX + 1.0))
-#endif
 
 #if HAVE_JSON
-	#include <json/json.h>
+#include <json/json.h>
 #endif
 	
 #include <cafeService.h>
@@ -57,36 +30,6 @@ string hashOriginal="";
 unsigned short hashOriginalFlag=0;
 bool fillBSPV=false;
 vector<std::string> bsPV;
-	
-//  Receive 0MQ string from socket and convert into C string
-//  Caller must free returned string. Returns NULL if the context
-//  is being terminated.
-static char *
-s_recv (void *socket) {
-    char buffer [4096];
-    int size = zmq_recv (socket, buffer, 4096, 0); //ZMQ_DONTWAIT);
-    if (size == -1)
-        return NULL;
-    if (size > 4096)
-        size = 4096;
-    buffer [size] = 0;
-    return strdup (buffer);
-}
-
-//  Convert C string to 0MQ string and send to socket
-static int
-s_send (void *socket, char *string) {
-    int size = zmq_send (socket, string, strlen (string), 0); 
-    return size;
-}
-
-//  Sends string as 0MQ string, as multipart non-terminal
-static int
-s_sendmore (void *socket, char *string) {
-    int size = zmq_send (socket, string, strlen (string), ZMQ_SNDMORE);
-    return size;
-}
-
 
 
 //  Receives all message parts from socket, prints neatly
@@ -97,7 +40,7 @@ s_dump (DBPMKeeper & dbpm)
 
 		if (inDumpFlag==1) {
 			cout << "zeroMQ socket is busy " << endl;
-			cout << "waiting got zmq timeout " << endl;
+			cout << "waiting for zmq timeout " << endl;
 		}
 		
    	puts ("//START----------------------------------------//");
@@ -124,20 +67,21 @@ s_dump (DBPMKeeper & dbpm)
 
     cout << "df = " << inDumpFlag << endl; 	
 
-	  while (inDumpFlag==1) {
+	   while (inDumpFlag==1) {
 		    cout << "df/ = " << inDumpFlag << endl; 
-	      cout << " sleeping " << endl;
-				sleep(1);
+			cout << " sleeping " << endl;
+				//sleep(1);
 		}
 
 		int subMessage=0;		
 		int nSequentialHeader=0;
 		
+
     while (1) {
 			  inDumpFlag=1;
 			 				
-		   // puts ("//WHILE LOOP ----------------------------------------//");
-				//cout << "subMessage " << subMessage << endl;
+			//puts ("//WHILE LOOP ----------------------------------------//");
+			//cout << "subMessage " << subMessage << endl;
         //  Process all parts of the message
         zmq_msg_t message;
         zmq_msg_init (&message);
@@ -149,32 +93,52 @@ s_dump (DBPMKeeper & dbpm)
 					cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
 					//Resource unavailable means that there is nothing to read now
 					
+					zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
+
+
+					//cout << "message mulipart --> more == " << more << endl;
+
+
 					 zmq_msg_close (&message);
-					 dbpm.status=ICAFE_LINUX_ERROR+zmq_errno() ;
+
+
+					 //if (!more) {
+					 //		   dbpm.status=ERRNO_EAGAIN; //ICAFE_ERRNO_BASE +zmq_errno() ;
+					 //		   cout << "EARLY BREAK subMessage total: " << subMessage << endl;
+					 //		   puts ("//------------------------------------END-------------------------------------//");
+					 //		 break;      //  Last message
+					 // }
+
+
+
+					 dbpm.status=ICAFE_ERRNO_BASE+zmq_errno() ;
 					 break;
 				} 
 				
 				
 				else if (size == 0) {
 
-					//cout << " Data of Zero SIZE for submessage " << subMessage << endl;
+					////cout << " Data of Zero SIZE for submessage " << subMessage << endl;
 			
 					++nZeroSize;
-					
+
+
 					 //zmq_msg_close (&message);
 					 //dbpm.status=ECAFE_NODATA;
 					 //break;
 					 //Comes in pairs; one for val one for timestamp
 					 if (nZeroSize%2==1) {
-					   ++bsPVIdx;					  
-						
-					  // cout << " pv with zero size:  " << bsPV[bsPVIdx] << endl;
-						 
+					   ++bsPVIdx;
+
+
+						if (bsPVIdx >0) {
+						   cout << bsPV[bsPVIdx] << endl;
+						}
 					 }
-					 				 
+
 					 ++subMessage;
 					 
-					 continue;
+					 //continue;
 				} 
         else { 
 			
@@ -190,9 +154,16 @@ s_dump (DBPMKeeper & dbpm)
             ||  (unsigned char) data [char_nbr] > 127)
                 is_text = 0;
 
-	      // printf (" SIZE [%03d] ", size);
+
+		//TExt is two header files
+		//non-text size=8 is X1, Y1, Q1
+		//non-text size=2 is -VALID
+		//non-text size=16 is timestamp
 
 		/*
+		printf (" SIZE [%03d] ", size);
+
+
 		if (is_text) {
 			cout << " TEXT +++++++++++ " << endl;
 		}
@@ -230,11 +201,11 @@ s_dump (DBPMKeeper & dbpm)
 				if (is_text) {
 						parsingSuccessful=reader.parse(data, parsedFromString);
 						if (parsingSuccessful) {
-							Json::StyledWriter styledWriter;
+							//Json::StyledWriter styledWriter;
 							//cout << "STYLED: --------------------------------" << endl;
 							//cout << styledWriter.write(parsedFromString) << endl;
 							//cout << "----------------------------------" << endl;
-							cout << parsedFromString["htype"] << endl;
+							//cout << parsedFromString["htype"] << endl;
 							
 							
 							if (fastWriter.write(parsedFromString["htype"]).find("bsr_m-1.1") != std::string::npos) { 
@@ -243,7 +214,7 @@ s_dump (DBPMKeeper & dbpm)
 
 								hashIs=parsedFromString["hash"].asString();
 
-								if (hashOriginalFlag<2) {
+								if (hashOriginalFlag==0) {
 									cout << hashIs << " is different to original/// " << hashOriginal << endl;	
 									hashOriginal=hashIs;
 									++hashOriginalFlag;
@@ -252,10 +223,14 @@ s_dump (DBPMKeeper & dbpm)
 
 								if (hashOriginal.compare(hashIs)!=0) {
 									cout << hashIs << " is different to original " << hashOriginal << endl;	
+									hashOriginal=hashIs;
+									++hashOriginalFlag;
 									fillBSPV=true;
 																
 								}
-                cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;		
+								 cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
+
+								 dbpm.setPulse_id(parsedFromString["pulse_id"].asUInt64());
 
 								//Reset values as a change of hash signifies that data from two pulse ids
 								//is being sent in one zeromq messages
@@ -283,9 +258,9 @@ s_dump (DBPMKeeper & dbpm)
 							}	
 							else if (fastWriter.write(parsedFromString["htype"]).find("bsr_d-1.1") != std::string::npos) { 
 							
-					
+							++nSequentialHeader;
 								
-							 //if  (fillBSPV) {
+							 if  (fillBSPV) {
 							
 									bsPV.clear();
 									bsPV.reserve(dbpm.getNPV());
@@ -324,7 +299,7 @@ s_dump (DBPMKeeper & dbpm)
 										
 										//cout << "NEW FILL: size of bsPV " <<  bsPV.size() << endl;
 										fillBSPV=false;
-								//}
+								}
 
 							}	
 							
@@ -338,24 +313,37 @@ s_dump (DBPMKeeper & dbpm)
 							}
 							
 							
-							//cout << "----------------------------------" << endl;
+							cout << "/----------------------------------/" << endl;
 								
 					}
 				}
 				
 				
-				if (nSequentialHeader >5) {
+				if (nSequentialHeader >3 && is_text==1) {
 					 cout << "WARNING: ZEROMQ SUB-MESSAGE DOES NOT CLOSE " << endl; 
-					 cout << "WARNING: FORCING CLOSE AND BREAKING FROM LOOP " << endl; 
-					 zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
+					 cout << "WARNING: FORCING ZMQ_MSG_CLOSE  " << endl;
+
+					 cout << "No of sequential headers " << nSequentialHeader << endl;
+					 cout << "is_text " << is_text << endl;
+					 //zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
 					 			 
-           zmq_msg_close (&message);
-					 cout << "message mulipart --> more == " << more << endl;
+					 //zmq_msg_close (&message);
+					 //cout << "message mulipart --> more == " << more << endl;
 					 	
-						dbpm.status=LINUX_EAGAIN; //ICAFE_LINUX_ERROR +zmq_errno() ;
-			 	  //break;
+
+					 //nSequentialHeader=0;
+					 //cannot break; results in seqmentation fault
+
+					 //if (!more) {
+					//		   dbpm.status=ERRNO_EAGAIN; //ICAFE_ERRNO_BASE +zmq_errno() ;
+					//		   cout << "EARLY BREAK subMessage total: " << subMessage << endl;
+					//		   puts ("//------------------------------------END-------------------------------------//");
+
+					// break;      //  Last message
+					//}
 				
 				}
+
 				
 				
 				union foo
@@ -408,7 +396,9 @@ s_dump (DBPMKeeper & dbpm)
 					
 					
 					dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set(v);
-					
+
+					dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].setBSStatus(ICAFE_NORMAL);
+
 					//cout << " readback of value that was set = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].d << endl;
 						
 					}
@@ -465,6 +455,9 @@ s_dump (DBPMKeeper & dbpm)
 							}
 							
 								//cout << "value DBPM = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].str << endl;
+
+
+								dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].setBSStatus(ICAFE_NORMAL);
 					}	
 				
 					
@@ -497,23 +490,27 @@ s_dump (DBPMKeeper & dbpm)
 					dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].ts.nsec=b;
 				}
 				
-			
-				
+
+
 					//cout << "subMessage above: " << subMessage << endl;
-				
-				++subMessage;
-				
+
+					++subMessage;
+
       
-				} //ifelse
+		} //ifelse
 				
       
         zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
+
         zmq_msg_close (&message);
 				
-			
+		//cout << "value of more " << more << endl;
 				
         if (!more) {
+				  dbpm.status=ICAFE_NORMAL;
 				  cout << "subMessage total: " << subMessage << endl;
+				  cout << " of which 0 size: " << nZeroSize << endl;
+				  cout << " Percentage good: " << (subMessage-nZeroSize-2)*100/(subMessage-2);
 				  puts ("//------------------------------------END-------------------------------------//");
 					 
             break;      //  Last message part
@@ -522,6 +519,16 @@ s_dump (DBPMKeeper & dbpm)
 		
 		inDumpFlag=0;
 	
+		if (subMessage>2) {
+			dbpm.status=ICAFE_NORMAL;
+		cout << "subMessage total: " << subMessage << endl;
+		cout << " of which 0 size: " << nZeroSize << endl;
+		cout << " Percentage good: " << (subMessage-nZeroSize-2)*100/(subMessage-2);
+		puts ("//------------------------------------END-------------------------------------//");
+		}
+
+
+		cout << "end of loop " << endl;
 		
 		return;
 }
@@ -763,68 +770,6 @@ s_dump (void *socket)
 		
 }
 
-//  Set simple random printable identity on socket
-//
-static void
-s_set_id (void *socket)
-{
-    char identity [10];
-    sprintf (identity, "%04X-%04X", randof (0x10000), randof (0x10000));
-    zmq_setsockopt (socket, ZMQ_IDENTITY, identity, strlen (identity));
-}
 
-/*
-//  Sleep for a number of milliseconds
-static void
-s_sleep (int msecs)
-{
-#if (defined (WIN32))
-    Sleep (msecs);
-#else
-    struct timespec t;
-    t.tv_sec  =  msecs / 1000;
-    t.tv_nsec = (msecs % 1000) * 1000000;
-    nanosleep (&t, NULL);
-#endif
-}
-*/
 
-//  Return current system clock as milliseconds
-static int64_t
-s_clock (void)
-{
-#if (defined (WIN32))
-    SYSTEMTIME st;
-    GetSystemTime (&st);
-    return (int64_t) st.wSecond * 1000 + st.wMilliseconds;
-#else
-    struct timeval tv;
-    gettimeofday (&tv, NULL);
-    return (int64_t) (tv.tv_sec * 1000 + tv.tv_usec / 1000);
-#endif
-}
-
-//  Print formatted string to stdout, prefixed by date/time and
-//  terminated with a newline.
-
-/*
-static void
-s_console (const char *format, ...)
-{
-    time_t curtime = time (NULL);
-    struct tm *loctime = localtime (&curtime);
-    char *formatted = (char*)malloc (20);
-    strftime (formatted, 20, "%y-%m-%d %H:%M:%S ", loctime);
-    printf ("%s", formatted);
-    free (formatted);
-
-    va_list argptr;
-    va_start (argptr, format);
-    vprintf (format, argptr);
-    va_end (argptr);
-    printf ("\n");
-}
-*/
-#endif  //  __ZHELPERS_H_INCLUDED__
-
-#endif
+#endif  //  ZHELPERS_H

include/zhelpers.h-

@@ -0,0 +1,830 @@
+/*  =====================================================================
+    zhelpers.h
+
+    Helper header file for example applications.
+    =====================================================================
+*/
+
+
+
+#ifndef __ZHELPERS_H_INCLUDED__
+#define __ZHELPERS_H_INCLUDED__
+
+#if HAVE_ZEROMQ
+
+
+//  Include a bunch of headers that we will need in the examples
+
+#include <zmq.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#if (defined (WIN32))
+#   include <time.h>
+#else
+#   include <sys/time.h>
+#endif
+
+#include <assert.h>
+#include <signal.h>
+
+//  Version checking, and patch up missing constants to match 2.1
+#if ZMQ_VERSION_MAJOR == 2
+#   error "Please upgrade to ZeroMQ/3.2 for these examples"
+#endif
+
+//  Provide random number from 0..(num-1)
+#if (defined (WIN32))
+#   define randof(num)  (int) ((float) (num) * rand () / (RAND_MAX + 1.0))
+#else
+#   define randof(num)  (int) ((float) (num) * random () / (RAND_MAX + 1.0))
+#endif
+
+#if HAVE_JSON
+	#include <json/json.h>
+#endif
+	
+#include <cafeService.h>
+
+
+unsigned short inDumpFlag=2;
+string hashIs="";
+string hashOriginal="";
+unsigned short hashOriginalFlag=0;
+bool fillBSPV=false;
+vector<std::string> bsPV;
+	
+//  Receive 0MQ string from socket and convert into C string
+//  Caller must free returned string. Returns NULL if the context
+//  is being terminated.
+static char *
+s_recv (void *socket) {
+    char buffer [4096];
+    int size = zmq_recv (socket, buffer, 4096, 0); //ZMQ_DONTWAIT);
+    if (size == -1)
+        return NULL;
+    if (size > 4096)
+        size = 4096;
+    buffer [size] = 0;
+    return strdup (buffer);
+}
+
+//  Convert C string to 0MQ string and send to socket
+static int
+s_send (void *socket, char *string) {
+    int size = zmq_send (socket, string, strlen (string), 0); 
+    return size;
+}
+
+//  Sends string as 0MQ string, as multipart non-terminal
+static int
+s_sendmore (void *socket, char *string) {
+    int size = zmq_send (socket, string, strlen (string), ZMQ_SNDMORE);
+    return size;
+}
+
+
+
+//  Receives all message parts from socket, prints neatly
+//
+static void
+s_dump (DBPMKeeper & dbpm)
+{
+
+		if (inDumpFlag==1) {
+			cout << "zeroMQ socket is busy " << endl;
+			cout << "waiting got zmq timeout " << endl;
+		}
+		
+   	puts ("//START----------------------------------------//");
+		
+		void * socket = dbpm.subscriber;
+		
+		
+		#if HAVE_JSON
+			Json::Value parsedFromString;
+			Json::Reader reader;
+			bool parsingSuccessful;
+			Json::FastWriter fastWriter;
+		
+		#endif
+		
+		    int64_t more;           //  Multipart detection
+        more = 0;
+        size_t more_size = sizeof (more);	
+		
+		int bsPVIdx=-1;
+		dbpm.status=ICAFE_NORMAL;
+
+		int nZeroSize=0;
+
+    cout << "df = " << inDumpFlag << endl; 	
+
+	  while (inDumpFlag==1) {
+		    cout << "df/ = " << inDumpFlag << endl; 
+	      cout << " sleeping " << endl;
+				sleep(1);
+		}
+
+		int subMessage=0;		
+		int nSequentialHeader=0;
+		
+    while (1) {
+			  inDumpFlag=1;
+			 				
+		   // puts ("//WHILE LOOP ----------------------------------------//");
+				//cout << "subMessage " << subMessage << endl;
+        //  Process all parts of the message
+        zmq_msg_t message;
+        zmq_msg_init (&message);
+				
+        size_t size = zmq_msg_recv (&message, socket, 0);
+				//puts ("//MESSAGE RECEIVED     ----------------------------------------//");
+				
+				if (size == -1) {
+					cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
+					//Resource unavailable means that there is nothing to read now
+					
+					 zmq_msg_close (&message);
+					 dbpm.status=ICAFE_LINUX_ERROR+zmq_errno() ;
+					 break;
+				} 
+				
+				
+				else if (size == 0) {
+
+					//cout << " Data of Zero SIZE for submessage " << subMessage << endl;
+			
+					++nZeroSize;
+					
+					 //zmq_msg_close (&message);
+					 //dbpm.status=ECAFE_NODATA;
+					 //break;
+					 //Comes in pairs; one for val one for timestamp
+					 if (nZeroSize%2==1) {
+					   ++bsPVIdx;					  
+						
+					  // cout << " pv with zero size:  " << bsPV[bsPVIdx] << endl;
+						 
+					 }
+					 				 
+					 ++subMessage;
+					 
+					 continue;
+				} 
+        else { 
+			
+        //  Dump the message as text or binary
+        char *data = (char*)zmq_msg_data (&message);
+        int is_text = 1;
+        int char_nbr;
+				
+				//char cmd[5000]="";
+				
+        for (char_nbr = 0; char_nbr < size; char_nbr++)
+            if ((unsigned char) data [char_nbr] < 32
+            ||  (unsigned char) data [char_nbr] > 127)
+                is_text = 0;
+
+	      // printf (" SIZE [%03d] ", size);
+
+		/*
+		if (is_text) {
+			cout << " TEXT +++++++++++ " << endl;
+		}
+		else {
+			cout << " NOT TEXT +++++++++++ " << endl;
+		}
+
+
+        for (char_nbr = 0; char_nbr < size; char_nbr++) {
+            if (is_text) {
+                printf ("%c", data [char_nbr]);
+								  //snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%c", data [char_nbr]);		
+																																	
+						}
+            else {
+                 printf ("%02X", (unsigned char) data [char_nbr]);
+								 //printf ("%d",   (unsigned char) data [char_nbr]);
+								 
+								//snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%d", (unsigned char)data [char_nbr]);
+								
+								//if (data[0] == '\x7') {
+								//	cout << " little endian " << endl;
+								//}
+								//else {
+								//	cout << "big endian " << endl;
+								//}
+				
+								
+						}
+        }//for
+		printf ("\n");
+		*/
+				
+			
+				if (is_text) {
+						parsingSuccessful=reader.parse(data, parsedFromString);
+						if (parsingSuccessful) {
+							Json::StyledWriter styledWriter;
+							//cout << "STYLED: --------------------------------" << endl;
+							//cout << styledWriter.write(parsedFromString) << endl;
+							//cout << "----------------------------------" << endl;
+							cout << parsedFromString["htype"] << endl;
+							
+							
+							if (fastWriter.write(parsedFromString["htype"]).find("bsr_m-1.1") != std::string::npos) { 
+
+								++nSequentialHeader;
+
+								hashIs=parsedFromString["hash"].asString();
+
+								if (hashOriginalFlag<2) {
+									cout << hashIs << " is different to original/// " << hashOriginal << endl;	
+									hashOriginal=hashIs;
+									++hashOriginalFlag;
+									fillBSPV=true;
+								}
+
+								if (hashOriginal.compare(hashIs)!=0) {
+									cout << hashIs << " is different to original " << hashOriginal << endl;	
+									fillBSPV=true;
+																
+								}
+                cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;		
+
+								//Reset values as a change of hash signifies that data from two pulse ids
+								//is being sent in one zeromq messages
+
+								subMessage=0;
+								
+								bsPVIdx=-1;
+								dbpm.status=ICAFE_NORMAL;
+
+								nZeroSize=0;
+								
+								
+							/*
+							cout << "(1)++++++++++++++++++++++++++++++++++++++++MAIN++++++++++++++++++++++++++++++++++++++++++"	<< endl;
+						
+								cout << "hash " << parsedFromString["hash"] << endl;
+								cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
+								cout << "g ts " << parsedFromString["global_timestamp"] << endl;
+								cout << "comp " << parsedFromString["dh_compression"] << endl;
+							
+								cout << "sec " << parsedFromString["global_timestamp"]["sec"].asUInt() << endl;
+							  cout << "nsec " << parsedFromString["global_timestamp"]["ns"].asUInt() << endl;
+							*/
+								
+							}	
+							else if (fastWriter.write(parsedFromString["htype"]).find("bsr_d-1.1") != std::string::npos) { 
+							
+					
+								
+							 //if  (fillBSPV) {
+							
+									bsPV.clear();
+									bsPV.reserve(dbpm.getNPV());
+									/*
+									if (dbpm.getNPV() != parsedFromString["channels"].size() ) {
+										cout << "No of CONFIGURED BPMS: " << dbpm.getNPV() 
+										     << " is diffent to that being channeled " <<  parsedFromString["channels"].size() << endl;
+										bsPV.reserve( max( (size_t) parsedFromString["channels"].size(),dbpm.getNPV()) );	 
+										
+									}
+									
+								*/
+		
+											   					
+								//cout << "chan " << parsedFromString["channels"] << endl;
+								
+								cout << "No of channels " << parsedFromString["channels"].size() << endl;
+
+								cout << "(2)++++++++++++++++++++++++++++++++++++++++HEADER++++++++++++++++++++++++++++++++++++++++++"	<< endl;
+													
+									 	for (Json::Value::ArrayIndex i=0; i < parsedFromString["channels"].size(); ++ i) {
+							
+									  		//cout << "name " << parsedFromString["channels"][i]["name"].asString() << endl;
+									  		//cout << "enco " << parsedFromString["channels"][i]["encoding"] << endl;
+								    		//cout << "type " << parsedFromString["channels"][i]["type"] << endl;
+									 
+									 			bsPV.push_back( (parsedFromString["channels"][i]["name"]).asString());
+										}
+										/*
+										cout << "LIST OF PVS " << endl;
+										for (size_t i=0; i< bsPV.size(); ++i ) {			
+											cout << i << " // " <<   bsPV[i].c_str() << " " << endl;
+										}
+										cout << endl;
+										*/
+										
+										//cout << "NEW FILL: size of bsPV " <<  bsPV.size() << endl;
+										fillBSPV=false;
+								//}
+
+							}	
+							
+							else {
+							
+							  cout << "HEADER IS SOMETHING ELSE: " << endl;
+										cout << parsedFromString["htype"] << endl;
+							
+								exit(1);
+							
+							}
+							
+							
+							//cout << "----------------------------------" << endl;
+								
+					}
+				}
+				
+				
+				if (nSequentialHeader >5) {
+					 cout << "WARNING: ZEROMQ SUB-MESSAGE DOES NOT CLOSE " << endl; 
+					 cout << "WARNING: FORCING CLOSE AND BREAKING FROM LOOP " << endl; 
+					 zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
+					 			 
+           zmq_msg_close (&message);
+					 cout << "message mulipart --> more == " << more << endl;
+					 	
+						dbpm.status=LINUX_EAGAIN; //ICAFE_LINUX_ERROR +zmq_errno() ;
+			 	  //break;
+				
+				}
+				
+				
+				union foo
+				{
+				char c[sizeof(double)];
+				double d;
+			
+				} bar;
+				
+				//SIZE 16 is timestamp
+				//SIZE 8  is x,y,Q
+				//SIZE 2  is valid
+				
+				if (subMessage > 1430) {
+				  cout << " SIZE " << size << " subMessage " << subMessage << endl;
+				  cout << "size of bsPV " <<  bsPV.size() << endl;
+				}	
+					
+				if (subMessage > 0 && subMessage%2 ==0) {
+					if (size==8) {
+						
+						// big endian	
+						for (char_nbr = 0; char_nbr < size; char_nbr++) {
+						 bar.c[char_nbr]=data[size-1-char_nbr];  // THis works for big engian
+						}
+						// little endian	
+						//for (char_nbr = 0; char_nbr < size; char_nbr++) {
+						// bar.c[char_nbr]=data[char_nbr];  
+						//}
+						
+						
+						//cout << "UNION D " << bar.d << endl;
+					
+						
+						double v; // = (double*) data;
+						memcpy(&v, bar.c, sizeof(double));
+							//cout << " double val " << v << endl;
+				
+					//This is BPM Data - value
+					++bsPVIdx;
+					 
+					if (dbpm.getPVIdx(bsPV[bsPVIdx]) <0)  {
+					  cout << " WARNING--> THIS CHANNEL WAS NOT REQUESTED IN CONFIGURATION FILE " << endl;
+						cout << " bsPV index = " <<  bsPVIdx << endl;
+					  cout << " pv from bs = " << bsPV[bsPVIdx] << endl;
+					  cout << " Illegal index Value =" << dbpm.getPVIdx(bsPV[bsPVIdx]) << endl;
+						cout << " SKIPPING THIS BPM... " << endl;
+						continue;
+					}
+					
+					
+					dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set(v);
+					
+					//cout << " readback of value that was set = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].d << endl;
+						
+					}
+					else if (size==2) {
+						unsigned short iv;
+						//memcpy(&iv, cmd, size);
+							//big endian
+							for (size_t n=0; n < size; n++) {
+								iv = (iv << 8) + data[n];
+							}
+							//little endian
+							//for (size_t n = size; n >= 0; n--) {
+						 	//	iv = (iv << 8) + data[n];
+							//}
+					
+					//This is BPM Data	- VALID/INVALID	
+							
+							//cout << "uint val (1 means valid) " << iv << endl;
+							
+					  /*
+						std::copy(data, data + 32, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 8, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 4, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 2, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 1, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						
+						*/
+							++bsPVIdx;
+						
+							 
+					if (dbpm.getPVIdx(bsPV[bsPVIdx]) <0)  {
+					  cout << " WARNING--> THIS CHANNEL WAS NOT REQUESTED IN CONFIGURATION FILE " << endl;
+						cout << " bsPV index = " <<  bsPVIdx << endl;
+					  cout << " pv from bs = " << bsPV[bsPVIdx] << endl;
+					  cout << " Illegal index Value =" << dbpm.getPVIdx(bsPV[bsPVIdx]) << endl;
+						cout << " SKIPPING THIS BPM ENUM TYPE " << endl;
+						continue;
+					}
+						
+								
+								
+								
+							if (iv==1) {
+								dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set((std::string) "VALID");
+								
+							}	
+							else {
+								dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].set((std::string) "INVALID");
+							}
+							
+								//cout << "value DBPM = " << dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].val[0].str << endl;
+					}	
+				
+					
+				}
+				else if (subMessage > 1 && subMessage%2 ==1) {
+					//cout << "timestamp " << endl;
+					unsigned int a,b;
+					for (size_t n=0; n < size/2; n++) {
+								a = (a << 8) + data[n];
+					}
+					for (size_t n=size/2; n < size; n++) {
+								b = (b << 8) + data[n];
+					}
+					
+					//cout << "a " << a << " b " << b << endl;
+					
+					 
+					if (dbpm.getPVIdx(bsPV[bsPVIdx]) <0)  {
+					  cout << " WARNING--> THIS CHANNEL WAS NOT REQUESTED IN CONFIGURATION FILE " << endl;
+						cout << " bsPV index = " <<  bsPVIdx << endl;
+					  cout << " pv from bs = " << bsPV[bsPVIdx] << endl;
+					  cout << " Illegal index Value =" << dbpm.getPVIdx(bsPV[bsPVIdx]) << endl;
+						cout << " SKIPPING THIS BPM TIMESTAMP " << endl;
+						continue;
+					}
+					
+					
+					
+					dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].ts.secPastEpoch=a;
+					dbpm.pvd[dbpm.getPVIdx(bsPV[bsPVIdx])].ts.nsec=b;
+				}
+				
+			
+				
+					//cout << "subMessage above: " << subMessage << endl;
+				
+				++subMessage;
+				
+      
+				} //ifelse
+				
+      
+        zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
+        zmq_msg_close (&message);
+				
+			
+				
+        if (!more) {
+				  cout << "subMessage total: " << subMessage << endl;
+				  puts ("//------------------------------------END-------------------------------------//");
+					 
+            break;      //  Last message part
+				}
+    } //while 1
+		
+		inDumpFlag=0;
+	
+		
+		return;
+}
+
+
+
+
+
+
+
+
+
+//  Receives all message parts from socket, prints neatly
+//
+static void
+s_dump (void *socket)
+{
+    puts ("//START----------------------------------------//");
+		int subMessage=0;
+		#if HAVE_JSON
+			Json::Value parsedFromString;
+			Json::Reader reader;
+			bool parsingSuccessful;
+			Json::FastWriter fastWriter;
+		
+		#endif
+		
+		
+		
+    while (1) {
+        //  Process all parts of the message
+        zmq_msg_t message;
+        zmq_msg_init (&message);
+        size_t size = zmq_msg_recv (&message, socket, 0);
+				
+				if (size == -1) {
+					cout << " Error is " << zmq_errno() << " " << zmq_strerror(zmq_errno()) << endl;
+					//Resource unavailable means that there is nothing to read now
+					
+					 zmq_msg_close (&message);
+					 break;
+				} 
+        else { 
+			
+        //  Dump the message as text or binary
+        char *data = (char*)zmq_msg_data (&message);
+        int is_text = 1;
+        int char_nbr;
+				
+				//char cmd[5000]="";
+				
+        for (char_nbr = 0; char_nbr < size; char_nbr++)
+            if ((unsigned char) data [char_nbr] < 32
+            ||  (unsigned char) data [char_nbr] > 127)
+                is_text = 0;
+
+        printf ("[%03d] ", size);
+				
+        for (char_nbr = 0; char_nbr < size; char_nbr++) {
+            if (is_text) {
+                printf ("%c", data [char_nbr]);
+								  //snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%c", data [char_nbr]);		
+																																	
+						}
+            else {
+                 printf ("%02X", (unsigned char) data [char_nbr]);
+								 //printf ("%d",   (unsigned char) data [char_nbr]);
+								 
+								//snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%d", (unsigned char)data [char_nbr]);
+								
+								//if (data[0] == '\x7') {
+								//	cout << " little endian " << endl;
+								//}
+								//else {
+								//	cout << "big endian " << endl;
+								//}
+				
+								
+						}
+        }//for
+					printf ("\n");	
+				/*
+        for (char_nbr = 0; char_nbr < size; char_nbr++) {
+            if (is_text) {
+                  printf ("%c", data [char_nbr]);
+								  snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%c", data [char_nbr]);
+								}
+            else {
+                printf ("%02X", (unsigned char) data [char_nbr]);
+								snprintf(cmd + strlen(cmd), (sizeof cmd) - strlen(cmd), "%02X", (unsigned char)data [size-1-char_nbr]);
+								}
+        }
+				*/
+			
+			
+			
+					
+			
+				if (is_text) {
+						parsingSuccessful=reader.parse(data, parsedFromString);
+						if (parsingSuccessful) {
+							Json::StyledWriter styledWriter;
+							cout << "STYLED: --------------------------------" << endl;
+							cout << styledWriter.write(parsedFromString) << endl;
+							cout << "----------------------------------" << endl;
+							cout << parsedFromString["htype"] << endl;
+							
+							
+							if (fastWriter.write(parsedFromString["htype"]).find("bsr_m-1.1") != std::string::npos) { 
+						
+								cout << "hash " << parsedFromString["hash"] << endl;
+								cout << "p id " << parsedFromString["pulse_id"].asUInt64() << endl;
+								cout << "g ts " << parsedFromString["global_timestamp"] << endl;
+								cout << "comp " << parsedFromString["dh_compression"] << endl;
+							
+								 cout << "sec " << parsedFromString["global_timestamp"]["sec"].asUInt() << endl;
+							  cout << "nsec " << parsedFromString["global_timestamp"]["ns"].asUInt() << endl;
+							
+								
+							}	
+							else if (fastWriter.write(parsedFromString["htype"]).find("bsr_d-1.1") != std::string::npos) { 
+						
+						
+						   
+						
+								cout << "chan " << parsedFromString["channels"] << endl;
+								
+							
+							
+									 for (Json::Value::ArrayIndex i=0; i < parsedFromString["channels"].size(); ++ i) {
+							
+									  cout << "name " << parsedFromString["channels"][i]["name"] << endl;
+									  cout << "enco " << parsedFromString["channels"][i]["encoding"] << endl;
+								    cout << "type " << parsedFromString["channels"][i]["type"] << endl;
+									 }
+								
+							}	
+							
+							
+							cout << "----------------------------------" << endl;
+								
+					}
+				}
+				
+				
+				
+				
+				union foo
+				{
+				char c[sizeof(double)];
+				double d;
+			
+				} bar;
+				
+				
+					
+				if (subMessage > 0 && subMessage%2 ==0) {
+					if (size==8) {
+						
+						// big endian	
+						for (char_nbr = 0; char_nbr < size; char_nbr++) {
+						 bar.c[char_nbr]=data[size-1-char_nbr];  // THis works for big engian
+						}
+						// little endian	
+						//for (char_nbr = 0; char_nbr < size; char_nbr++) {
+						// bar.c[char_nbr]=data[char_nbr];  
+						//}
+						
+						
+						cout << "UNION D " << bar.d << endl;
+					
+						
+						double v; // = (double*) data;
+						memcpy(&v, bar.c, sizeof(double));
+							cout << "double val " << v << endl;
+				
+				
+						
+					}
+					else if (size==2) {
+						unsigned short i;
+						//memcpy(&i, cmd, size);
+							//big endian
+							for (size_t n=0; n < size; n++) {
+								i = (i << 8) + data[n];
+							}
+							//little endian
+							//for (size_t n = size; n >= 0; n--) {
+						 	//	i = (i << 8) + data[n];
+							//}
+							
+							
+							cout << "uint val " << i << endl;
+							
+					  /*
+						std::copy(data, data + 32, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 8, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 4, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 2, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						std::copy(data, data + 1, reinterpret_cast<char *>(&i));
+						cout << "uint16  val " << i << endl;
+						
+						*/
+						
+					}	
+				}
+				else if (subMessage > 1 && subMessage%2 ==1) {
+					cout << "timestamp " << endl;
+					unsigned int a,b;
+					for (size_t n=0; n < size/2; n++) {
+								a = (a << 8) + data[n];
+					}
+					for (size_t n=size/2; n < size; n++) {
+								b = (b << 8) + data[n];
+					}
+					
+					cout << "a " << a << " b " << b << endl;
+				}
+				
+				++subMessage;
+				
+				} //ifelse
+				
+        int64_t more;           //  Multipart detection
+        more = 0;
+        size_t more_size = sizeof (more);
+        zmq_getsockopt (socket, ZMQ_RCVMORE, &more, &more_size);
+        zmq_msg_close (&message);
+        if (!more) {
+				  puts ("//END----------------------------------------//");
+            break;      //  Last message part
+				}
+    } //while 1
+		
+		
+}
+
+//  Set simple random printable identity on socket
+//
+static void
+s_set_id (void *socket)
+{
+    char identity [10];
+    sprintf (identity, "%04X-%04X", randof (0x10000), randof (0x10000));
+    zmq_setsockopt (socket, ZMQ_IDENTITY, identity, strlen (identity));
+}
+
+/*
+//  Sleep for a number of milliseconds
+static void
+s_sleep (int msecs)
+{
+#if (defined (WIN32))
+    Sleep (msecs);
+#else
+    struct timespec t;
+    t.tv_sec  =  msecs / 1000;
+    t.tv_nsec = (msecs % 1000) * 1000000;
+    nanosleep (&t, NULL);
+#endif
+}
+*/
+
+//  Return current system clock as milliseconds
+static int64_t
+s_clock (void)
+{
+#if (defined (WIN32))
+    SYSTEMTIME st;
+    GetSystemTime (&st);
+    return (int64_t) st.wSecond * 1000 + st.wMilliseconds;
+#else
+    struct timeval tv;
+    gettimeofday (&tv, NULL);
+    return (int64_t) (tv.tv_sec * 1000 + tv.tv_usec / 1000);
+#endif
+}
+
+//  Print formatted string to stdout, prefixed by date/time and
+//  terminated with a newline.
+
+/*
+static void
+s_console (const char *format, ...)
+{
+    time_t curtime = time (NULL);
+    struct tm *loctime = localtime (&curtime);
+    char *formatted = (char*)malloc (20);
+    strftime (formatted, 20, "%y-%m-%d %H:%M:%S ", loctime);
+    printf ("%s", formatted);
+    free (formatted);
+
+    va_list argptr;
+    va_start (argptr, format);
+    vprintf (format, argptr);
+    va_end (argptr);
+    printf ("\n");
+}
+*/
+#endif  //  __ZHELPERS_H_INCLUDED__
+
+#endif

makefile

@@ -227,7 +227,7 @@ htmldir = ${docdir}
 includedir = ${prefix}/include
 infodir = ${datarootdir}/info
 install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh
-libdir = /opt/gfa/cafe/cpp/cafe-1.3.0-final-2/lib
+libdir = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1/lib
 libexecdir = ${exec_prefix}/libexec
 localedir = ${datarootdir}/locale
 localstatedir = ${prefix}/var
@@ -236,7 +236,7 @@ mandir = ${datarootdir}/man
 mkdir_p = /bin/mkdir -p
 oldincludedir = /usr/include
 pdfdir = ${docdir}
-prefix = /opt/gfa/cafe/cpp/cafe-1.3.0-final-2
+prefix = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1
 program_transform_name = s,x,x,
 psdir = ${docdir}
 sbindir = ${exec_prefix}/sbin

src/cafe.cpp

@@ -23,6 +23,7 @@
 #include "conduitGroup.h"
 #include <set>
 
+
 bool MUTEX=true;
 bool CHECK_CONSISTENCY_CA_STATE=true;
 
@@ -90,7 +91,7 @@ int  CAFE::set(const unsigned int *handleArray, const unsigned int nelem, const
         }
 
 
-        if ( channelInfo.getCafeConnectionState() != ICAFE_CS_NEVER_CONN) {
+        if ( channelInfo.getCafeConnectionState() != ICAFE_CS_NEVER_CONN  && channelInfo.getCafeConnectionState() != ICAFE_CS_CLOSED ) {
             if (channelInfo.getDataType()==DBF_STRING) {
                 chtMax=DBR_STRING;
                 break;
@@ -171,6 +172,10 @@ int  CAFE::get(const unsigned int handle, long long * _val, \
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
     }
+		else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+        return ICAFE_CS_CLOSED;
+    }
+		
     status=ICAFE_NORMAL;
     unsigned int  nn=handleHelper.getNelemNative(handle);
 
@@ -258,6 +263,9 @@ int  CAFE::get(const unsigned int  handle, long long   * _val, \
     CAFE::getChannelInfo(handle, channelInfo);
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
+    }
+		else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+        return ICAFE_CS_CLOSED;
     }
     int  _status=ICAFE_NORMAL;
     unsigned int  nn=handleHelper.getNelemNative(handle);
@@ -344,6 +352,9 @@ int  CAFE::get(const unsigned int handle, long long * _val){
     CAFE::getChannelInfo(handle, channelInfo);
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
+    }
+		else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+        return ICAFE_CS_CLOSED;
     }
     int  _status=ICAFE_NORMAL;
     unsigned int  nn=handleHelper.getNelemNative(handle);
@@ -3016,6 +3027,10 @@ int  CAFE::set(unsigned int handle, const long long * val) { //5+ long long
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
     }
+		else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+        return ICAFE_CS_CLOSED;
+    }
+		
     int  _status=ICAFE_NORMAL;
     unsigned int  nn=handleHelper.getNelemNative(handle);
 

src/cafeCache.cpp

@@ -69,7 +69,7 @@ int CAFE::getCache(const unsigned int  *handleArray, unsigned int  nelem, long l
             nbyteChType=1;
         }
 
-        if ( channelInfo.getCafeConnectionState() != ICAFE_CS_NEVER_CONN) {
+        if ( channelInfo.getCafeConnectionState() != ICAFE_CS_NEVER_CONN  && channelInfo.getCafeConnectionState() != ICAFE_CS_CLOSED) {
             if (channelInfo.getDataType()==DBF_STRING) {
                 chtMax=DBR_STRING;
                 break;
@@ -230,6 +230,10 @@ int  CAFE::getCache(const unsigned int handle, long long * _val, \
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
     }
+		else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+        return ICAFE_CS_CLOSED;
+    }
+		
     int  _status=ICAFE_NORMAL;
     unsigned int  nn=handleHelper.getNelemRequest(handle);
 
@@ -318,6 +322,9 @@ int  CAFE::getCache(const unsigned int  handle, long long   * _val, \
     CAFE::getChannelInfo(handle, channelInfo);
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
+    }
+		else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+        return ICAFE_CS_CLOSED;
     }
     int  _status=ICAFE_NORMAL;
     unsigned int  nn=handleHelper.getNelemRequest(handle);
@@ -406,6 +413,10 @@ int  CAFE::getCache(const unsigned int handle, long long * _val){
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
     }
+		else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+        return ICAFE_CS_CLOSED;
+    }
+		
     int  _status=ICAFE_NORMAL;
     unsigned int  nn=handleHelper.getNelemRequest(handle);
 

src/cafeGroup.cpp

@@ -60,8 +60,6 @@ int  CAFE::groupAttach(const unsigned int _groupHandle, PVGroup &pvgroup) {
 
 	string s = handleHelper.getGroupNameFromGroupHandle(_groupHandle);
 
-
-
 	unsigned int iIdx;
 
 	if (s!="") {
@@ -450,13 +448,31 @@ int  CAFE::groupSet(const unsigned int  _groupHandle, PVGroup &pvgroup) {
 			}
 		} //while
 
-		if (ntries>0) {
+		if (ntries > 0 ) {
+		//if (ntries >= channelTimeoutPolicySGPut.getNtries() ) {
+			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+			std::cout << "No of(additional) tries=" << ntries << std::endl;
+
+      if (gStatus==ECAFE_TIMEOUT) {
+          std::cout << "is the MAXIMUM allowed as configured through SGTimeoutPolicy! "  << std::endl;
+					std::cout << "SETTING SELF-GOVERNING TIMEOUT FOR SG PUT OPERATIONS FOR THIS CHANNEL TO FALSE"  << std::endl;
+					std::cout << "RESTORING TIMEOUT TO ORIGINAL SG PUT VALUE OF: " << originalTimeOut << " SECONDS " << std::endl;
+					channelTimeoutPolicySGPut.setSelfGoverningTimeout(false);
+					channelTimeoutPolicySGPut.setTimeout( originalTimeOut );
+					if(MUTEX){cafeMutex.lock();}  //lock
+						groupHandle_index.modify(it_groupHandle,
+									 change_channelTimeoutPolicySGPut(channelTimeoutPolicySGPut));
+					if(MUTEX){cafeMutex.unlock();}  //unlock	
+										
+      } 
+			else{
 			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
 			cout << "Changed SG PUT from intitial " << originalTimeOut << " to: "  <<
 				(originalTimeOut +
 				 channelTimeoutPolicySGPut.getDeltaTimeout()*ntries)
 				<< " seconds after " << ntries << " sg_put calls " <<endl;
-		}
+			}
+		} //IF
 
 
 		//Withdraw this test for now; not required
@@ -1264,14 +1280,16 @@ int  CAFE::groupGet(const unsigned int  _groupHandle, PVGroup &pvgroup) {
 			cout << "Changing SG GET timeout from: " << channelTimeoutPolicySGGet.getTimeout()
 				 << " to: "  << (originalTimeOut + channelTimeoutPolicySGGet.getDeltaTimeout()*ntries)
 				 << " seconds"  << endl;
-
+			
+			
 			channelTimeoutPolicySGGet.setTimeout( (originalTimeOut +
 											  channelTimeoutPolicySGGet.getDeltaTimeout()*ntries));
-
+												
 			if(MUTEX){cafeMutex.lock();}  //lock
 			groupHandle_index.modify(it_groupHandle,
 									 change_channelTimeoutPolicySGGet(channelTimeoutPolicySGGet));
-			if(MUTEX){cafeMutex.unlock();}  //unlock
+			if(MUTEX){cafeMutex.unlock();}  //unlock	
+
 
 			if (gStatus == ECA_TIMEOUT) {
 				gStatus=(*it_groupHandle).get();
@@ -1280,12 +1298,35 @@ int  CAFE::groupGet(const unsigned int  _groupHandle, PVGroup &pvgroup) {
 		} //while
 
 		if (ntries>0) {
+		//if (ntries >= channelTimeoutPolicySGGet.getNtries() ) {
 			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
-			cout << "Changed SG GET from intitial " << originalTimeOut << " to: "  <<
+			std::cout << "No of(additional) tries=" << ntries << std::endl;
+
+      if (gStatus==ECAFE_TIMEOUT) {
+          std::cout << "is the MAXIMUM allowed as configured through SGTimeoutPolicy! "  << std::endl;
+					std::cout << "SETTING SELF-GOVERNING TIMEOUT FOR SG GET OPERATIONS FOR THIS CHANNEL TO FALSE"  << std::endl;
+					std::cout << "RESTORING TIMEOUT TO ORIGINAL SG GET VALUE OF: " << originalTimeOut << " SECONDS " << std::endl;
+					channelTimeoutPolicySGGet.setSelfGoverningTimeout(false);
+					channelTimeoutPolicySGGet.setTimeout( originalTimeOut );
+					if(MUTEX){cafeMutex.lock();}  //lock
+						groupHandle_index.modify(it_groupHandle,
+									 change_channelTimeoutPolicySGGet(channelTimeoutPolicySGGet));
+					if(MUTEX){cafeMutex.unlock();}  //unlock	
+										
+      } 
+			
+		  else {
+			
+				cout << "Changed SG GET from intitial " << originalTimeOut << " to: "  <<
 				(originalTimeOut +
 				 channelTimeoutPolicySGGet.getDeltaTimeout()*ntries)
-				<< " seconds after " << ntries << " sg_get calls " <<endl;
-		}
+				<< " seconds"  << endl;
+			
+			}
+		
+		}	//if
+				
+		
 
 		//Withdraw this test for now; not required
 		//if (ca_sg_test((*it_groupHandle).getGroupID()) == ECA_IOINPROGRESS) {

src/cafeVectors.cpp

@@ -451,7 +451,10 @@ int  CAFE::get(const unsigned int  _handle, vector<long long> & V,
         if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
             return ICAFE_CS_NEVER_CONN;
         }
-
+				else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+            return ICAFE_CS_CLOSED;
+        }
+				
         unsigned int  nelemThatWillBeRequested= (*it_handle).getChannelRegalia().getNelem();
 
         //Reserve only what will be in the buffer.
@@ -2714,7 +2717,10 @@ int  CAFE::set(const unsigned int  _handle, vector<long long> V) {
     if ( channelInfo.getCafeConnectionState() == ICAFE_CS_NEVER_CONN) {
         return ICAFE_CS_NEVER_CONN;
     }
-
+    else if ( channelInfo.getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+            return ICAFE_CS_CLOSED;
+    }
+				
     switch ( channelInfo.getDataType()) {
 
     case DBR_DOUBLE:

src/conduit.cpp

@@ -49,6 +49,9 @@ Conduit::Conduit(const char * _pv, ca_client_context *_ccc,  bool _pyCafeFlag) {
  *   \param _pv      input:      	process variable
  *   \param _ccc     input:     	ca_client_context
  *   \param _pyCafeFlag input: bool
+ *   \param _channelRequestPolicyPut input: ChannelRequestPolicyPut
+ *   \param _channelRequestPolicyGet input: ChannelRequestPolicyGet
+ *   \param _channelGetActionWhenMonitorPolicyGet input: ChannelGetActionWhenPolicyGet 
  */
 Conduit::Conduit(const char * _pv, ca_client_context *_ccc, 
 	ChannelRequestPolicy _channelRequestPolicyPut, ChannelRequestPolicy _channelRequestPolicyGet,
@@ -382,7 +385,7 @@ int  Conduit::getPVDataHolder(PVDataHolder & _pvd) const {
     chtype channelType = channelRequestMetaData.getDbrDataType();
     CAFENUM::DBR_TYPE dbrTypeClass=helper.convertToCAFEDbrTypeClass(channelType);
 
-    if ( channelRegalia.getCafeConnectionState()  != ICAFE_CS_NEVER_CONN ) {
+    if ( channelRegalia.getCafeConnectionState()  != ICAFE_CS_NEVER_CONN  &&  channelRegalia.getCafeConnectionState()  != ICAFE_CS_CLOSED) {
 
         switch(dbrTypeClass)
         {
@@ -610,7 +613,7 @@ int  Conduit::getPVDataHolder(PVDataHolder & _pvd) const {
         break;
 
     case TYPENOTCONN:
-        if ( channelRegalia.getCafeConnectionState()  != ICAFE_CS_NEVER_CONN ) {
+        if ( channelRegalia.getCafeConnectionState()  != ICAFE_CS_NEVER_CONN  &&  channelRegalia.getCafeConnectionState()  != ICAFE_CS_CLOSED ) {
         cout << __FILE__ << "/" << __LINE__ << "/" << __METHOD__  << endl;
         cout << "ERROR CAFE_TYPENOTCONN: dataType: "
                 <<  channelType <<  " : " << dbr_type_to_text(channelType) << endl;
@@ -648,7 +651,7 @@ int  Conduit::getPVCtrlHolder(PVCtrlHolder & _pvc) const {
 
     CAFENUM::DBR_TYPE dbrTypeClass=helper.convertToCAFEDbrTypeClass(channelType);
 
-    if ( channelRegalia.getCafeConnectionState()  != ICAFE_CS_NEVER_CONN ) {
+    if ( channelRegalia.getCafeConnectionState()  != ICAFE_CS_NEVER_CONN &&  channelRegalia.getCafeConnectionState()  != ICAFE_CS_CLOSED ) {
 
         switch(dbrTypeClass)
         {

src/conduitGroup.cpp

@@ -57,11 +57,10 @@ ConduitGroup::ConduitGroup(const char * _groupName, ca_client_context * _ccc,  C
     ++groupHandleNext;
     groupHandle	      = groupHandleNext;
 
-
     mStatus = new int [nMember];
     mRule = new bool[nMember];
     for (unsigned int i=0; i<nMember; ++i) {
-        mRule[i]="true";
+        mRule[i]=true;
         mStatus[i]=ICAFE_NORMAL;
     }
 };

src/connect.cpp

@@ -93,6 +93,9 @@ int  Connect::createChannel(unsigned int handle, const char * pv, chid &pCh) {
 
         if (status != ECA_NORMAL) {
             cout << __FILE__ << "//" << __LINE__ << "//"<< __METHOD__ << " ca_create_channel failed: " << endl;
+						if (status == ECA_EVDISALLOW) {
+            	cout << __FILE__ << "//" << __LINE__ << "//"<< __METHOD__ << " inappropriate function " << endl;
+						}
             cafeStatus.report(status);
 
              if(MUTEX){cafeMutex.lock();}  //lock
@@ -101,18 +104,58 @@ int  Connect::createChannel(unsigned int handle, const char * pv, chid &pCh) {
             return (int) status;
         }
 
-				
+					
 				
         //What is the POLICY!??
         //To Flush or to Pend this is the question!
 		
         if (channelOpenPolicy.getWhenToFlushSendBuffer()==FLUSH_AFTER_EACH_CHANNEL_CREATION) {
+							
+							
+            using namespace boost::posix_time;
+            ptime timeStart(microsec_clock::local_time());
+
+            double  timeElapsed=0;
+            unsigned int  nPoll=0;	
 							 	     
-              channelOpenPolicy.flushSendBufferNow(); 						        
+            channelOpenPolicy.flushSendBufferNow(); 	
+					  ptime timeEnd(microsec_clock::local_time());
+            time_duration duration(timeEnd-timeStart);
+            timeElapsed= (double) duration.total_microseconds()/1000000.0;
+
+            while ( !(*it_handle).isConnected() && timeElapsed <= channelOpenPolicy.getTimeout()){	
+									
+                #if HAVE_BOOST_THREAD
+                  boost::this_thread::sleep_for(boost::chrono::microseconds(1000));
+                #else
+                  #if HAVE_LINUX
+                  usleep(1000);
+                  #endif
+                #endif
+								
+                ++nPoll;
+
+                ptime timeEnd(microsec_clock::local_time());
+                time_duration duration(timeEnd-timeStart);
+                timeElapsed= (double) duration.total_microseconds()/1000000.0;
+							
+            }
+							
+						/*	
+						if ( (*it_handle).isConnected() ) {
+								cout << (*it_handle).getPV() << " // is connected //" << endl;
+						} 					        
+						else {
+								cout << (*it_handle).getPV() << " // is not connected //" << endl;
+						}
+						cout << "timeElapsed for open " << timeElapsed << " nPoll = " << nPoll << endl;
+						*/
+							
         }
 
 	
         // Peculiar if true
+				/*
         if (status == ECA_EVDISALLOW) {
             cout << __FILE__ << "//" << __LINE__ << "//"<< __METHOD__ << " inappropriate function " << endl;
             cafeStatus.report(status);
@@ -120,6 +163,11 @@ int  Connect::createChannel(unsigned int handle, const char * pv, chid &pCh) {
             handle_index.modify(it_handle, change_status (status) );
              if(MUTEX){cafeMutex.unlock();} //unlock
         }
+				*/
+				
+				
+				
+				//
     }
     else {
         return ECAFE_INVALID_HANDLE;
@@ -1124,19 +1172,17 @@ int  Connect::open(const char * _pv, const char * _pvAlias, unsigned int  & hand
 
         if (it_handle != handle_index.end()) {
 
-
             if ((*it_handle).getChannelID() != NULL &&  cctLocal != NULL ) {
 
-
                 status = ca_clear_channel((*it_handle).getChannelID());
 
-
-
                 if (status != ECA_NORMAL) {
                     return status; //ECA_BADCHID
                 }
 
-                status = ca_pend_io(channelClosePolicy.getTimeout());
+                status = ca_pend_io(channelClosePolicy.getTimeout()); //See channelClosePolicy.setPolicy in connect.h
+								//channelClosePolicy.flushSendBufferNow();
+									
                 if(MUTEX){cafeMutex.lock();}
                 handle_index.modify(it_handle, free_dataBuffers());
                 if(MUTEX){cafeMutex.unlock();}
@@ -1192,7 +1238,7 @@ int  Connect::open(const char * _pv, const char * _pvAlias, unsigned int  & hand
   *  \return ECA_NORMAL if all OK; error if one or more channelIDs fail to close
   */
  int  Connect::closeHandles(unsigned int * handleArray, unsigned int nHandles) {
- #define __METHOD__ "Connect::closeHandles(unsigned int *) "
+ #define __METHOD__ "Connect::closeHandles(unsigned int *, unsigned int) "
 
 		
 		//copy array to vector and remove dupliacte handles
@@ -1373,6 +1419,339 @@ int  Connect::open(const char * _pv, const char * _pvAlias, unsigned int  & hand
  }
 
 
+
+
+
+
+
+ /**
+  *  \brief Closes channel connections (even if in other thread) but does not delete handle.  \n
+  *  Note that this does NOT cause the channel's disconnect handler to be called.  \n
+  *  It does however invoke event handlers for subscriptions (i.e., monitors).  \n
+  *  The Conduit handle is NOT erased
+  *  \param  handle input
+  *  \return ECA_NORMAL if all OK else error
+  */
+ int  Connect::closeChannelKeepHandle(unsigned int handle) {
+ #define __METHOD__ "Connect::closeChannelKeepHandle"
+
+    //We can close handle irrespective of ca_current_context!
+    ca_client_context * cctLocal=  ca_current_context();
+
+    status=ICAFE_NORMAL;
+		
+		ChannelRegalia channelRegalia;
+
+    cafeConduit_set_by_handle & handle_index = cs.get<by_handle> ();
+    cafeConduit_set_by_handle::iterator it_handle;
+
+    it_handle = handle_index.find(handle);
+		
+		bool statusFlag=false;
+
+        if (it_handle != handle_index.end()) {
+
+            if ((*it_handle).getChannelID() != NULL &&  cctLocal != NULL ) {
+			
+								Connect::monitorStop(handle);			
+
+                status = ca_clear_channel((*it_handle).getChannelID());
+
+                if (status != ECA_NORMAL) {	
+										if(MUTEX){cafeMutex.lock();}  //lock
+   									handle_index.modify(it_handle, change_status (status) );
+    								if(MUTEX){cafeMutex.unlock();} //unlock						
+                    return status; //ECA_BADCHID
+                }
+
+								channelRegalia=(*it_handle).getChannelRegalia();
+
+                //status = ca_pend_io(channelClosePolicy.getTimeout()); //See channelClosePolicy.setPolicy in connect.h
+								channelClosePolicy.flushSendBufferNow();
+								
+								
+								//Do not want to free buffers(!)
+                //if(MUTEX){cafeMutex.lock();}
+                //handle_index.modify(it_handle, free_dataBuffers());
+                //if(MUTEX){cafeMutex.unlock();}
+            
+
+            		statusFlag=true;
+						}
+        }
+        else {
+            // Loop through all elements
+            for (itcs = cs.begin(); itcs != cs.end();) {
+                //Conduit cc = *itcs;
+
+                //operator overload prints handle, pv and nelem
+
+                if ((*itcs).handle == handle) {
+                    if ((*itcs).getChannelID() != NULL &&  cctLocal != NULL) {
+
+												Connect::monitorStop(handle);		
+
+                        status = ca_clear_channel((*itcs).getChannelID());
+                        if (status != ECA_NORMAL) {
+														if(MUTEX){cafeMutex.lock();}  //lock
+   													handle_index.modify(it_handle, change_status (status) );
+    												if(MUTEX){cafeMutex.unlock();} //unlock
+                            return status; //ECA_BADCHID
+                        }
+												channelRegalia=(*it_handle).getChannelRegalia();
+                        //status = ca_pend_io(channelClosePolicy.getTimeout());
+												channelClosePolicy.flushSendBufferNow();
+                        //if(MUTEX){cafeMutex.lock();}
+                        //handle_index.modify(itcs, free_dataBuffers());
+                        //if(MUTEX){cafeMutex.unlock();}
+                    }
+
+             
+                		statusFlag=true;
+										break;
+                }
+                else {
+                    ++itcs;
+                }
+            }
+            return ECAFE_INVALID_HANDLE;
+         }
+
+		if (statusFlag) {
+		
+    	if(MUTEX){cafeMutex.lock();}  //lock
+    	handle_index.modify(it_handle, change_status (ICAFE_CS_CLOSED) );
+    	if(MUTEX){cafeMutex.unlock();} //unlock
+
+			//Also callback done
+			ChannelRequestStatus channelRequestStatusGet;
+			ChannelRequestStatus channelRequestStatusPut;
+    	channelRequestStatusGet.setCallbackKind(false, true); //fake completion
+    	channelRequestStatusPut.setCallbackKind(false, true); //fake completion
+			if(MUTEX){cafeMutex.lock();}  //lock
+    	handle_index.modify(it_handle, change_channelRequestStatusGet (channelRequestStatusGet) );
+			handle_index.modify(it_handle, change_channelRequestStatusPut (channelRequestStatusPut) );
+    	if(MUTEX){cafeMutex.unlock();} //unlock
+			
+    	channelRegalia.setCafeConnectionState(ICAFE_CS_CLOSED);
+    	channelRegalia.setConnectFlag(false);  
+			channelRegalia.setConnectionState(ICAFE_CA_OP_CONN_DOWN);
+			channelRegalia.channelID=NULL;
+ 			if(MUTEX){cafeMutex.lock();}  //lock
+    	handle_index.modify(it_handle, change_channelRegalia (channelRegalia) );
+    	if(MUTEX){cafeMutex.unlock();} //unlock
+		}
+
+    return status; 
+
+ #undef __METHOD__
+ }
+
+
+
+
+
+
+
+
+ /**
+  *  \brief Closes given channel connections (even if in other threads) but does not deletes their handles.  \n
+  *  Note that this does NOT cause the channel's disconnect handler to be called.  \n
+  *  It does however invoke event subscriptions (for monitors).  \n
+  *  All corresponding Conduit handles are not erased.
+  *  \param handleArray input: unsigned int *
+  *  \param nHandles input: unsigned int
+  *  \return ECA_NORMAL if all OK; error if one or more channelIDs fail to close
+  */
+ int  Connect::closeChannelsKeepHandles(unsigned int * handleArray, unsigned int nHandles) {
+ #define __METHOD__ "Connect::closeChannelsKeepHandles(unsigned int *, unsigned int) "
+
+	
+		//copy array to vector and remove duplicate handles
+		vector<unsigned int> vec;
+		vec.reserve(nHandles);
+		vec.insert(vec.end(), &handleArray[0], &handleArray[nHandles]);
+	
+
+		//Remove duplicate values
+		sort( vec.begin(), vec.end() );
+		vec.erase( unique( vec.begin(), vec.end() ), vec.end() );
+
+	
+    int  statusGroup = ECA_NORMAL;
+    int  status      = ICAFE_NORMAL;
+
+    bool isClearChannel = false;
+   
+	  ChannelRegalia channelRegalia;
+	 
+	 
+    vector<bool>   isClearChannelV;
+	  isClearChannelV.reserve(vec.size());
+	
+    cafeConduit_set_by_handle & handle_index = cs.get<by_handle> ();
+    cafeConduit_set_by_handle::iterator it_handle;
+
+    if (ca_current_context() != NULL) {
+
+  
+				for (unsigned int i=0; i<vec.size(); ++i) {
+				
+						isClearChannelV.push_back(false);
+				
+            it_handle = handle_index.find(vec[i]);
+
+
+            if (it_handle != handle_index.end()) {
+
+                if ((*it_handle).getChannelID() != NULL  ) {
+										Connect::monitorStop(vec[i]);	
+                    status = ca_clear_channel((*it_handle).getChannelID());
+                    if (status != ECA_NORMAL) {
+                        statusGroup=status; //ECA_BADCHID
+                    }
+
+                }
+                isClearChannelV[i]=true;
+								isClearChannel=true;
+            }
+
+            else {
+
+                // Loop through all elements
+                for (itcs = cs.begin(); itcs != cs.end(); ++itcs) {
+
+                    //if ((*itcs).getHandle()==handleArray[i]) {
+										if ((*itcs).getHandle()==vec[i]) {
+
+                        if ((*itcs).getChannelID() != NULL ) {
+													 Connect::monitorStop(vec[i]);	
+                           status = ca_clear_channel((*itcs).getChannelID());
+
+                           //cout << "clear channel with handle: " << (*itcs).getHandle() << endl;
+
+                           if (status != ECA_NORMAL){
+                               statusGroup = status;
+                           }
+                           isClearChannelV[i]=true;
+													 isClearChannel=true;
+                        }
+                        break;
+                    }
+                }
+            }// else
+					
+        } //for
+    }//if ca_current_context != NULL
+
+    if (isClearChannel) {
+				channelClosePolicy.flushSendBufferNow();
+				
+        //status = ca_pend_io(channelClosePolicy.getTimeout());			
+        //if (statusGroup == ECA_NORMAL) {
+        //    statusGroup = status;
+        //}
+    
+
+				//for (unsigned int i=0; i<nHandles; ++i) {
+        //it_handle = handle_index.find(handleArray[i]);
+
+      for (unsigned int i=0; i<vec.size(); ++i) {
+        it_handle = handle_index.find(vec[i]);
+
+        if (it_handle != handle_index.end() &&  isClearChannelV[i]) {
+            //if(MUTEX){cafeMutex.lock();}
+            //handle_index.modify(it_handle, free_dataBuffers());
+            //if(MUTEX){cafeMutex.unlock();}
+						
+    			if(MUTEX){cafeMutex.lock();}  //lock
+    			handle_index.modify(it_handle, change_status (ICAFE_CS_CLOSED) );
+    			if(MUTEX){cafeMutex.unlock();} //unlock
+
+					//Also callback done
+					ChannelRequestStatus channelRequestStatusGet;
+					ChannelRequestStatus channelRequestStatusPut;
+    			channelRequestStatusGet.setCallbackKind(false, true); //fake completion
+    			channelRequestStatusPut.setCallbackKind(false, true); //fake completion
+					if(MUTEX){cafeMutex.lock();}  //lock
+    			handle_index.modify(it_handle, change_channelRequestStatusGet (channelRequestStatusGet) );
+					handle_index.modify(it_handle, change_channelRequestStatusPut (channelRequestStatusPut) );
+    			if(MUTEX){cafeMutex.unlock();} //unlock
+					
+					channelRegalia=(*it_handle).getChannelRegalia();
+    			channelRegalia.setCafeConnectionState(ICAFE_CS_CLOSED);
+    			channelRegalia.setConnectFlag(false);  
+					channelRegalia.setConnectionState(ICAFE_CA_OP_CONN_DOWN);
+					channelRegalia.channelID=NULL;
+ 					if(MUTEX){cafeMutex.lock();}  //lock
+    			handle_index.modify(it_handle, change_channelRegalia (channelRegalia) );
+    			if(MUTEX){cafeMutex.unlock();} //unlock
+						
+            
+        }
+        else {
+
+            // Loop through all elements
+            for (itcs = cs.begin(); itcs != cs.end();) {
+
+                //if ((*itcs).handle == handleArray[i]) {
+								if ((*itcs).handle == vec[i]  && isClearChannelV[i]) {
+                     //if(MUTEX){cafeMutex.lock();}
+                    //handle_index.modify(itcs, free_dataBuffers());
+                    // if(MUTEX){cafeMutex.unlock();}
+
+											
+    							if(MUTEX){cafeMutex.lock();}  //lock
+    							handle_index.modify(itcs, change_status (ICAFE_CS_CLOSED) );
+    							if(MUTEX){cafeMutex.unlock();} //unlock
+
+									//Also callback done
+									ChannelRequestStatus channelRequestStatusGet;
+									ChannelRequestStatus channelRequestStatusPut;
+    							channelRequestStatusGet.setCallbackKind(false, true); //fake completion
+    							channelRequestStatusPut.setCallbackKind(false, true); //fake completion
+									if(MUTEX){cafeMutex.lock();}  //lock
+    							handle_index.modify(itcs, change_channelRequestStatusGet (channelRequestStatusGet) );
+									handle_index.modify(itcs, change_channelRequestStatusPut (channelRequestStatusPut) );
+    							if(MUTEX){cafeMutex.unlock();} //unlock
+					
+									channelRegalia=(*itcs).getChannelRegalia();
+    							channelRegalia.setCafeConnectionState(ICAFE_CS_CLOSED);
+    							channelRegalia.setConnectFlag(false);  
+									channelRegalia.setConnectionState(ICAFE_CA_OP_CONN_DOWN);
+									channelRegalia.channelID=NULL;
+ 									if(MUTEX){cafeMutex.lock();}  //lock
+    							handle_index.modify(itcs, change_channelRegalia (channelRegalia) );
+    							if(MUTEX){cafeMutex.unlock();} //unlock
+
+
+                  break;
+             		}
+                else {
+                    ++itcs;
+                }
+            }  //for itcs       
+        }//if else
+
+      }//for
+		} //isClearChannel	
+
+
+
+    return statusGroup;
+
+ #undef __METHOD__
+ }
+
+
+
+
+
+
+
+
+
+
  /**
   *  \brief Closes channels for the given channel access client context. \n
   *  Shuts down the 'local' channel access client context and frees allocated resources  \n
@@ -1829,7 +2208,8 @@ int  Connect::monitorStart(vector<unsigned int> handleV, vector<int> &statusV,
          //FIRST CHECK IF CONNECTED!
          //Once connected, then we have this information stored
          //
-         if ((*it_handle).getChannelRegalia().getCafeConnectionState() !=  ICAFE_CS_NEVER_CONN ) {
+         if ((*it_handle).getChannelRegalia().getCafeConnectionState() !=  ICAFE_CS_NEVER_CONN  
+				 &&  (*it_handle).getChannelRegalia().getCafeConnectionState() !=  ICAFE_CS_CLOSED ) {
              mp.setDataType((*it_handle).getChannelRegalia().getDataType());
              mp.setNelem((*it_handle).getChannelRegalia().getNelem());
          }
@@ -2186,6 +2566,74 @@ int  Connect::monitorStart(vector<unsigned int> handleV, vector<int> &statusV,
  }
 
 
+
+
+ /**
+  *  \brief send the command to the ioc to open channels
+  *  \param _timeout input: max pend time to establish connections \n
+  */
+  void Connect::openNowAndWait(double _timeout) {
+	  double dto = channelOpenPolicy.getTimeout();
+	  channelOpenPolicy.setTimeout(_timeout);
+	  //channelOpenPolicy.flushSendBufferNow();
+		
+		//Time lapsed
+			
+    using namespace boost::posix_time;
+    ptime timeStart(microsec_clock::local_time());
+
+    double  timeElapsed=0;
+    unsigned int  nPoll=0;	
+							 	     
+    channelOpenPolicy.flushSendBufferNow(); 	
+		
+		ptime timeEnd(microsec_clock::local_time());
+    time_duration duration(timeEnd-timeStart);
+    timeElapsed= (double) duration.total_microseconds()/1000000.0;
+		
+
+    while ( !handleHelper.allChannelsConnected() && (timeElapsed <= channelOpenPolicy.getTimeout())){	
+									
+          #if HAVE_BOOST_THREAD
+            boost::this_thread::sleep_for(boost::chrono::microseconds(1000));
+          #else
+            #if HAVE_LINUX
+              usleep(1000);
+            #endif
+          #endif
+								
+          ++nPoll;
+
+          ptime timeEnd(microsec_clock::local_time());
+          time_duration duration(timeEnd-timeStart);
+          timeElapsed= (double) duration.total_microseconds()/1000000.0;
+							
+     }
+				
+						/*	
+						if ( handleHelper.allChannelsConnected() ) {
+								cout << " // all is connected //" << endl;
+						} 					        
+						else {
+								cout << " // all is not connected //" << endl;
+						}
+						cout << "timeElapsed for open " << timeElapsed << " nPoll = " << nPoll << endl;
+						*/
+		
+		
+		//reset 
+		channelOpenPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
+		channelOpenPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
+		//channelOpenPolicy.setTimeoutToDefault();
+		channelOpenPolicy.setTimeout(dto);
+		return;
+	} 
+	
+
+
+
+
+
  /**
   *  \brief print status information of given handle
   *  \param handle input: handle to Conduit object \n
@@ -2214,6 +2662,7 @@ int  Connect::monitorStart(vector<unsigned int> handleV, vector<int> &statusV,
  }
 
 
+
  /**
   *  \brief print status information of given handle only on error
   *  \param handle input: handle to Conduit object \n
@@ -2394,7 +2843,7 @@ int  Connect::monitorStart(vector<unsigned int> handleV, vector<int> &statusV,
 
  /**
   *  \brief print status information of given PVs only on error
-  *  \param handleArray input: array of Handles to Conduit objects \n
+  *  \param pvArray input: array of PVnames \n
   *  \param nelem input: size of array of handles
   *  \param statusArray input: array of statuses \n
   *  \return ECA_NORMAL if all OK else ECAFE_INVALID_HANDLE (if one or more handles are invalid)
@@ -2419,6 +2868,9 @@ int  Connect::monitorStart(vector<unsigned int> handleV, vector<int> &statusV,
 
 
 
+
+
+
  /**
   *  \brief Closes all channels within the given context and their respective handles \n
   *  Shuts down the given channel access client context and frees allocated resources \n

src/connectGroup.cpp

@@ -1128,9 +1128,9 @@ int Connect::collectionMemberList(const char * collectionName, vector<string> &l
 
 
 /**
- * \brief Connect::devicePositionOrderedMultiMap - returms a map of devices and their positions
+ * \brief Connect::devicePositionOrderedMultiMap - returns a map of devices and their positions
  * \param collectionName input: name of collection
- * \param devPos output: multimap of devices (string) and their positions (float) - odered in position
+ * \param posDev output: multimap of devices (string) and their positions (float) - odered in position
  * \return ICAFE_NORMAL is all OK else, ECAFE_UNKNOWN_COLLECTION
  */
 int Connect::devicePositionOrderedMultiMap(const char * collectionName, std::multimap<float, string> &posDev) {
@@ -1171,9 +1171,9 @@ int Connect::devicePositionOrderedMultiMap(const char * collectionName, std::mul
 
 
 /**
- * \brief Connect::devicePositionMap - returms a map of devices and their positions
+ * \brief Connect::devicePositionMap - returns a map of devices and their positions
  * \param collectionName input: name of collection
- * \param devPos output: map of devices (string) and their positions (float) - not ordered
+ * \param posDev output: map of devices (string) and their positions (float) - not ordered
  * \return ICAFE_NORMAL is all OK else, ECAFE_UNKNOWN_COLLECTION
  */
 int Connect::devicePositionMap(const char * collectionName, std::map<float, string> &posDev) {
@@ -1211,9 +1211,10 @@ int Connect::devicePositionMap(const char * collectionName, std::map<float, stri
 
 
 /**
- * \brief Connect::devicePositionMap - returms a map of devices and their positions
+ * \brief Connect::devicePositionV - returns a vector of devices and their positions
  * \param collectionName input: name of collection
- * \param devPos output: map of devices (string) and their positions (float) - not ordered
+ * \param dev output: vector of devices (string) 
+ * \param pos output: vector of devices positions (float) 
  * \return ICAFE_NORMAL is all OK else, ECAFE_UNKNOWN_COLLECTION
  */
 int Connect::devicePositionV(const char * collectionName, std::vector<string> &dev, std::vector<float> &pos) {
@@ -1297,6 +1298,11 @@ int Connect::fetchIndexOfCollectionMember(const char *collectionName, const char
 
 
 
+
+
+
+
+
 /**
  *  Establishes virtual circuit to epics process variable
  *  for each group member by calling Connect::open(pv, &handle)
@@ -1502,9 +1508,75 @@ int Connect::groupOpen(const char *groupName, unsigned int &groupHandle)
     {
 			  //Set timeout to a value that depends on the no of members: 1200 takes 3.5 seconds
 				double extraTime=nMember/NMEMBER_PER_SEC_SG_PEND_EVENT;
+				//if ( (DEFAULT_TIMEOUT_SG_PEND_EVENT + extraTime) > channelOpenGroupPolicy.getTimeout() ) {
+				if ( (channelOpenGroupPolicy.getDefaultTimeout() + extraTime) > channelOpenGroupPolicy.getTimeout() ) {
+					channelOpenGroupPolicy.setTimeout(channelOpenGroupPolicy.getDefaultTimeout()+ extraTime);
+				}
+				
+							
+				
+            using namespace boost::posix_time;
+            ptime timeStart(microsec_clock::local_time());
+
+            double  timeElapsed=0;
+            unsigned int  nPoll=0;	
+				
+				
+            channelOpenGroupPolicy.flushSendBufferNow();
+						
+						bool allConnected=true;						
+            for (unsigned int i = 0; i < nMember; ++i) {
+              it_handle = handle_index.find(memberHandle[i]);
+              if (it_handle != handle_index.end()) {
+							  if (!(*it_handle).isConnected()) {		
+									allConnected=false;						
+                }
+              }
+            }
+								
+					  ptime timeEnd(microsec_clock::local_time());
+            time_duration duration(timeEnd-timeStart);
+            timeElapsed= (double) duration.total_microseconds()/1000000.0;
+
+            while ( !allConnected && timeElapsed <= channelOpenGroupPolicy.getTimeout()){	
+									
+                #if HAVE_BOOST_THREAD
+                  boost::this_thread::sleep_for(boost::chrono::microseconds(1000));
+                #else
+                  #if HAVE_LINUX
+                  usleep(1000);
+                  #endif
+                #endif
+								
+                ++nPoll;
+								
+								allConnected=true;								
+                for (unsigned int i = 0; i < nMember; ++i) {
+                  it_handle = handle_index.find(memberHandle[i]);
+                  if (it_handle != handle_index.end()) {
+							      if (!(*it_handle).isConnected()) {		
+									    allConnected=false;						
+                    }
+                  }
+                }
+
+                ptime timeEnd(microsec_clock::local_time());
+                time_duration duration(timeEnd-timeStart);
+                timeElapsed= (double) duration.total_microseconds()/1000000.0;
+							
+            }
+							
+						/*
+						if (allConnected)  {
+								cout << groupName << " // is all connected //" << endl;
+						} 					        
+						else {
+								cout << groupName << " // is not all connected //" << endl;
+						}
+						cout << "timeElapsed for open " << timeElapsed << " nPoll = " << nPoll << endl;
+						*/
+				
 				
-				channelOpenGroupPolicy.setTimeout(DEFAULT_TIMEOUT_SG_PEND_EVENT + extraTime);
-        channelOpenGroupPolicy.flushSendBufferNow();
     }
 
     //memHandle must not be deleted; allocated memory for use elsewhere
@@ -1703,6 +1775,9 @@ int Connect::createChannelWithinGroup(unsigned int _handle, const char * pv, chi
 
         if (status != ECA_NORMAL) {
             cout << __FILE__ << "/" << __LINE__ << "/"<< __METHOD__ << " ca_create_channel failed: " << endl;
+						if (status == ECA_EVDISALLOW) {
+               cout << __FILE__ << "/" << __LINE__ << "/"<< __METHOD__ << " inappropriate function " << endl;
+						}
             cafeStatus.report(status);
 
             if(MUTEX){cafeMutex.lock();}  //lock
@@ -1712,6 +1787,7 @@ int Connect::createChannelWithinGroup(unsigned int _handle, const char * pv, chi
         }
 
         // Peculiar if true
+				/*
         if (status == ECA_EVDISALLOW) {
             cout << __FILE__ << "/" << __LINE__ << "/"<< __METHOD__ << " inappropriate function " << endl;
             cafeStatus.report(status);
@@ -1719,7 +1795,7 @@ int Connect::createChannelWithinGroup(unsigned int _handle, const char * pv, chi
             handle_index.modify(it_handle, change_status (status) );
             if(MUTEX){cafeMutex.unlock();} //unlock
         }
-
+				*/
     }
     else {
         return ECAFE_INVALID_HANDLE;
@@ -1828,3 +1904,130 @@ int Connect::createHandleWithinGroup(const char  * pv, ca_client_context * ccc,
 
 }
 
+
+
+
+
+ /**
+  *  \brief send the command to the ioc to open channels within all group(s).
+  *  \param _timeout input: max pend time to establish connections \n
+  */
+  void Connect::openGroupNowAndWait(double _timeout) {
+	  double dto = channelOpenGroupPolicy.getTimeout();
+	  channelOpenGroupPolicy.setTimeout(_timeout);
+	  		
+		//Time lapsed
+			
+    using namespace boost::posix_time;
+    ptime timeStart(microsec_clock::local_time());
+
+    double  timeElapsed=0;
+    unsigned int  nPoll=0;	
+							 	     
+    channelOpenGroupPolicy.flushSendBufferNow(); 	
+		
+		ptime timeEnd(microsec_clock::local_time());
+    time_duration duration(timeEnd-timeStart);
+    timeElapsed= (double) duration.total_microseconds()/1000000.0;
+		
+
+    while ( !handleHelper.allChannelsWithinGroupConnected() && (timeElapsed <= channelOpenGroupPolicy.getTimeout())){	
+									
+          #if HAVE_BOOST_THREAD
+            boost::this_thread::sleep_for(boost::chrono::microseconds(1000));
+          #else
+            #if HAVE_LINUX
+              usleep(1000);
+            #endif
+          #endif
+								
+          ++nPoll;
+
+          ptime timeEnd(microsec_clock::local_time());
+          time_duration duration(timeEnd-timeStart);
+          timeElapsed= (double) duration.total_microseconds()/1000000.0;
+							
+     }
+				
+							
+						if ( handleHelper.allChannelsWithinGroupConnected() ) {
+								cout << " // all group members are connected //" << endl;
+						} 					        
+						else {
+								cout << " // not all group members are connected //" << endl;
+						}
+						cout << "timeElapsed for group open " << timeElapsed << " nPoll = " << nPoll << endl;
+						
+		
+		
+		//reset 
+		channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
+		channelOpenGroupPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
+		//channelOpenPolicy.setTimeoutToDefault();
+		channelOpenGroupPolicy.setTimeout(dto);
+		return;
+	} 
+	
+
+ /**
+  *  \brief send the command to the ioc to open channels within given group(s).
+	*  \param _timeout input: max pend time to establish connections \n
+	*  \param  gHandles input: vector of groups handles \n
+  */
+  void Connect::openGroupNowAndWaitForInputGroups(double _timeout, vector<unsigned int> gHandles) {
+	  double dto = channelOpenGroupPolicy.getTimeout();
+	  channelOpenGroupPolicy.setTimeout(_timeout);
+	  		
+		//Time lapsed
+			
+    using namespace boost::posix_time;
+    ptime timeStart(microsec_clock::local_time());
+
+    double  timeElapsed=0;
+    unsigned int  nPoll=0;	
+							 	     
+    channelOpenGroupPolicy.flushSendBufferNow(); 	
+		
+		ptime timeEnd(microsec_clock::local_time());
+    time_duration duration(timeEnd-timeStart);
+    timeElapsed= (double) duration.total_microseconds()/1000000.0;
+		
+
+    while ( !handleHelper.allChannelsWithinGroupConnectedV(gHandles) && (timeElapsed <= channelOpenGroupPolicy.getTimeout())){	
+									
+          #if HAVE_BOOST_THREAD
+            boost::this_thread::sleep_for(boost::chrono::microseconds(1000));
+          #else
+            #if HAVE_LINUX
+              usleep(1000);
+            #endif
+          #endif
+								
+          ++nPoll;
+
+          ptime timeEnd(microsec_clock::local_time());
+          time_duration duration(timeEnd-timeStart);
+          timeElapsed= (double) duration.total_microseconds()/1000000.0;
+							
+     }
+				
+							
+						if ( handleHelper.allChannelsWithinGroupConnectedV(gHandles) ) {
+								cout << " // all group members of all groups are connected //" << endl;
+						} 					        
+						else {
+								cout << " // not all group members of all groups are connected //" << endl;
+						}
+						cout << "timeElapsed for mulitple group open " << timeElapsed << " nPoll = " << nPoll << endl;
+						
+		
+		
+		//reset 
+		channelOpenGroupPolicy.setWhenToFlushSendBuffer(FLUSH_NOW);
+		channelOpenGroupPolicy.setFlushSendBufferKind(WITH_POLL); //PEND_EVENT);
+		//channelOpenPolicy.setTimeoutToDefault();
+		channelOpenGroupPolicy.setTimeout(dto);
+		return;
+	} 
+	
+

src/granules.cpp

@@ -27,6 +27,10 @@ int  Granules::channelVerifyPut(const unsigned int  _handle, chtype _dbrType) {
         if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_NEVER_CONN)  {
             return ICAFE_CS_NEVER_CONN;
         }
+				else if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+            return ICAFE_CS_CLOSED;
+        }
+				
 
 		if ( CHECK_CONSISTENCY_CA_STATE && !(*it_handle).isConnected())  {
 			status=helper.checkConsistency(_handle);
@@ -386,26 +390,26 @@ int  Granules::channelExecutePut(const unsigned int  _handle) {
                         if (status==ECAFE_TIMEOUT) {
                             std::cout << "is the MAXIMUM allowed as configured through TimeoutPolicy! "  << std::endl;
 
-							std::cout << " SELF-GOVERNING TIMEOUT FOR SET OPERATIONS FOR THIS CHANNEL"  << std::endl;
-							channelTimeoutPolicyPut.setSelfGoverningTimeout(false);
-							channelTimeoutPolicyPut.setTimeout( channelTimeoutPolicyPut.getTimeout() );
+														std::cout << " SELF-GOVERNING TIMEOUT FOR SET OPERATIONS FOR THIS CHANNEL"  << std::endl;
+														channelTimeoutPolicyPut.setSelfGoverningTimeout(false);
+														channelTimeoutPolicyPut.setTimeout( channelTimeoutPolicyPut.getTimeout() );
                         }
-						else {
-							std::cout << "Changing timeout for handle/pv "
+												else {
+														std::cout << "Changing timeout for handle/pv "
                                   << _handle << "/" << (*it_handle).getPV() << " to: "  <<
                             (channelTimeoutPolicyPut.getTimeout() +
                              channelTimeoutPolicyPut.getDeltaTimeout()*ntries) << " seconds"  <<endl;					
-							channelTimeoutPolicyPut.setTimeout( (channelTimeoutPolicyPut.getTimeout() +
+															channelTimeoutPolicyPut.setTimeout( (channelTimeoutPolicyPut.getTimeout() +
                                                           channelTimeoutPolicyPut.getDeltaTimeout()*ntries));
-						}
+												}
                         if(MUTEX){cafeMutex.lock();}    //lock
                         handle_index.modify(it_handle, change_channelTimeoutPolicyPut(channelTimeoutPolicyPut));
-						if(MUTEX){cafeMutex.unlock();}  //unlock
+												if(MUTEX){cafeMutex.unlock();}  //unlock
 
-						if (status==ECAFE_TIMEOUT) {
-							std::cout << "CURRENT STATUS OF HANDLE: " << std::endl;
-							helper.printHandle(_handle);
-						}
+												if (status==ECAFE_TIMEOUT) {
+													std::cout << "CURRENT STATUS OF HANDLE: " << std::endl;
+													helper.printHandle(_handle);
+												}
                     } //isConnected
                 }
 
@@ -558,9 +562,15 @@ int  Granules::channelVerifyGet(const unsigned int  _handle, chtype _dbrType) {
 
     if (it_handle != handle_index.end()) {
 
+
         if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_NEVER_CONN)  {
             return ICAFE_CS_NEVER_CONN;
         }
+				else if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+            return ICAFE_CS_CLOSED;
+        }
+				
+						
 
 		if ( CHECK_CONSISTENCY_CA_STATE && !(*it_handle).isConnected())  {
 			status=helper.checkConsistency(_handle);
@@ -579,7 +589,7 @@ int  Granules::channelVerifyGet(const unsigned int  _handle, chtype _dbrType) {
             handle_index.modify(it_handle, change_channelRequestStatusGet(channelRequestStatusGet));
 
             handle_index.modify(it_handle, change_status(ICAFE_CA_OP_CONN_DOWN)); //for return
-          if(MUTEX){cafeMutex.unlock();}//unlock
+            if(MUTEX){cafeMutex.unlock();}//unlock
             return ICAFE_CA_OP_CONN_DOWN;
         }
 
@@ -1447,15 +1457,15 @@ int  Granules::waitForGetEvent(const unsigned int  _handle, double _timeout) {
 
             while (channelRequestStatusGet.getCallbackProgressKind() == CAFENUM::PENDING
                                                         && timeElapsed < _timeout){				
-				ca_flush_io();
+			    	ca_flush_io();
 				
-				#if HAVE_BOOST_THREAD
-				  boost::this_thread::sleep_for(boost::chrono::microseconds(20));
-				#else
-					#if HAVE_LINUX
-	        usleep(20);
-	        #endif
-				#endif
+			  	  #if HAVE_BOOST_THREAD
+				      boost::this_thread::sleep_for(boost::chrono::microseconds(20));
+				    #else
+					   #if HAVE_LINUX
+	           usleep(20);
+	           #endif
+				    #endif
                 ++nPoll;
 
                 ptime timeEnd(microsec_clock::local_time());
@@ -1650,9 +1660,16 @@ int  Granules::channelVerifyGetCtrl(const unsigned int  _handle, chtype _dbrType
 
     if (it_handle != handle_index.end()) {
 
+
+
         if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_NEVER_CONN)  {
             return ICAFE_CS_NEVER_CONN;
         }
+				else if ( (*it_handle).getChannelRegalia().getCafeConnectionState()==ICAFE_CS_CLOSED)  {
+            return ICAFE_CS_CLOSED;
+        }
+				
+				
 
 		if ( CHECK_CONSISTENCY_CA_STATE && !(*it_handle).isConnected())  {
 			status=helper.checkConsistency(_handle);

src/handleHelper.cpp

@@ -1112,7 +1112,7 @@ unsigned int HandleHelper::getHandleFromPVWithinGroup(const char * _pv,
  *  \return vector of handles within Group
  */
 vector<unsigned int>   HandleHelper::getHandlesFromWithinGroupV(unsigned int _groupHandle) {
-#define __METHOD__ "HandleHelper::getGroupHandlesFromWithinGroup"
+#define __METHOD__ "HandleHelper::getHandlesFromWithinGroupV"
 
 	cafeGroup_set_by_groupHandle & groupHandle_index = gs.get<by_groupHandle> ();
 	cafeGroup_set_by_groupHandle::iterator it_groupHandle;
@@ -1154,7 +1154,7 @@ vector<unsigned int>   HandleHelper::getHandlesFromWithinGroupV(unsigned int _gr
  *  \return array of handles within Group
  */
 unsigned int *   HandleHelper::getHandlesFromWithinGroup(unsigned int _groupHandle) {
-#define __METHOD__ "HandleHelper::getGroupHandlesFromWithinGroup"
+#define __METHOD__ "HandleHelper::getHandlesFromWithinGroup"
 
     cafeGroup_set_by_groupHandle & groupHandle_index = gs.get<by_groupHandle> ();
     cafeGroup_set_by_groupHandle::iterator it_groupHandle;
@@ -1187,6 +1187,74 @@ unsigned int *   HandleHelper::getHandlesFromWithinGroup(unsigned int _groupHand
 #undef __METHOD__
 }
 
+
+
+/**
+ *  \brief  Retrieves all handles belonging to a group referenced by its groupHandle
+ *  \param  _groupHandle input: groupHandle
+ *  \return vector of handles within Group
+ */
+vector<unsigned int>   HandleHelper::getDisconnectedHandlesFromWithinGroupV(unsigned int _groupHandle) {
+#define __METHOD__ "HandleHelper::getDisconnectedHandlesFromWithinGroupV"
+
+	cafeGroup_set_by_groupHandle & groupHandle_index = gs.get<by_groupHandle> ();
+	cafeGroup_set_by_groupHandle::iterator it_groupHandle;
+
+	it_groupHandle = groupHandle_index.find(_groupHandle);
+
+	vector<unsigned int> vhg;
+
+	if (it_groupHandle != groupHandle_index.end()) {
+		vhg.reserve( (*it_groupHandle).getNMember());
+		
+		cafeConduit_set_by_handle & handle_index = cs.get<by_handle> ();
+		cafeConduit_set_by_handle::iterator it_handle;
+		
+		for (unsigned int i=0; i <(*it_groupHandle).getNMember(); ++i ) {
+								
+			it_handle = handle_index.find((*it_groupHandle).mHandle[i]);
+
+			if (it_handle != handle_index.end()) {				
+			  if ( ! ((*it_handle).isConnected()) ) {
+				  vhg.push_back((*it_groupHandle).mHandle[i]);			
+			  }	
+			}
+		}
+		return vhg;
+	} else {
+		// Loop through all elements and search for grouphandle match
+		for (itgs = gs.begin(); itgs != gs.end(); ++itgs) {
+
+			if ((*itgs).getGroupHandle() == _groupHandle ) {
+				vhg.reserve( (*itgs).getNMember());
+				
+				cafeConduit_set_by_handle & handle_index = cs.get<by_handle> ();
+				cafeConduit_set_by_handle::iterator it_handle;
+				
+									
+				for (unsigned int i=0; i <(*itgs).getNMember(); ++i ) {
+				
+			   	it_handle = handle_index.find((*itgs).mHandle[i]);
+					if (it_handle != handle_index.end()) {		
+						if ( !((*it_handle).isConnected() ) ) {
+							vhg.push_back((*itgs).mHandle[i]);
+						}	
+					}	
+				}
+				return vhg;
+			}
+		}
+	}
+
+	cafeStatus.report(ECAFE_UNKNOWN_GROUP);
+
+  return vhg;
+#undef __METHOD__
+}
+
+
+
+
 /**
  *  \brief  Method returns true if channel is connected, else false
  *  \param  handle input: handle
@@ -1205,6 +1273,72 @@ bool HandleHelper::isChannelConnected(unsigned int handle){
 
 
 
+/**
+ *  \brief  Method returns true if all channels are connected, else false
+ *  \return bool
+ */
+bool HandleHelper::allChannelsConnected() {
+#define __METHOD__ "HandleHelper::allChannelsConnected"
+ 		ca_client_context * ccc = ca_current_context();
+    // Loop through all elements 
+    for (itcs = cs.begin(); itcs != cs.end(); ++itcs) {		
+        if (!(*itcs).isConnected() && (ccc ==(*itcs).getClientContext()) ) {			
+				  return false;	
+				}				
+		}		
+		
+    return true;
+#undef __METHOD__
+}
+
+
+/**
+ *  \brief  Method returns true if all channels are connected, else false
+ *  \return bool
+ */
+bool HandleHelper::allChannelsWithinGroupConnected() {
+#define __METHOD__ "HandleHelper::allChannelsWithinGroupConnected"
+ 		ca_client_context * ccc = ca_current_context();
+    // Loop through all elements 
+    for (itcs = cs.begin(); itcs != cs.end(); ++itcs) {		
+        if (!(*itcs).isConnected() && (ccc ==(*itcs).getClientContext()) && (*itcs).getGroupHandle()>0 ) {			
+				  return false;	
+				}				
+		}		
+		
+    return true;
+#undef __METHOD__
+}
+
+/**
+ *  \brief  Method returns true if all channels within the given vector of groups handles are connected, else false
+ *  \param  grpID input: vector of group handles
+ *  \return bool
+ */
+bool HandleHelper::allChannelsWithinGroupConnectedV(vector<unsigned int> grpID) {
+#define __METHOD__ "HandleHelper::allChannelsWithinGroupConnectedV"
+    if (grpID.size()==0) {
+			cout << __FILE__ << "//" << __LINE__ << "//" << __METHOD__ << endl;
+			cout << "Input vector listing group handles is of zero size " << endl;
+		} 
+				
+		for (size_t i=0; i<grpID.size(); ++i) {
+		  unsigned int nMem= HandleHelper::getDisconnectedHandlesFromWithinGroupV(grpID[i]).size();
+		  if ( nMem > 0) {
+			//cout << "group handle " << grpID[i] << " NOT all members connected " << endl;
+		   return false;
+		  }	
+			//cout << "group handle " << grpID[i] << " has all members connected " << endl;
+		}
+		
+		return true;
+		
+#undef __METHOD__
+}
+
+
+
+
 /**
  *  \brief  Retrieves last cached status information for given handle
  *  \param  _handle input: handle
@@ -1321,7 +1455,7 @@ int HandleHelper::getAlarmStatusSeverityAsString(unsigned int _handle, string as
 /**
  *  \brief Rerieves vector of handles for given vector of PVs
  *  \param pvV input: vector of PVS
- *  \retun handleV output: vector of handles 
+ *  \return vector of handles 
  */
 vector<unsigned int>  HandleHelper::getHandlesFromPVs(vector<string> pvV) {
 
@@ -1336,7 +1470,6 @@ vector<unsigned int>  HandleHelper::getHandlesFromPVs(vector<string> pvV) {
  *  \brief Rerieves vector of handles for given vector of PVs
  *  \param pvV input: vector of PVS
  *  \param ccc input: ca_client_context *
- *  \param handleV output: vector of handles 
  *  \return ICAFE_NORMAL if all OK else ECAFE_INVALID_HANDLE
  */
 vector<unsigned int> HandleHelper::getHandlesFromPVs(vector<string> pvV,  ca_client_context * ccc) {

src/makefile

@@ -207,7 +207,7 @@ htmldir = ${docdir}
 includedir = ${prefix}/include
 infodir = ${datarootdir}/info
 install_sh = ${SHELL} /afs/psi.ch/project/cafe/gitlab/CAFE/cpp/install-sh
-libdir = /opt/gfa/cafe/cpp/cafe-1.3.0-final-2/lib
+libdir = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1/lib
 libexecdir = ${exec_prefix}/libexec
 localedir = ${datarootdir}/locale
 localstatedir = ${prefix}/var
@@ -216,7 +216,7 @@ mandir = ${datarootdir}/man
 mkdir_p = /bin/mkdir -p
 oldincludedir = /usr/include
 pdfdir = ${docdir}
-prefix = /opt/gfa/cafe/cpp/cafe-1.3.0-final-2
+prefix = /opt/gfa/cafe/cpp/cafe-1.5.0-final-1
 program_transform_name = s,x,x,
 psdir = ${docdir}
 sbindir = ${exec_prefix}/sbin