daqsocket/DAQC_api.hh

/* -*- mode: c++; c-basic-offset: 4; -*- */
#ifndef DAQC_API_HH
#define DAQC_API_HH
//
//    This is a C++ interface for frame data.
//
#include <sys/time.h>
#include <time.h>
#include <vector>
#include <string>
#include <map>
#include "gmutex.hh"

//--------------------------------------  Default protocol ports
#ifndef DAQD_PORT
#define DAQD_PORT 8088
#endif
#define NDS2_PORT 31200

enum chantype {
    cUnknown,

    cOnline,

    cRaw,

    cRDS,

    cSTrend,

    cMTrend,

    cTestPoint

};

enum datatype {
    _undefined = 0,
    _16bit_integer = 1,
    _32bit_integer = 2,
    _64bit_integer = 3,
    _32bit_float = 4,
    _64bit_double = 5,
    _32bit_complex = 6
};

struct DAQDChannel {
    std::string mName;
    chantype mChanType;
    double mRate;
    datatype mDatatype;
    int mBOffset;
    int mStatus;
    float mGain;
    float mSlope;
    float mOffset;
    std::string mUnit;

    DAQDChannel(void) 
        : mChanType(cUnknown), mRate(0.0), mDatatype(_undefined), mBOffset(0), 
          mStatus(0), mGain(1.0), mSlope(1.0), mOffset(0.0)
    {}

    long nwords(double dt) const {
        return long(dt*mRate + 0.5);
    }

    static chantype cvt_str_chantype(const std::string& str);

    static const char* cvt_chantype_str(chantype typ);

    static datatype cvt_str_datatype(const std::string& str);

    static const char* cvt_datatype_str(datatype typ);

    static int datatype_size(datatype typ);
};

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

class DAQC_api {
public:
    typedef std::vector<DAQDChannel> chan_list;

    typedef chan_list::iterator channel_iter;

    typedef chan_list::const_iterator const_channel_iter;

    typedef double wait_time;

    typedef unsigned long count_type;

public:
    DAQC_api(void);

    virtual ~DAQC_api(void);

    virtual int open (const std::string& ipaddr, int ipport, 
                      long buflen = 16384) = 0;

    virtual void close() = 0;

    virtual void flush() = 0;

    virtual bool isOpen(void) const;

    virtual bool isOn(void) const;

    virtual int AddChannel(const DAQDChannel& chns);

    virtual int AddChannel(const std::string& chan, chantype ty, double rate);

    virtual int Available(chantype typ, long gps, chan_list& list, 
                          wait_time timeout=-1) = 0;

    const_channel_iter chan_begin(void) const;

    const_channel_iter chan_end(void) const;

    const_channel_iter FindChannel(const std::string& chan) const;

    channel_iter FindChannel(const std::string& chan);

    virtual int GetChannelData(const std::string& chan, float* data,
                               long maxlen) const;
   
     virtual int GetData(wait_time timeout = -1);

    virtual int GetData(char** buf, wait_time timeout = -1);

    virtual unsigned long nRequest(void) const;

    virtual int RequestOnlineData (double stride, wait_time timeout) = 0;
   
    virtual int RequestData (unsigned long start, unsigned long duration, 
                             wait_time timeout = -1) = 0;

    virtual void RmChannel(const std::string& chan);
   
    virtual void setAbort (bool* abort);

    virtual void setDebug(int debug=1);
    virtual void setDebug(bool debug=true);
   
    virtual int StopWriter() = 0;

    virtual int Times(chantype type, unsigned long& start, 
                      unsigned long& duration, wait_time timeout = -1);

     virtual float Version(void) const;

    virtual int  WaitforData (bool poll = false) = 0;

protected:
    void SwapHeader(void);

    int SwapData(void);

    int CVHex(const char* text, int N);
   
    virtual int RecvData(wait_time timeout=-1) = 0;
   
    virtual int RecvFloat(float& data, wait_time timeout=-1);

    virtual int RecvInt(int& data, wait_time timeout=-1);

    virtual int RecvRec(char *buf, long len, bool readall=false, 
                        wait_time maxwait=-1) = 0;
    
    virtual int RecvReconfig(count_type len, wait_time maxwait=-1) = 0;
   
    
    virtual int RecvStr(std::string& str, wait_time maxwait=-1);

public:
    class recvBuf {
    public:
        typedef unsigned long size_type;
    public:
        recvBuf(size_type length=0);
        ~recvBuf(void);
        size_type capacity(void) const;
        void clear(void);
        char* ref_data(void);
        const char* ref_data() const;
        DAQDRecHdr& ref_header();
        const DAQDRecHdr& ref_header() const;
        void reserve(size_type length);
    private:
        size_type  mLength;
        DAQDRecHdr mHeader;
        char*      mData;
    };

    recvBuf mRecvBuf;

protected:
    mutable thread::recursivemutex      mux;
   
    bool  mOpened;

    int mDebug;

    enum writer_type {
        NoWriter, 
        NameWriter, 
        DataWriter, 
        FrameWriter, 
        FastWriter,
        NDS2Writer
    } mWriterType;
   
    int   mOffline;

    int   mVersion;

    int   mRevision;

    bool* mAbort;

    chan_list mRequest_List;

};

//======================================  Inline methods
inline DAQC_api::const_channel_iter 
DAQC_api::chan_begin(void) const {
    return mRequest_List.begin();
}

inline DAQC_api::const_channel_iter 
DAQC_api::chan_end(void) const {
    return mRequest_List.end();
}

inline bool 
DAQC_api::isOpen(void) const {
    return mOpened;
}

inline float 
DAQC_api::Version(void) const {
    return mVersion + 0.01*mRevision;
}

inline bool 
DAQC_api::isOn() const {
    return mWriterType != NoWriter;
}

inline unsigned long 
DAQC_api::nRequest(void) const {
    return mRequest_List.size();
}

inline DAQC_api::recvBuf::size_type 
DAQC_api::recvBuf::capacity(void) const {
    return mLength;
}

inline char* 
DAQC_api::recvBuf::ref_data(void) {
    return mData;
}

inline const char* 
DAQC_api::recvBuf::ref_data() const {
    return mData;
}

inline DAQDRecHdr& 
DAQC_api::recvBuf::ref_header() {
    return mHeader;
}

inline const DAQDRecHdr&
DAQC_api::recvBuf:: ref_header() const {
    return mHeader;
}

#endif  //  DAQSOCKET_HH

---