client.h

/*
 * Copyright information and license terms for this software can be
 * found in the file LICENSE that is included with the distribution
 */
#ifndef PVATESTCLIENT_H
#define PVATESTCLIENT_H
 
#include <ostream>
#include <stdexcept>
#include <list>
 
#include <epicsMutex.h>
 
#include <pv/pvData.h>
#include <pv/bitSet.h>
 
class epicsEvent;
 
namespace epics {namespace pvAccess {
class ChannelProvider;
class Channel;
class Monitor;
class Configuration;
}}//namespace epics::pvAccess
 
namespace pvac {
 
class ClientProvider;
 
struct epicsShareClass Operation
{
    struct Impl
    {
        virtual ~Impl() {}
        virtual std::string name() const =0;
        virtual void cancel() =0;
        virtual void show(std::ostream&) const =0;
    };
 
    Operation() {}
    Operation(const std::tr1::shared_ptr<Impl>&);
    ~Operation();
    std::string name() const;
    void cancel();
 
    bool valid() const { return !!impl; }
 
#if __cplusplus>=201103L
    explicit operator bool() const { return valid(); }
#else
private:
    typedef bool (Operation::*bool_type)() const;
public:
    operator bool_type() const { return valid() ? &Operation::valid : 0; }
#endif
 
    void reset() { impl.reset(); }
 
protected:
    friend epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const Operation& op);
    std::tr1::shared_ptr<Impl> impl;
};
 
struct epicsShareClass PutEvent
{
    enum event_t {
        Fail,    
        Cancel,  
        Success, 
    } event;
    std::string message; 
};
 
struct epicsShareClass GetEvent : public PutEvent
{
    epics::pvData::PVStructure::const_shared_pointer value;
    epics::pvData::BitSet::const_shared_pointer valid;
};
 
struct epicsShareClass InfoEvent : public PutEvent
{
    epics::pvData::FieldConstPtr type;
};
 
struct MonitorSync;
 
struct epicsShareClass Monitor
{
    struct Impl;
    Monitor() {}
    Monitor(const std::tr1::shared_ptr<Impl>&);
    ~Monitor();
 
    std::string name() const;
 
    void cancel();
    bool poll();
    bool complete() const;
    epics::pvData::PVStructure::const_shared_pointer root;
    epics::pvData::BitSet changed,
                          overrun;
 
    bool valid() const { return !!impl; }
 
#if __cplusplus>=201103L
    explicit operator bool() const { return valid(); }
#else
private:
    typedef bool (Monitor::*bool_type)() const;
public:
    operator bool_type() const { return valid() ? &Monitor::valid : 0; }
#endif
 
    void reset() { impl.reset(); }
 
private:
    std::tr1::shared_ptr<Impl> impl;
    friend epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const Monitor& op);
    friend struct MonitorSync;
};
 
struct MonitorEvent
{
    enum event_t {
        Fail=1,      
        Cancel=2,    
        Disconnect=4,
        Data=8,      
    } event;
    std::string message; 
};
 
struct epicsShareClass MonitorSync : public Monitor
{
    struct SImpl;
    MonitorSync() {}
    MonitorSync(const Monitor&, const std::tr1::shared_ptr<SImpl>&);
    ~MonitorSync();
 
    bool wait();
    bool wait(double timeout);
    bool test();
 
    void wake();
 
    MonitorEvent event;
private:
    std::tr1::shared_ptr<SImpl> simpl;
};
 
struct ConnectEvent
{
    bool connected;
    std::string peerName;
};
 
struct Timeout : public std::runtime_error
{
    Timeout();
};
 
namespace detail {
class PutBuilder;
void registerRefTrack();
}
 
class epicsShareClass ClientChannel
{
#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 305)
public:
    // Impl is public only as a workaround on older GCC
#endif
    struct Impl;
private:
    std::tr1::shared_ptr<Impl> impl;
    friend class ClientProvider;
    friend void detail::registerRefTrack();
    friend epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const ClientChannel& op);
 
    ClientChannel(const std::tr1::shared_ptr<Impl>& i) :impl(i) {}
public:
    struct epicsShareClass Options {
        short priority;
        std::string address;
        Options();
        bool operator<(const Options&) const;
    };
 
    ClientChannel() {}
    ClientChannel(const std::tr1::shared_ptr<epics::pvAccess::ChannelProvider>& provider,
                      const std::string& name,
                      const Options& opt = Options());
    ~ClientChannel();
 
    std::string name() const;
 
    bool valid() const { return !!impl; }
 
#if __cplusplus>=201103L
    explicit operator bool() const { return valid(); }
#else
private:
    typedef bool (ClientChannel::*bool_type)() const;
public:
    operator bool_type() const { return valid() ? &ClientChannel::valid : 0; }
#endif
 
    void reset() { impl.reset(); }
 
    struct GetCallback {
        virtual ~GetCallback() {}
        virtual void getDone(const GetEvent& evt)=0;
    };
 
    Operation get(GetCallback* cb,
                      epics::pvData::PVStructure::const_shared_pointer pvRequest = epics::pvData::PVStructure::const_shared_pointer());
 
    epics::pvData::PVStructure::const_shared_pointer
    get(double timeout = 3.0,
        epics::pvData::PVStructure::const_shared_pointer pvRequest = epics::pvData::PVStructure::const_shared_pointer());
 
 
    Operation rpc(GetCallback* cb,
                      const epics::pvData::PVStructure::const_shared_pointer& arguments,
                      epics::pvData::PVStructure::const_shared_pointer pvRequest = epics::pvData::PVStructure::const_shared_pointer());
 
    epics::pvData::PVStructure::const_shared_pointer
    rpc(double timeout,
        const epics::pvData::PVStructure::const_shared_pointer& arguments,
        epics::pvData::PVStructure::const_shared_pointer pvRequest = epics::pvData::PVStructure::const_shared_pointer());
 
    struct PutCallback {
        virtual ~PutCallback() {}
        struct Args {
            Args(epics::pvData::BitSet& tosend, epics::pvData::BitSet& previousmask) :tosend(tosend), previousmask(previousmask) {}
            epics::pvData::PVStructure::const_shared_pointer root;
            epics::pvData::BitSet& tosend;
            epics::pvData::PVStructure::const_shared_pointer previous;
            const epics::pvData::BitSet& previousmask;
        };
        virtual void putBuild(const epics::pvData::StructureConstPtr& build, Args& args) =0;
        virtual void putDone(const PutEvent& evt)=0;
    };
 
    Operation put(PutCallback* cb,
                  epics::pvData::PVStructure::const_shared_pointer pvRequest = epics::pvData::PVStructure::const_shared_pointer(),
                  bool getprevious = false);
 
    inline
    detail::PutBuilder put(const epics::pvData::PVStructure::const_shared_pointer &pvRequest = epics::pvData::PVStructure::const_shared_pointer());
 
    struct MonitorCallback {
        virtual ~MonitorCallback() {}
        virtual void monitorEvent(const MonitorEvent& evt)=0;
    };
 
    Monitor monitor(MonitorCallback *cb,
                          epics::pvData::PVStructure::const_shared_pointer pvRequest = epics::pvData::PVStructure::const_shared_pointer());
 
    MonitorSync monitor(const epics::pvData::PVStructure::const_shared_pointer& pvRequest = epics::pvData::PVStructure::const_shared_pointer(),
                        epicsEvent *event =0);
 
    struct InfoCallback {
        virtual ~InfoCallback() {}
        virtual void infoDone(const InfoEvent& evt) =0;
    };
 
    Operation info(InfoCallback *cb, const std::string& subfld = std::string());
 
    epics::pvData::FieldConstPtr info(double timeout = 3.0,
                                      const std::string& subfld = std::string());
 
    struct ConnectCallback {
        virtual ~ConnectCallback() {}
        virtual void connectEvent(const ConnectEvent& evt)=0;
    };
    void addConnectListener(ConnectCallback*);
    void removeConnectListener(ConnectCallback*);
 
    void show(std::ostream& strm) const;
private:
    std::tr1::shared_ptr<epics::pvAccess::Channel> getChannel();
};
 
namespace detail {
 
class epicsShareClass PutBuilder {
    ClientChannel& channel;
    epics::pvData::PVStructure::const_shared_pointer request;
 
    template<typename V>
    struct triple {
        std::string name;
        bool required;
        V value;
        triple(const std::string& name, const V& value, bool required =true)
            :name(name), required(required), value(value)
        {}
    };
 
    typedef std::list<triple<epics::pvData::AnyScalar> > scalars_t;
    scalars_t scalars;
 
    typedef std::list<triple<epics::pvData::shared_vector<const void> > > arrays_t;
    arrays_t arrays;
 
    struct Exec;
 
    friend class pvac::ClientChannel;
    PutBuilder(ClientChannel& channel, const epics::pvData::PVStructure::const_shared_pointer& request)
        :channel(channel), request(request)
    {}
public:
    PutBuilder& set(const std::string& name, const epics::pvData::AnyScalar& value, bool required=true) {
        scalars.push_back(scalars_t::value_type(name, value, required));
        return *this;
    }
    template<typename T>
    PutBuilder& set(const std::string& name, T value, bool required=true) {
        return set(name, epics::pvData::AnyScalar(value), required);
    }
    PutBuilder& set(const std::string& name, const epics::pvData::shared_vector<const void>& value, bool required=true) {
        arrays.push_back(arrays_t::value_type(name, value, required));
        return *this;
    }
    template<typename T>
    PutBuilder& set(const std::string& name, const epics::pvData::shared_vector<const T>& value, bool required=true) {
        return set(name, epics::pvData::static_shared_vector_cast<const void>(value), required);
    }
    void exec(double timeout=3.0);
};
 
 
}// namespace detail
 
class epicsShareClass ClientProvider
{
    struct Impl;
    std::tr1::shared_ptr<Impl> impl;
    friend void detail::registerRefTrack();
    friend epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const ClientProvider& op);
public:
 
    ClientProvider() {}
    ClientProvider(const std::string& providerName,
                   const std::tr1::shared_ptr<epics::pvAccess::Configuration>& conf = std::tr1::shared_ptr<epics::pvAccess::Configuration>());
    explicit ClientProvider(const std::tr1::shared_ptr<epics::pvAccess::ChannelProvider>& provider);
    ~ClientProvider();
 
    std::string name() const;
 
    ClientChannel connect(const std::string& name,
                          const ClientChannel::Options& conf = ClientChannel::Options());
 
    bool disconnect(const std::string& name,
                    const ClientChannel::Options& conf = ClientChannel::Options());
 
    void disconnect();
 
    bool valid() const { return !!impl; }
 
#if __cplusplus>=201103L
    explicit operator bool() const { return valid(); }
#else
private:
    typedef bool (ClientProvider::*bool_type)() const;
public:
    operator bool_type() const { return valid() ? &ClientProvider::valid : 0; }
#endif
 
    void reset() { impl.reset(); }
};
 
 
 
detail::PutBuilder
ClientChannel::put(const epics::pvData::PVStructure::const_shared_pointer& pvRequest)
{
    return detail::PutBuilder(*this, pvRequest);
}
 
epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const Operation& op);
epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const Monitor& op);
epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const ClientChannel& op);
epicsShareFunc ::std::ostream& operator<<(::std::ostream& strm, const ClientProvider& op);
 
 
}//namespace pvac
 
#endif // PVATESTCLIENT_H