sharedstate.h

/*
 * Copyright information and license terms for this software can be
 * found in the file LICENSE that is included with the distribution
 */
#ifndef PV_SHAREDSTATE_H
#define PV_SHAREDSTATE_H
 
#include <string>
#include <list>
 
#include <shareLib.h>
#include <pv/sharedPtr.h>
#include <pv/noDefaultMethods.h>
#include <pv/bitSet.h>
#include <pv/createRequest.h>
 
#include <pva/server.h>
 
namespace epics{namespace pvData{
class Structure;
class PVStructure;
class BitSet;
class Status;
}} // epics::pvData
namespace epics{namespace pvAccess{
class ChannelProvider;
class Channel;
class ChannelRequester;
struct ChannelBaseRequester;
class GetFieldRequester;
void providerRegInit(void*);
}} // epics::pvAccess
 
namespace pvas {
 
namespace detail {
struct SharedChannel;
struct SharedMonitorFIFO;
struct SharedPut;
struct SharedRPC;
}
 
struct Operation;
 
class epicsShareClass SharedPV
        : public pvas::StaticProvider::ChannelBuilder
{
    friend struct detail::SharedChannel;
    friend struct detail::SharedMonitorFIFO;
    friend struct detail::SharedPut;
    friend struct detail::SharedRPC;
public:
    POINTER_DEFINITIONS(SharedPV);
    struct epicsShareClass Config {
        bool dropEmptyUpdates; 
        epics::pvData::PVRequestMapper::mode_t mapperMode; 
        Config();
    };
 
    struct epicsShareClass Handler {
        POINTER_DEFINITIONS(Handler);
        virtual ~Handler();
        virtual void onFirstConnect(const SharedPV::shared_pointer& pv) {}
        virtual void onLastDisconnect(const SharedPV::shared_pointer& pv) {}
        virtual void onPut(const SharedPV::shared_pointer& pv, Operation& op);
        virtual void onRPC(const SharedPV::shared_pointer& pv, Operation& op);
    };
 
    static shared_pointer build(const std::tr1::shared_ptr<Handler>& handler, Config* conf=0);
    static shared_pointer buildReadOnly(Config* conf=0);
    static shared_pointer buildMailbox(Config* conf=0);
private:
    explicit SharedPV(const std::tr1::shared_ptr<Handler>& handler, Config* conf);
public:
    virtual ~SharedPV();
 
    void setHandler(const std::tr1::shared_ptr<Handler>& handler);
    Handler::shared_pointer getHandler() const;
 
    bool isOpen() const;
 
    void open(const epics::pvData::PVStructure& value);
 
    void open(const epics::pvData::PVStructure& value, const epics::pvData::BitSet& valid);
 
    void open(const epics::pvData::StructureConstPtr& type);
 
    inline void close(bool destroy=false) { realClose(destroy, true, 0); }
 
    std::tr1::shared_ptr<epics::pvData::PVStructure> build();
 
    void post(const epics::pvData::PVStructure& value,
              const epics::pvData::BitSet& changed);
 
    void fetch(epics::pvData::PVStructure& value, epics::pvData::BitSet& valid);
 
    virtual std::tr1::shared_ptr<epics::pvAccess::Channel> connect(
            const std::tr1::shared_ptr<epics::pvAccess::ChannelProvider>& provider,
            const std::string& channelName,
            const std::tr1::shared_ptr<epics::pvAccess::ChannelRequester>& requester) OVERRIDE FINAL;
 
    virtual void disconnect(bool destroy, const epics::pvAccess::ChannelProvider* provider) OVERRIDE FINAL;
 
    void setDebug(int lvl);
    int isDebug() const;
 
private:
    void realClose(bool destroy, bool close, const epics::pvAccess::ChannelProvider* provider);
 
    friend void epics::pvAccess::providerRegInit(void*);
    static size_t num_instances;
 
    weak_pointer internal_self; // const after build()
 
    const Config config;
 
    mutable epicsMutex mutex;
 
    std::tr1::shared_ptr<SharedPV::Handler> handler;
 
    typedef std::list<detail::SharedPut*> puts_t;
    typedef std::list<detail::SharedRPC*> rpcs_t;
    typedef std::list<detail::SharedMonitorFIFO*> monitors_t;
    typedef std::list<std::tr1::weak_ptr<epics::pvAccess::GetFieldRequester> > getfields_t;
    typedef std::list<detail::SharedChannel*> channels_t;
 
    std::tr1::shared_ptr<const epics::pvData::Structure> type;
 
    puts_t puts;
    rpcs_t rpcs;
    monitors_t monitors;
    getfields_t getfields;
    channels_t channels;
 
    std::tr1::shared_ptr<epics::pvData::PVStructure> current;
    epics::pvData::BitSet valid;
 
    // whether onFirstConnect() has been, or is being, called.
    // Set when the first getField, Put, or Monitor (but not RPC) is created.
    // Cleared when the last Channel is destroyed.
    bool notifiedConn;
 
    int debugLvl;
 
    EPICS_NOT_COPYABLE(SharedPV)
};
 
struct epicsShareClass Operation {
    POINTER_DEFINITIONS(Operation);
    struct Impl;
private:
    std::tr1::shared_ptr<Impl> impl;
 
    friend struct detail::SharedPut;
    friend struct detail::SharedRPC;
    explicit Operation(const std::tr1::shared_ptr<Impl> impl);
public:
    Operation() {} 
 
    const epics::pvData::PVStructure& pvRequest() const;
    const epics::pvData::PVStructure& value() const; 
    const epics::pvData::BitSet& changed() const;
    std::string channelName() const;
 
    const epics::pvAccess::PeerInfo* peer() const;
 
    void complete(); 
    void complete(const epics::pvData::Status& sts);
    void complete(const epics::pvData::PVStructure& value,
                  const epics::pvData::BitSet& changed);
 
    void info(const std::string&);
    void warn(const std::string&);
 
    int isDebug() const;
 
    // escape hatch.  never NULL
    std::tr1::shared_ptr<epics::pvAccess::Channel> getChannel();
    // escape hatch.  may be NULL
    std::tr1::shared_ptr<epics::pvAccess::ChannelBaseRequester> getRequester();
 
    bool valid() const;
 
#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
};
 
} // namespace pvas
 
 
#endif // PV_SHAREDSTATE_H