pvaClientMultiChannel.h

Go to the documentation of this file.

/* pvaClientMultiChannel.h */
#ifndef PVACLIENTMULTICHANNEL_H
#define PVACLIENTMULTICHANNEL_H

#ifdef epicsExportSharedSymbols
#   define pvaClientMultiChannelEpicsExportSharedSymbols
#   undef epicsExportSharedSymbols
#endif

#include <pv/ntmultiChannel.h>
#include <pv/createRequest.h>

#ifdef pvaClientMultiChannelEpicsExportSharedSymbols
#   define epicsExportSharedSymbols
#   undef pvaClientMultiChannelEpicsExportSharedSymbols
#endif


#include <pv/pvaClient.h>


namespace epics { namespace pvaClient {


class PvaClientMultiChannel;
typedef std::tr1::shared_ptr<PvaClientMultiChannel> PvaClientMultiChannelPtr;
class PvaClientMultiGetDouble;
typedef std::tr1::shared_ptr<PvaClientMultiGetDouble> PvaClientMultiGetDoublePtr;
class PvaClientMultiPutDouble;
typedef std::tr1::shared_ptr<PvaClientMultiPutDouble> PvaClientMultiPutDoublePtr;
class PvaClientMultiMonitorDouble;
typedef std::tr1::shared_ptr<PvaClientMultiMonitorDouble> PvaClientMultiMonitorDoublePtr;

class PvaClientNTMultiGet;
typedef std::tr1::shared_ptr<PvaClientNTMultiGet> PvaClientNTMultiGetPtr;
class PvaClientNTMultiPut;
typedef std::tr1::shared_ptr<PvaClientNTMultiPut> PvaClientNTMultiPutPtr;
class PvaClientNTMultiMonitor;
typedef std::tr1::shared_ptr<PvaClientNTMultiMonitor> PvaClientNTMultiMonitorPtr;
class PvaClientNTMultiData;
typedef std::tr1::shared_ptr<PvaClientNTMultiData> PvaClientNTMultiDataPtr;


typedef epics::pvData::shared_vector<PvaClientChannelPtr> PvaClientChannelArray;

class epicsShareClass PvaClientMultiChannel :
    public std::tr1::enable_shared_from_this<PvaClientMultiChannel>
{
public:
    POINTER_DEFINITIONS(PvaClientMultiChannel);
    static PvaClientMultiChannelPtr create(
         PvaClientPtr const &pvaClient,
         epics::pvData::shared_vector<const std::string> const & channelNames,
         std::string const & providerName = "pva",
         size_t maxNotConnected=0
     );
    ~PvaClientMultiChannel();
    epics::pvData::shared_vector<const std::string> getChannelNames();
    epics::pvData::Status connect(double timeout=5);
    bool allConnected();
    bool connectionChange();
    epics::pvData::shared_vector<epics::pvData::boolean> getIsConnected();
    PvaClientChannelArray getPvaClientChannelArray();
    PvaClientPtr getPvaClient();
    PvaClientMultiGetDoublePtr createGet();
    PvaClientMultiPutDoublePtr createPut();
    PvaClientMultiMonitorDoublePtr createMonitor();
    PvaClientNTMultiPutPtr createNTPut();
    PvaClientNTMultiGetPtr createNTGet(
        std::string const &request = "field(value,alarm,timeStamp)");
    PvaClientNTMultiMonitorPtr createNTMonitor(
        std::string const &request= "field(value,alarm,timeStamp)");
private:
    PvaClientMultiChannel(
        PvaClientPtr const &pvaClient,
        epics::pvData::shared_vector<const std::string> const & channelName,
        std::string const & providerName,
        size_t maxNotConnected);
    void checkConnected();

    PvaClientPtr pvaClient;
    epics::pvData::shared_vector<const std::string> channelName;
    std::string providerName;
    size_t maxNotConnected;

    size_t numChannel;
    epics::pvData::Mutex mutex;

    size_t numConnected;
    PvaClientChannelArray pvaClientChannelArray;
    epics::pvData::shared_vector<epics::pvData::boolean> isConnected;
    epics::pvData::CreateRequest::shared_pointer createRequest;
};

class epicsShareClass PvaClientMultiGetDouble :
    public std::tr1::enable_shared_from_this<PvaClientMultiGetDouble>
{

public:
    POINTER_DEFINITIONS(PvaClientMultiGetDouble);

    static PvaClientMultiGetDoublePtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);

    ~PvaClientMultiGetDouble();

    void connect();
    epics::pvData::shared_vector<double> get();
    PvaClientMultiGetDoublePtr getPtrSelf()
    {
        return shared_from_this();
    }
private:
    PvaClientMultiGetDouble(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);

    PvaClientMultiChannelPtr pvaClientMultiChannel;
    PvaClientChannelArray pvaClientChannelArray;
    size_t nchannel;
    epics::pvData::Mutex mutex;

    epics::pvData::shared_vector<double> doubleValue;
    std::vector<PvaClientGetPtr> pvaClientGet;
    bool isGetConnected;
};

class epicsShareClass PvaClientMultiPutDouble :
    public std::tr1::enable_shared_from_this<PvaClientMultiPutDouble>
{

public:
    POINTER_DEFINITIONS(PvaClientMultiPutDouble);

    static PvaClientMultiPutDoublePtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);
    ~PvaClientMultiPutDouble();
    void connect();
    void put(epics::pvData::shared_vector<double> const &data);
    PvaClientMultiPutDoublePtr getPtrSelf()
    {
        return shared_from_this();
    }
private:
    PvaClientMultiPutDouble(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);

    PvaClientMultiChannelPtr pvaClientMultiChannel;
    PvaClientChannelArray pvaClientChannelArray;
    size_t nchannel;
    epics::pvData::Mutex mutex;

    std::vector<PvaClientPutPtr> pvaClientPut;
    bool isPutConnected;
};

class epicsShareClass PvaClientMultiMonitorDouble :
    public std::tr1::enable_shared_from_this<PvaClientMultiMonitorDouble>
{

public:
    POINTER_DEFINITIONS(PvaClientMultiMonitorDouble);

    static PvaClientMultiMonitorDoublePtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);
    ~PvaClientMultiMonitorDouble();
    void connect();
    bool poll();
    bool waitEvent(double secondsToWait);
    epics::pvData::shared_vector<double> get();
    PvaClientMultiMonitorDoublePtr getPtrSelf()
    {
        return shared_from_this();
    }
private:
    PvaClientMultiMonitorDouble(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);

    PvaClientMultiChannelPtr pvaClientMultiChannel;
    PvaClientChannelArray pvaClientChannelArray;
    size_t nchannel;
    epics::pvData::Mutex mutex;

    epics::pvData::shared_vector<double> doubleValue;
    std::vector<PvaClientMonitorPtr> pvaClientMonitor;
    bool isMonitorConnected;
};

class epicsShareClass PvaClientNTMultiGet :
    public std::tr1::enable_shared_from_this<PvaClientNTMultiGet>
{

public:
    POINTER_DEFINITIONS(PvaClientNTMultiGet);
    static PvaClientNTMultiGetPtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);

    ~PvaClientNTMultiGet();
    void connect();
    void get(bool valueOnly = true);
    PvaClientNTMultiDataPtr getData();
    PvaClientNTMultiGetPtr getPtrSelf()
    {
        return shared_from_this();
    }
private:
    PvaClientNTMultiGet(
         epics::pvData::UnionConstPtr const & u,
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);

    PvaClientMultiChannelPtr pvaClientMultiChannel;
    PvaClientChannelArray pvaClientChannelArray;
    epics::pvData::PVStructurePtr pvRequest;
    size_t nchannel;
    epics::pvData::Mutex mutex;


    PvaClientNTMultiDataPtr pvaClientNTMultiData;
    std::vector<PvaClientGetPtr> pvaClientGet;
    bool isConnected;
};

class epicsShareClass PvaClientNTMultiPut :
    public std::tr1::enable_shared_from_this<PvaClientNTMultiPut>
{

public:
    POINTER_DEFINITIONS(PvaClientNTMultiPut);
    static PvaClientNTMultiPutPtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);

    ~PvaClientNTMultiPut();
    void connect();
    epics::pvData::shared_vector<epics::pvData::PVUnionPtr> getValues();
    void put();
    PvaClientNTMultiPutPtr getPtrSelf()
    {
        return shared_from_this();
    }
private:
    PvaClientNTMultiPut(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);

    PvaClientMultiChannelPtr pvaClientMultiChannel;
    PvaClientChannelArray pvaClientChannelArray;
    size_t nchannel;
    epics::pvData::Mutex mutex;

    epics::pvData::shared_vector<epics::pvData::PVUnionPtr> unionValue;
    epics::pvData::shared_vector<epics::pvData::PVFieldPtr> value;
    std::vector<PvaClientPutPtr> pvaClientPut;
    bool isConnected;
};

class epicsShareClass PvaClientNTMultiMonitor :
    public std::tr1::enable_shared_from_this<PvaClientNTMultiMonitor>
{

public:
    POINTER_DEFINITIONS(PvaClientNTMultiMonitor);
    static PvaClientNTMultiMonitorPtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);
    ~PvaClientNTMultiMonitor();
    void connect();
    bool poll(bool valueOnly = true);
    bool waitEvent(double secondsToWait);
    PvaClientNTMultiDataPtr getData();
    PvaClientNTMultiMonitorPtr getPtrSelf()
    {
        return shared_from_this();
    }
private:
    PvaClientNTMultiMonitor(
         epics::pvData::UnionConstPtr const & u,
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);

    PvaClientMultiChannelPtr pvaClientMultiChannel;
    PvaClientChannelArray pvaClientChannelArray;
    epics::pvData::PVStructurePtr pvRequest;
    size_t nchannel;
    epics::pvData::Mutex mutex;
    PvaClientNTMultiDataPtr pvaClientNTMultiData;
    std::vector<PvaClientMonitorPtr> pvaClientMonitor;
    bool isConnected;
};

class epicsShareClass PvaClientNTMultiData :
    public std::tr1::enable_shared_from_this<PvaClientNTMultiData>
{

public:
    POINTER_DEFINITIONS(PvaClientNTMultiData);
    static PvaClientNTMultiDataPtr create(
         epics::pvData::UnionConstPtr const & u,
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);
    ~PvaClientNTMultiData();

    size_t getNumber();

    void startDeltaTime();
    void endDeltaTime(bool valueOnly = true);
    epics::pvData::TimeStamp getTimeStamp();
    epics::nt::NTMultiChannelPtr getNTMultiChannel();
    PvaClientNTMultiDataPtr getPtrSelf()
    {
        return shared_from_this();
    }
private:
    PvaClientNTMultiData(
         epics::pvData::UnionConstPtr const & u,
         PvaClientMultiChannelPtr const &pvaNTMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);
    void setPVStructure(
        epics::pvData::PVStructurePtr const &pvStructure,size_t index);

    PvaClientMultiChannelPtr pvaClientMultiChannel;
    PvaClientChannelArray pvaClientChannelArray;
    size_t nchannel;
    epics::pvData::Mutex mutex;

    std::vector<epics::pvData::PVStructurePtr> topPVStructure;
    bool gotAlarm;
    bool gotTimeStamp;

    epics::pvData::StructureConstPtr ntMultiChannelStructure;
    epics::pvData::shared_vector<epics::pvData::PVUnionPtr> unionValue;
    epics::pvData::shared_vector<epics::pvData::int32> severity;
    epics::pvData::shared_vector<epics::pvData::int32> status;
    epics::pvData::shared_vector<std::string> message;
    epics::pvData::shared_vector<epics::pvData::int64> secondsPastEpoch;
    epics::pvData::shared_vector<epics::pvData::int32> nanoseconds;
    epics::pvData::shared_vector<epics::pvData::int32> userTag;
    epics::pvData::Alarm alarm;
    epics::pvData::TimeStamp timeStamp;;
    epics::pvData::PVTimeStamp pvTimeStamp;
    friend class PvaClientNTMultiGet;
    friend class PvaClientNTMultiPut;
    friend class PvaClientNTMultiMonitor;
};


}}

#endif  /* PVACLIENTMULTICHANNEL_H */