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