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,
         epics::pvData::shared_vector<const std::string> const & providerNames
             = epics::pvData::shared_vector<const std::string>()
     );
    ~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 & channelNames,
        std::string const & providerName,
        size_t maxNotConnected,
        epics::pvData::shared_vector<const std::string> const & providerNames);
    void checkConnected();
 
    PvaClientPtr pvaClient;
    epics::pvData::shared_vector<const std::string> channelNames;
    std::string providerName;
    size_t maxNotConnected;
    epics::pvData::shared_vector<const std::string> const & providerNames;
 
    size_t numChannel;
    size_t numProviderNames;
    epics::pvData::Mutex mutex;
 
    size_t numConnected;
    bool firstConnect;
    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);
protected:
    static PvaClientMultiGetDoublePtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);
    friend class PvaClientMultiChannel;
public:
    ~PvaClientMultiGetDouble();
    void connect();
    epics::pvData::shared_vector<double> get();
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);
protected:
    static PvaClientMultiPutDoublePtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);
    friend class PvaClientMultiChannel;
public:
    ~PvaClientMultiPutDouble();
    void connect();
    void put(epics::pvData::shared_vector<double> const &data);
 
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);
protected:
    static PvaClientMultiMonitorDoublePtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);
    friend class PvaClientMultiChannel;
public:
    ~PvaClientMultiMonitorDouble();
    void connect();
    bool poll();
    bool waitEvent(double secondsToWait);
    epics::pvData::shared_vector<double> get();
 
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);
protected:
    static PvaClientNTMultiGetPtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);
    friend class PvaClientMultiChannel;
public:
    ~PvaClientNTMultiGet();
    void connect();
    void get(bool valueOnly = true);
    PvaClientNTMultiDataPtr getData();
 
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);
protected:
    static PvaClientNTMultiPutPtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray);
    friend class PvaClientMultiChannel;
public:
    ~PvaClientNTMultiPut();
    void connect();
    epics::pvData::shared_vector<epics::pvData::PVUnionPtr> getValues();
    void put();
 
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);
protected:    
    static PvaClientNTMultiMonitorPtr create(
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);
    friend class PvaClientMultiChannel;
public:
    ~PvaClientNTMultiMonitor();
    void connect();
    bool poll(bool valueOnly = true);
    bool waitEvent(double secondsToWait);
    PvaClientNTMultiDataPtr getData();
 
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);
    ~PvaClientNTMultiData();
    size_t getNumber();
    epics::pvData::TimeStamp getTimeStamp();
    epics::nt::NTMultiChannelPtr getNTMultiChannel();
    epics::pvData::shared_vector<epics::pvData::boolean> getChannelChangeFlags();
protected: 
    static PvaClientNTMultiDataPtr create(
         epics::pvData::UnionConstPtr const & u,
         PvaClientMultiChannelPtr const &pvaClientMultiChannel,
         PvaClientChannelArray const &pvaClientChannelArray,
         epics::pvData::PVStructurePtr const &  pvRequest);
    void startDeltaTime();
    void endDeltaTime(bool valueOnly = true);
    friend class PvaClientNTMultiGet;
    friend class PvaClientNTMultiMonitor;
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::shared_vector<epics::pvData::boolean> changeFlags;
    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;
};
 
 
}}
 
#endif  /* PVACLIENTMULTICHANNEL_H */