daqsocket/DAQSocket.hh

#ifndef DAQSOCKET_HH
#define DAQSOCKET_HH
//
//    This is a C++ interface for frame data.
//
#include <vector>
#include <string>
#include <map>
#include "gmutex.hh"
#include "sockutil.h"

#define DAQD_PORT 8088



   struct DAQDChannel {
      char mName[50];
      int  mGroup;
      int  mRate;
      int  mNum;
      int  mBPS;
      int  mDatatype;
      float mGain;
      float mSlope;
      float mOffset;
      char mUnit[40];
   };

   struct DAQDRecHdr {
      int Blen;
      int Secs;
      int GPS;
      int NSec;
      int SeqNum;
   };

   class DAQSocket {
   public:
      typedef std::pair<int, int> rate_bps_pair;
      typedef std::map<std::string, DAQDChannel> channellist;
      typedef channellist::iterator Channel_iter;
   
     channellist mChannel;
   
     DAQSocket();
   
     explicit DAQSocket(const char* ipaddr, int ipport = DAQD_PORT,
                        long RcvBufferLen = 16384);
   
      ~DAQSocket();
   
     int  open (const char* ipaddr, int ipport = DAQD_PORT, 
                long RcvBufferLen = 16384);
   
     void close();
   
     void flush();
   
     bool isOpen() const {
       return mOpened;
     }
   
     bool isOn() const {
       return mWriterType != NoWriter;
     }
   
     int  StopWriter();
   
     int  RequestFrames();
   
     int  RequestOnlineData (bool fast = false, long timeout = -1);
   
     int  RequestData (unsigned long start, unsigned long duration, 
                       long timeout = -1);
   
     int  RequestTrend (unsigned long start, unsigned long duration,
                        bool mintrend = false, long timeout = -1);
   
     int  RequestNames(long timeout = -1);
   
     int  WaitforData (bool poll = false);
   
     int AddChannel (const DAQDChannel& chns);
   
     int  AddChannel(const char* chan, 
                     rate_bps_pair rb = rate_bps_pair (0, 0));
   
     void RmChannel(const char* chan);

     int GetData(char* buf, long len, long timeout = -1);
   
      int GetData (char** buf, long timeout = -1);
   
      long GetName(char *buf, long len);
   
      long GetFrame(char *buf, long len);
   
      int  Available (DAQDChannel list[], long N);
   
      int  Available (std::vector<DAQDChannel>& list);
   
      int  Times (unsigned long& start, unsigned long& duration, 
                 long timeout = -1);
      int  TimesTrend (unsigned long& start, unsigned long& duration, 
                      bool mintrend = false, long timeout = -1);
   
      void setDebug(bool debug=true) {
         mDebug = debug;}
   
      void setAbort (bool* abort) {
         mAbort = abort;}
   
      bool TestOpen(void) {
         return mOpened;}
   
      float Version(void) {
         return mVersion + 0.01*mRevision;}
   
   private:
     int SendRequest(const char* text, char *reply=0, long length=0, 
                     long *Size=0, wait_time maxwait=-1);
   
      int RecvRec(char *buf, long len, bool readall=false, 
                 wait_time maxwait=-1);
   
      int SendRec(const char *buffer, long length, wait_time maxwait = -1);
   
      int RecvData(char *buf, long len, DAQDRecHdr* hdr=0, long timeout = -1);
   
      int RecvData(char **buf, long timeout = -1);
   
   private:
      mutable thread::recursivemutex    mux;
   
      bool  mOpened;
   
      bool  mDebug;
   
      int   mSocket;
   
      long   mRcvBuffer;
   
      bool  mGetAll;
   
      bool  mReorder;
   
      char  mWriter[8];
   
      enum {NoWriter, NameWriter, DataWriter, FrameWriter, FastWriter} 
      mWriterType;
   
      int   mOffline;
   
      int   mVersion;
   
      int   mRevision;
   
      bool*   mAbort;
   
   };

#endif  //  DAQSOCKET_HH

---