pvaClient.h

Go to the documentation of this file.

 
#ifndef PVACLIENT_H
#define PVACLIENT_H
 
#ifdef epicsExportSharedSymbols
#   define pvaClientEpicsExportSharedSymbols
#   undef epicsExportSharedSymbols
#endif
 
#include <list>
#include <iostream>
#include <ostream>
#include <sstream>
#include <pv/requester.h>
#include <pv/status.h>
#include <pv/event.h>
#include <pv/lock.h>
#include <pv/pvData.h>
#include <pv/pvTimeStamp.h>
#include <pv/timeStamp.h>
#include <pv/pvAlarm.h>
#include <pv/alarm.h>
#include <pv/pvAccess.h>
#include <pv/standardField.h>
#include <pv/standardPVField.h>
#include <pv/createRequest.h>
#include <pv/nt.h>
 
#ifdef pvaClientEpicsExportSharedSymbols
#   define epicsExportSharedSymbols
#   undef pvaClientEpicsExportSharedSymbols
#endif
 
#include <shareLib.h>
 
namespace epics { namespace pvaClient {
 
class PvaClient;
typedef std::tr1::shared_ptr<PvaClient> PvaClientPtr;
class PvaClientData;
typedef std::tr1::shared_ptr<PvaClientData> PvaClientDataPtr;
class PvaClientGetData;
typedef std::tr1::shared_ptr<PvaClientGetData> PvaClientGetDataPtr;
class PvaClientPutData;
typedef std::tr1::shared_ptr<PvaClientPutData> PvaClientPutDataPtr;
class PvaClientMonitorData;
typedef std::tr1::shared_ptr<PvaClientMonitorData> PvaClientMonitorDataPtr;
class PvaClientChannelStateChangeRequester;
typedef std::tr1::shared_ptr<PvaClientChannelStateChangeRequester> PvaClientChannelStateChangeRequesterPtr;
typedef std::tr1::weak_ptr<PvaClientChannelStateChangeRequester> PvaClientChannelStateChangeRequesterWPtr;
class PvaClientChannel;
typedef std::tr1::shared_ptr<PvaClientChannel> PvaClientChannelPtr;
class PvaClientProcessRequester;
typedef std::tr1::shared_ptr<PvaClientProcessRequester> PvaClientProcessRequesterPtr;
typedef std::tr1::weak_ptr<PvaClientProcessRequester> PvaClientProcessRequesterWPtr;
class PvaClientProcess;
typedef std::tr1::shared_ptr<PvaClientProcess> PvaClientProcessPtr;
class PvaClientGetRequester;
typedef std::tr1::shared_ptr<PvaClientGetRequester> PvaClientGetRequesterPtr;
typedef std::tr1::weak_ptr<PvaClientGetRequester> PvaClientGetRequesterWPtr;
class PvaClientGet;
typedef std::tr1::shared_ptr<PvaClientGet> PvaClientGetPtr;
class PvaClientPutRequester;
typedef std::tr1::shared_ptr<PvaClientPutRequester> PvaClientPutRequesterPtr;
typedef std::tr1::weak_ptr<PvaClientPutRequester> PvaClientPutRequesterWPtr;
class PvaClientPut;
typedef std::tr1::shared_ptr<PvaClientPut> PvaClientPutPtr;
class PvaClientPutGetRequester;
typedef std::tr1::shared_ptr<PvaClientPutGetRequester> PvaClientPutGetRequesterPtr;
typedef std::tr1::weak_ptr<PvaClientPutGetRequester> PvaClientPutGetRequesterWPtr;
class PvaClientPutGet;
typedef std::tr1::shared_ptr<PvaClientPutGet> PvaClientPutGetPtr;
class PvaClientMonitor;
typedef std::tr1::shared_ptr<PvaClientMonitor> PvaClientMonitorPtr;
class PvaClientMonitorRequester;
typedef std::tr1::shared_ptr<PvaClientMonitorRequester> PvaClientMonitorRequesterPtr;
typedef std::tr1::weak_ptr<PvaClientMonitorRequester> PvaClientMonitorRequesterWPtr;
class PvaClientRPC;
typedef std::tr1::shared_ptr<PvaClientRPC> PvaClientRPCPtr;
class PvaClientRPCRequester;
typedef std::tr1::shared_ptr<PvaClientRPCRequester> PvaClientRPCRequesterPtr;
typedef std::tr1::weak_ptr<PvaClientRPCRequester> PvaClientRPCRequesterWPtr;
 
// following are private to pvaClient
class PvaClientChannelCache;
typedef std::tr1::shared_ptr<PvaClientChannelCache> PvaClientChannelCachePtr;
 
 
class epicsShareClass PvaClient :
     public epics::pvData::Requester,
     public std::tr1::enable_shared_from_this<PvaClient>
{
public:
    POINTER_DEFINITIONS(PvaClient);
    ~PvaClient();
    static PvaClientPtr get(std::string const & providerNames = "pva ca");
    static PvaClientPtr create() EPICS_DEPRECATED;
    void message(
        std::string const & message,
        epics::pvData::MessageType messageType);
    PvaClientChannelPtr channel(
        std::string const & channelName,
        std::string const &providerName = "pva",
        double timeOut = 5.0);
    PvaClientChannelPtr createChannel(
       std::string const & channelName,
       std::string const & providerName = "pva");
 
    void setRequester(epics::pvData::RequesterPtr const & requester);
    std::string getRequesterName();
    void clearRequester();
    void showCache();
    size_t cacheSize();
    static void setDebug(bool value);
    static bool getDebug();
private:
    PvaClient(std::string const & providerNames);
    PvaClientChannelCachePtr pvaClientChannelCache;
    epics::pvData::Requester::weak_pointer requester;
    bool pvaStarted;
    bool caStarted;
    epics::pvData::Mutex mutex;
    epics::pvAccess::ChannelProviderRegistry::shared_pointer channelRegistry;
};
 
// folowing private to PvaClientChannel
class PvaClientGetCache;
typedef std::tr1::shared_ptr<PvaClientGetCache> PvaClientGetCachePtr;
class PvaClientPutCache;
typedef std::tr1::shared_ptr<PvaClientPutCache> PvaClientPutCachePtr;
 
 
class epicsShareClass PvaClientChannelStateChangeRequester
{
public:
    POINTER_DEFINITIONS(PvaClientChannelStateChangeRequester);
    virtual ~PvaClientChannelStateChangeRequester(){}
    virtual void channelStateChange(PvaClientChannelPtr const & channel, bool isConnected) = 0;
};
 
class epicsShareClass PvaClientChannel :
   public epics::pvAccess::ChannelRequester,
   public std::tr1::enable_shared_from_this<PvaClientChannel>
{
public:
    POINTER_DEFINITIONS(PvaClientChannel);
    ~PvaClientChannel();
    void setStateChangeRequester(PvaClientChannelStateChangeRequesterPtr const &stateChangeRequester);
    std::string getChannelName();
    epics::pvAccess::Channel::shared_pointer getChannel();
    void connect(double timeout=5.0);
    void issueConnect();
    epics::pvData::Status waitConnect(double timeout = 5.0);
    PvaClientProcessPtr createProcess(std::string const & request = "");
    PvaClientProcessPtr createProcess(epics::pvData::PVStructurePtr const &  pvRequest);
    PvaClientGetPtr get(std::string const & request = "field(value,alarm,timeStamp)");
    PvaClientGetPtr createGet(std::string const & request = "field(value,alarm,timeStamp)");
    PvaClientGetPtr createGet(epics::pvData::PVStructurePtr const &  pvRequest);
    double getDouble(std::string const & request = "field(value)");
    std::string getString(std::string const & request = "field(value)");
    epics::pvData::shared_vector<const double>  getDoubleArray(
        std::string const & request = "field(value)");
    epics::pvData::shared_vector<const std::string>  getStringArray(
        std::string const & request = "field(value)");
    PvaClientPutPtr put(std::string const & request = "field(value)");
    PvaClientPutPtr createPut(std::string const & request = "field(value)");
    PvaClientPutPtr createPut(epics::pvData::PVStructurePtr const & pvRequest);
    void putDouble(double value,std::string const & request = "field(value)");
    void putString(std::string const & value,std::string const & request = "field(value)");
    void putDoubleArray(
        epics::pvData::shared_vector<const double> const & value,
        std::string const & request = "field(value)");
    void putStringArray(
        epics::pvData::shared_vector<const std::string> const & value,
        std::string const & request = "field(value)");
    void putStringArray(std::vector<std::string> const & value,std::string const & request = "field(value)");
    PvaClientPutGetPtr createPutGet(
         std::string const & request = "putField(argument)getField(result)");
    PvaClientPutGetPtr createPutGet(epics::pvData::PVStructurePtr const & pvRequest);
    PvaClientMonitorPtr monitor(std::string const & request = "field(value,alarm,timeStamp)");
    PvaClientMonitorPtr monitor(PvaClientMonitorRequesterPtr const & pvaClientMonitorRequester);
    PvaClientMonitorPtr monitor(
        std::string const & request,
        PvaClientMonitorRequesterPtr const & pvaClientMonitorRequester);
    PvaClientMonitorPtr createMonitor(
         std::string const & request = "field(value,alarm,timeStamp)");
    PvaClientMonitorPtr createMonitor(epics::pvData::PVStructurePtr const &  pvRequest);
     epics::pvData::PVStructurePtr rpc(
          epics::pvData::PVStructurePtr const &  pvRequest,
          epics::pvData::PVStructurePtr const & pvArgument);
     epics::pvData::PVStructurePtr rpc(
          epics::pvData::PVStructurePtr const & pvArgument);
    PvaClientRPCPtr createRPC();
    PvaClientRPCPtr createRPC(epics::pvData::PVStructurePtr const &  pvRequest);
    void showCache();
    size_t cacheSize();
private:
    static PvaClientChannelPtr create(
         PvaClientPtr const &pvaClient,
         std::string const & channelName,
         std::string const & providerName);
    PvaClientChannel(
        PvaClientPtr const &pvaClient,
        std::string const & channelName,
        std::string const & providerName);
 
    enum ConnectState {connectIdle,connectActive,notConnected,connected};
 
    PvaClient::weak_pointer pvaClient;
    std::string channelName;
    std::string providerName;
    ConnectState connectState;
 
    epics::pvData::CreateRequest::shared_pointer createRequest;
    PvaClientGetCachePtr pvaClientGetCache;
    PvaClientPutCachePtr pvaClientPutCache;
 
    epics::pvData::Mutex mutex;
    epics::pvData::Event waitForConnect;
    epics::pvAccess::Channel::shared_pointer channel;
    epics::pvAccess::ChannelProvider::shared_pointer channelProvider;
    PvaClientChannelStateChangeRequesterWPtr stateChangeRequester;
public:
    virtual std::string getRequesterName();
    virtual void message(std::string const & message, epics::pvData::MessageType messageType);
    virtual void channelCreated(
        const epics::pvData::Status& status,
        epics::pvAccess::Channel::shared_pointer const & channel);
    virtual void channelStateChange(
        epics::pvAccess::Channel::shared_pointer const & channel,
        epics::pvAccess::Channel::ConnectionState connectionState);
    friend class PvaClient;
};
 
class epicsShareClass PvaClientData
{
public:
    POINTER_DEFINITIONS(PvaClientData);
    ~PvaClientData() {}
    void setMessagePrefix(std::string const & value);
   epics::pvData::StructureConstPtr getStructure();
   epics::pvData::PVStructurePtr getPVStructure();
   epics::pvData::BitSetPtr getChangedBitSet();
   std::ostream & showChanged(std::ostream & out);
    void setData(
        epics::pvData::PVStructurePtr const & pvStructureFrom,
        epics::pvData::BitSetPtr const & bitSetFrom);
 
    bool hasValue();
    bool isValueScalar();
    bool isValueScalarArray();
    epics::pvData::PVFieldPtr getValue();
    epics::pvData::PVScalarPtr getScalarValue();
    std::tr1::shared_ptr<epics::pvData::PVArray> getArrayValue();
    std::tr1::shared_ptr<epics::pvData::PVScalarArray> getScalarArrayValue();
    double getDouble();
    std::string getString();
    epics::pvData::shared_vector<const double>  getDoubleArray();
    epics::pvData::shared_vector<const std::string>  getStringArray();
    epics::pvData::Alarm getAlarm();
    epics::pvData::TimeStamp getTimeStamp();
    void parse(const std::vector<std::string> &args);
    void streamJSON(
               std::ostream& strm,
               bool ignoreUnprintable = true,
               bool multiLine = false);
    void zeroArrayLength();
protected:
    static PvaClientDataPtr create(epics::pvData::StructureConstPtr const & structure);
    PvaClientData(epics::pvData::StructureConstPtr const & structure);
    epics::pvData::PVFieldPtr getSinglePVField();
    void checkValue();
    std::string messagePrefix;
private:
    void parse(
        const std::string &arg,
        const epics::pvData::PVFieldPtr &dest,
        epics::pvData::BitSetPtr &bitSet);
    void parse(
        const std::string &arg,
        const epics::pvData::PVUnionPtr &dest);
    void zeroArrayLength(const epics::pvData::PVStructurePtr &pvStructure);
 
    epics::pvData::StructureConstPtr structure;
    epics::pvData::PVStructurePtr pvStructure;
    epics::pvData::BitSetPtr bitSet;
 
    epics::pvData::PVFieldPtr pvValue;
    epics::pvData::PVAlarm pvAlarm;
    epics::pvData::PVTimeStamp pvTimeStamp;
    friend class PvaClientGet;
    friend class PvaClientPutGet;
};
 
class epicsShareClass PvaClientGetData : public PvaClientData
{
public:
    POINTER_DEFINITIONS(PvaClientGetData);
    ~PvaClientGetData() {}
    static PvaClientGetDataPtr create(epics::pvData::StructureConstPtr const & structure);
private:
    PvaClientGetData(epics::pvData::StructureConstPtr const & structure);
    friend class PvaClientGet;
    friend class PvaClientPutGet;
};
 
class PvaClientPostHandlerPvt; // private to PvaClientPutData
class epicsShareClass PvaClientPutData : public PvaClientData
{
public:
    POINTER_DEFINITIONS(PvaClientPutData);
    ~PvaClientPutData() {}
    void putDouble(double value);
    void putString(std::string const & value);
    void putDoubleArray(epics::pvData::shared_vector<const double> const & value);
    void putStringArray(epics::pvData::shared_vector<const std::string> const & value);
    void putStringArray(std::vector<std::string> const & value);
     static PvaClientPutDataPtr create(epics::pvData::StructureConstPtr const & structure);
private:
    PvaClientPutData(epics::pvData::StructureConstPtr const &structure);
    void postPut(size_t fieldNumber);
    std::vector<epics::pvData::PostHandlerPtr> postHandler;
    friend class PvaClientPostHandlerPvt;
    friend class PvaClientPut;
    friend class PvaClientPutGet;
};
 
class epicsShareClass PvaClientMonitorData : public PvaClientData
{
public:
    POINTER_DEFINITIONS(PvaClientMonitorData);
    ~PvaClientMonitorData() {}
    epics::pvData::BitSetPtr getOverrunBitSet();
    std::ostream & showOverrun(std::ostream & out);
     void setData(epics::pvData::MonitorElementPtr const & monitorElement);
     static PvaClientMonitorDataPtr create(epics::pvData::StructureConstPtr const & structure);
private:
    PvaClientMonitorData(epics::pvData::StructureConstPtr const & structure);
    epics::pvData::BitSetPtr overrunBitSet;
 
    friend class PvaClientMonitor;
};
 
class epicsShareClass PvaClientProcessRequester
{
public:
    POINTER_DEFINITIONS(PvaClientProcessRequester);
    virtual ~PvaClientProcessRequester() {}
    virtual void channelProcessConnect(
        const epics::pvData::Status& status,
        PvaClientProcessPtr const & clientProcess)
    {
    }
    virtual void processDone(
        const epics::pvData::Status& status,
        PvaClientProcessPtr const & clientProcess) = 0;
};
 
// NOTE: must use separate class that implements ChannelProcessRequester,
// because pvAccess holds a shared_ptr to ChannelProcessRequester instead of weak_pointer
class ChannelProcessRequesterImpl;
typedef std::tr1::shared_ptr<ChannelProcessRequesterImpl> ChannelProcessRequesterImplPtr;
 
class epicsShareClass PvaClientProcess :
    public std::tr1::enable_shared_from_this<PvaClientProcess>
{
public:
    POINTER_DEFINITIONS(PvaClientProcess);
    static PvaClientProcessPtr create(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest
    );
 
    ~PvaClientProcess();
    void setRequester(PvaClientProcessRequesterPtr const & pvaClientProcessRequester);
    void connect();
    void issueConnect();
    epics::pvData::Status waitConnect();
    void process();
    void issueProcess();
    epics::pvData::Status waitProcess();
    PvaClientChannelPtr getPvaClientChannel();
private:
    std::string getRequesterName();
    void message(std::string const & message,epics::pvData::MessageType messageType);
    void channelProcessConnect(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelProcess::shared_pointer const & channelProcess);
    void processDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelProcess::shared_pointer const & channelProcess);
 
    PvaClientProcess(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest);
 
    void checkProcessState();
    enum ProcessConnectState {connectIdle,connectActive,connected};
 
    PvaClient::weak_pointer pvaClient;
    PvaClientChannelPtr pvaClientChannel;
    epics::pvData::PVStructurePtr pvRequest;
    epics::pvData::Mutex mutex;
    epics::pvData::Event waitForConnect;
    epics::pvData::Event waitForProcess;
 
    epics::pvData::Status channelProcessConnectStatus;
    epics::pvData::Status channelProcessStatus;
    epics::pvAccess::ChannelProcess::shared_pointer channelProcess;
 
    ProcessConnectState connectState;
 
    PvaClientProcessRequesterWPtr pvaClientProcessRequester;
    enum ProcessState {processIdle,processActive,processComplete};
    ProcessState processState;
    ChannelProcessRequesterImplPtr channelProcessRequester;
public:
    friend class ChannelProcessRequesterImpl;
};
 
// NOTE: must use separate class that implements ChannelGetRequester,
// because pvAccess holds a shared_ptr to ChannelGetRequester instead of weak_pointer
class ChannelGetRequesterImpl;
typedef std::tr1::shared_ptr<ChannelGetRequesterImpl> ChannelGetRequesterImplPtr;
 
class epicsShareClass PvaClientGetRequester
{
public:
    POINTER_DEFINITIONS(PvaClientGetRequester);
    virtual ~PvaClientGetRequester() {}
    virtual void channelGetConnect(
        const epics::pvData::Status& status,
        PvaClientGetPtr const & clientGet)
    {
    }
    virtual void getDone(
        const epics::pvData::Status& status,
        PvaClientGetPtr const & clientGet) = 0;
};
class epicsShareClass PvaClientGet :
    public std::tr1::enable_shared_from_this<PvaClientGet>
{
public:
    POINTER_DEFINITIONS(PvaClientGet);
    static PvaClientGetPtr create(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest
    );
 
    ~PvaClientGet();
    void setRequester(PvaClientGetRequesterPtr const & pvaClientGetRequester);
    void connect();
    void issueConnect();
    epics::pvData::Status waitConnect();
    void get();
    void issueGet();
    epics::pvData::Status waitGet();
    PvaClientGetDataPtr getData();
    PvaClientChannelPtr getPvaClientChannel();
private:
        std::string getRequesterName();
    void message(std::string const & message,epics::pvData::MessageType messageType);
    void channelGetConnect(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelGet::shared_pointer const & channelGet,
        epics::pvData::StructureConstPtr const & structure);
    void getDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelGet::shared_pointer const & channelGet,
        epics::pvData::PVStructurePtr const & pvStructure,
        epics::pvData::BitSetPtr const & bitSet);
 
    PvaClientGet(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest);
 
    void checkConnectState();
    enum GetConnectState {connectIdle,connectActive,connected};
 
    PvaClient::weak_pointer pvaClient;
    PvaClientChannelPtr pvaClientChannel;
    epics::pvData::PVStructurePtr pvRequest;
    epics::pvData::Mutex mutex;
    epics::pvData::Event waitForConnect;
    epics::pvData::Event waitForGet;
    PvaClientGetDataPtr pvaClientData;
 
    epics::pvData::Status channelGetConnectStatus;
    epics::pvData::Status channelGetStatus;
    epics::pvAccess::ChannelGet::shared_pointer channelGet;
 
    GetConnectState connectState;
 
    PvaClientGetRequesterWPtr pvaClientGetRequester;
 
    enum GetState {getIdle,getActive,getComplete};
    GetState getState;
    ChannelGetRequesterImplPtr channelGetRequester;
public:
    friend class ChannelGetRequesterImpl;
};
 
 
// NOTE: must use separate class that implements ChannelPutRequester,
// because pvAccess holds a shared_ptr to ChannelPutRequester instead of weak_pointer
class ChannelPutRequesterImpl;
typedef std::tr1::shared_ptr<ChannelPutRequesterImpl> ChannelPutRequesterImplPtr;
 
class epicsShareClass PvaClientPutRequester
{
public:
    POINTER_DEFINITIONS(PvaClientPutRequester);
    virtual ~PvaClientPutRequester() {}
    virtual void channelPutConnect(
        const epics::pvData::Status& status,
        PvaClientPutPtr const & clientPut)
     {
     }
    virtual void getDone(
        const epics::pvData::Status& status,
        PvaClientPutPtr const & clientPut)
    {
    }
    virtual void putDone(
        const epics::pvData::Status& status,
        PvaClientPutPtr const & clientPut) = 0;
};
 
class epicsShareClass PvaClientPut :
    public std::tr1::enable_shared_from_this<PvaClientPut>
{
public:
    POINTER_DEFINITIONS(PvaClientPut);
    static PvaClientPutPtr create(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest
    );
    ~PvaClientPut();
    void setRequester(PvaClientPutRequesterPtr const & pvaClientPutRequester);
    void connect();
    void issueConnect();
    epics::pvData::Status waitConnect();
    void get();
    void issueGet();
    epics::pvData::Status waitGet();
    void put();
    void issuePut();
    epics::pvData::Status waitPut();
    PvaClientPutDataPtr getData();
    PvaClientChannelPtr getPvaClientChannel();
private :
    std::string getRequesterName();
    void message(std::string const & message,epics::pvData::MessageType messageType);
    void channelPutConnect(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelPut::shared_pointer const & channelPut,
        epics::pvData::StructureConstPtr const & structure);
    void getDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelPut::shared_pointer const & channelPut,
        epics::pvData::PVStructurePtr const & pvStructure,
        epics::pvData::BitSetPtr const & bitSet);
    void putDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelPut::shared_pointer const & channelPut);
    PvaClientPut(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest);
 
    void checkConnectState();
    enum PutConnectState {connectIdle,connectActive,connected};
 
    PvaClient::weak_pointer pvaClient;
    PvaClientChannelPtr pvaClientChannel;
    epics::pvData::PVStructurePtr pvRequest;
    epics::pvData::Mutex mutex;
    epics::pvData::Event waitForConnect;
    epics::pvData::Event waitForGetPut;
    PvaClientPutDataPtr pvaClientData;
 
    epics::pvData::Status channelPutConnectStatus;
    epics::pvData::Status channelGetPutStatus;
    epics::pvAccess::ChannelPut::shared_pointer channelPut;
    PutConnectState connectState;
 
    enum PutState {putIdle,getActive,putActive,putComplete};
    PutState putState;
    ChannelPutRequesterImplPtr channelPutRequester;
    PvaClientPutRequesterWPtr pvaClientPutRequester;
public:
    friend class ChannelPutRequesterImpl;
};
 
// NOTE: must use separate class that implements ChannelPutGetRequester,
// because pvAccess holds a shared_ptr to ChannelPutGetRequester instead of weak_pointer
class ChannelPutGetRequesterImpl;
typedef std::tr1::shared_ptr<ChannelPutGetRequesterImpl> ChannelPutGetRequesterImplPtr;
 
class epicsShareClass PvaClientPutGetRequester
{
public:
    POINTER_DEFINITIONS(PvaClientPutGetRequester);
    virtual ~PvaClientPutGetRequester() {}
    virtual void channelPutGetConnect(
        const epics::pvData::Status& status,
        PvaClientPutGetPtr const & clientPutGet)
     {
     }
    virtual void putGetDone(
        const epics::pvData::Status& status,
        PvaClientPutGetPtr const & clientPutGet) = 0;
    virtual void getPutDone(
        const epics::pvData::Status& status,
        PvaClientPutGetPtr const & clientPutGet)
     {
     }
    virtual void getGetDone(
        const epics::pvData::Status& status,
        PvaClientPutGetPtr const & clientPutGet)
    {
    }
 
};
 
 
class epicsShareClass PvaClientPutGet :
    public std::tr1::enable_shared_from_this<PvaClientPutGet>
{
public:
    POINTER_DEFINITIONS(PvaClientPutGet);
    static PvaClientPutGetPtr create(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest
    );
    ~PvaClientPutGet();
    void setRequester(PvaClientPutGetRequesterPtr const & pvaClientPutGetRequester);
 
    void connect();
    void issueConnect();
    epics::pvData::Status waitConnect();
    void putGet();
    void issuePutGet();
    epics::pvData::Status waitPutGet();
    void getGet();
    void issueGetGet();
    epics::pvData::Status waitGetGet();
    void getPut();
    void issueGetPut();
    epics::pvData::Status waitGetPut();
    PvaClientPutDataPtr getPutData();
    PvaClientGetDataPtr getGetData();
    PvaClientChannelPtr getPvaClientChannel();
private :
    std::string getRequesterName();
    void message(std::string const & message,epics::pvData::MessageType messageType);
    void channelPutGetConnect(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::StructureConstPtr const & putStructure,
        epics::pvData::StructureConstPtr const & getStructure);
    void putGetDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::PVStructurePtr const & getPVStructure,
        epics::pvData::BitSetPtr const & getBitSet);
    void getPutDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::PVStructurePtr const & putPVStructure,
        epics::pvData::BitSet::shared_pointer const & putBitSet);
    void getGetDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::PVStructurePtr const & getPVStructure,
        epics::pvData::BitSet::shared_pointer const & getBitSet);
 
    PvaClientPutGet(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest);
    void checkPutGetState();
    enum PutGetConnectState {connectIdle,connectActive,connected};
 
    PvaClient::weak_pointer pvaClient;
    PvaClientChannelPtr pvaClientChannel;
    epics::pvData::PVStructurePtr pvRequest;
    epics::pvData::Mutex mutex;
    epics::pvData::Event waitForConnect;
    epics::pvData::Event waitForPutGet;
    PvaClientGetDataPtr pvaClientGetData;
    PvaClientPutDataPtr pvaClientPutData;
 
    epics::pvData::Status channelPutGetConnectStatus;
    epics::pvData::Status channelPutGetStatus;
    epics::pvAccess::ChannelPutGet::shared_pointer channelPutGet;
    PutGetConnectState connectState;
 
    enum PutGetState {putGetIdle,putGetActive,putGetComplete};
    PutGetState putGetState;
    ChannelPutGetRequesterImplPtr channelPutGetRequester;
    PvaClientPutGetRequesterWPtr pvaClientPutGetRequester;
public:
    friend class ChannelPutGetRequesterImpl;
};
 
class epicsShareClass PvaClientMonitorRequester
{
public:
    POINTER_DEFINITIONS(PvaClientMonitorRequester);
    virtual void monitorConnect(epics::pvData::Status const & status,
        PvaClientMonitorPtr const & monitor, epics::pvData::StructureConstPtr const & structure)
    {
    }
    virtual ~PvaClientMonitorRequester() {}
    virtual void event(PvaClientMonitorPtr const & monitor) = 0;
    virtual void unlisten()
    {
         std::cerr << "PvaClientMonitorRequester::unlisten called"
                 << " but no PvaClientMonitorRequester::unlisten\n";
    }
};
 
 
// NOTE: must use separate class that implements MonitorRequester,
// because pvAccess holds a shared_ptr to MonitorRequester instead of weak_pointer
class MonitorRequesterImpl;
typedef std::tr1::shared_ptr<MonitorRequesterImpl> MonitorRequesterImplPtr;
 
class epicsShareClass PvaClientMonitor :
    public PvaClientChannelStateChangeRequester,   // remove when deprecated create removed
    public PvaClientMonitorRequester,
    public std::tr1::enable_shared_from_this<PvaClientMonitor>
{
public:
    POINTER_DEFINITIONS(PvaClientMonitor);
    static PvaClientMonitorPtr create(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest
    );
    static PvaClientMonitorPtr create(
        PvaClientPtr const &pvaClient,
        std::string const & channelName,
        std::string const & providerName,
        std::string const & request,
        PvaClientChannelStateChangeRequesterPtr const & stateChangeRequester
            = PvaClientChannelStateChangeRequesterPtr(),
        PvaClientMonitorRequesterPtr const & monitorRequester
            = PvaClientMonitorRequesterPtr()
    ) EPICS_DEPRECATED;
    ~PvaClientMonitor();
    void connect();
    void issueConnect();
    epics::pvData::Status waitConnect();
    void setRequester(PvaClientMonitorRequesterPtr const & pvaClientMonitorRequester);
    void start();
   void start(const std::string & request);
    void stop();
    bool poll();
    bool waitEvent(double secondsToWait = 0.0);
    void releaseEvent();
    PvaClientChannelPtr getPvaClientChannel();
    PvaClientMonitorDataPtr getData();
private:
    std::string getRequesterName();
    void message(std::string const & message,epics::pvData::MessageType messageType);
    void monitorConnect(
        const epics::pvData::Status& status,
        epics::pvData::MonitorPtr const & monitor,
        epics::pvData::StructureConstPtr const & structure);
    void unlisten(epics::pvData::MonitorPtr const & monitor);
    void monitorEvent(epics::pvData::MonitorPtr const & monitor);
 
    PvaClientMonitor(
        PvaClientPtr const &pvaClient,
        PvaClientChannelPtr const & pvaClientChannel,
        epics::pvData::PVStructurePtr const &pvRequest);
 
    void checkMonitorState();
    enum MonitorConnectState {connectIdle,connectWait,connectActive,connected};
 
    PvaClient::weak_pointer pvaClient;
    PvaClientChannelPtr pvaClientChannel;
    epics::pvData::PVStructurePtr pvRequest;
    epics::pvData::Mutex mutex;
    epics::pvData::Event waitForConnect;
    epics::pvData::Event waitForEvent;
    PvaClientMonitorDataPtr pvaClientData;
 
    bool isStarted;
    epics::pvData::Status monitorConnectStatus;
    epics::pvData::MonitorPtr monitor;
    epics::pvData::MonitorElementPtr monitorElement;
 
    PvaClientMonitorRequesterWPtr pvaClientMonitorRequester;
    MonitorConnectState connectState;
    bool userPoll;
    bool userWait;
    MonitorRequesterImplPtr monitorRequester;
    PvaClientChannelStateChangeRequesterWPtr pvaClientChannelStateChangeRequester; //deprecate
public:
    void channelStateChange(PvaClientChannelPtr const & channel, bool isConnected); //deprecate
    void event(PvaClientMonitorPtr const & monitor);
    friend class MonitorRequesterImpl;
};
 
 
 
class PvaClientRPCRequester
{
public:
    POINTER_DEFINITIONS(PvaClientRPCRequester);
    virtual ~PvaClientRPCRequester() {}
    virtual void requestDone(
        const epics::pvData::Status& status,
        PvaClientRPCPtr const & pvaClientRPC,
        epics::pvData::PVStructure::shared_pointer const & pvResponse) = 0;
};
// NOTE: must use separate class that implements RPCRequester,
// because pvAccess holds a shared_ptr to RPCRequester instead of weak_pointer
class  RPCRequesterImpl;
typedef std::tr1::shared_ptr<RPCRequesterImpl> RPCRequesterImplPtr;
 
class epicsShareClass PvaClientRPC :
    public std::tr1::enable_shared_from_this<PvaClientRPC>
{
public:
    POINTER_DEFINITIONS(PvaClientRPC);
    static PvaClientRPCPtr create(
        PvaClientPtr const &pvaClient,
        epics::pvAccess::Channel::shared_pointer const & channel);
    static PvaClientRPCPtr create(
        PvaClientPtr const &pvaClient,
        epics::pvAccess::Channel::shared_pointer const & channel,
        epics::pvData::PVStructurePtr const &pvRequest
    );
    ~PvaClientRPC();
    void setResponseTimeout(double responseTimeout)
    {
        this->responseTimeout = responseTimeout;
    }
    double getResponseTimeout()
    {
        return responseTimeout;
    }
    void connect();
    void issueConnect();
    epics::pvData::Status waitConnect();
    epics::pvData::PVStructure::shared_pointer request(
        epics::pvData::PVStructure::shared_pointer const & pvArgument);
    void request(
        epics::pvData::PVStructure::shared_pointer const & pvArgument,
        PvaClientRPCRequesterPtr const & pvaClientRPCRequester);
private:
    PvaClientRPC(
        PvaClientPtr const &pvaClient,
        epics::pvAccess::Channel::shared_pointer const & channel,
        epics::pvData::PVStructurePtr const &pvRequest);
    std::string getRequesterName();
    void message(std::string const & message,epics::pvData::MessageType messageType);
    void rpcConnect(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelRPC::shared_pointer const & channelRPC);
    void requestDone(
        const epics::pvData::Status& status,
        epics::pvAccess::ChannelRPC::shared_pointer const & channelRPC,
        epics::pvData::PVStructure::shared_pointer const & pvResponse);
 
    void checkRPCState();
 
    enum RPCConnectState {connectIdle,connectActive,connected};
    epics::pvData::Status connectStatus;
    RPCConnectState connectState;
 
    PvaClient::weak_pointer pvaClient;
    epics::pvAccess::Channel::weak_pointer channel;
    epics::pvData::PVStructurePtr pvRequest;
 
    epics::pvData::Mutex mutex;
    epics::pvData::Event waitForConnect;
    epics::pvData::Event waitForDone;
 
    PvaClientRPCRequesterWPtr pvaClientRPCRequester;
    RPCRequesterImplPtr rpcRequester;
    epics::pvAccess::ChannelRPC::shared_pointer channelRPC;
    epics::pvData::PVStructurePtr pvResponse;
 
    enum RPCState {rpcIdle,rpcActive,rpcComplete};
    RPCState rpcState;
    epics::pvData::Status requestStatus;
    double responseTimeout;
    friend class RPCRequesterImpl;
};
 
}}
 
#endif  /* PVACLIENT_H */