pvAccess.h

 
#ifndef PVACCESS_H
#define PVACCESS_H
 
#include <vector>
#include <set>
 
#ifdef epicsExportSharedSymbols
#   define pvAccessEpicsExportSharedSymbols
#   undef epicsExportSharedSymbols
#endif
 
#include <pv/pvData.h>
#include <pv/createRequest.h>
#include <pv/status.h>
#include <pv/bitSet.h>
 
#ifdef pvAccessEpicsExportSharedSymbols
#   define epicsExportSharedSymbols
#       undef pvAccessEpicsExportSharedSymbols
#endif
 
#include <pv/pvaVersion.h>
#include <pv/destroyable.h>
#include <pv/monitor.h>
 
#include <shareLib.h>
 
/* C++11 keywords
 @code
 struct Base {
   virtual void foo();
 };
 struct Class : public Base {
   virtual void foo() OVERRIDE FINAL;
 };
 @endcode
 */
#ifndef FINAL
#  if __cplusplus>=201103L
#    define FINAL final
#  else
#    define FINAL
#  endif
#endif
#ifndef OVERRIDE
#  if __cplusplus>=201103L
#    define OVERRIDE override
#  else
#    define OVERRIDE
#  endif
#endif
 
namespace epics {
namespace pvAccess {
class Configuration;
 
using epics::pvData::Requester;
using epics::pvData::RequesterPtr;
using epics::pvData::MessageType;
using epics::pvData::getMessageTypeName;
 
// TODO add write-only?
// change names
enum AccessRights {
    none,
    read,
    readWrite
};
 
 
class epicsShareClass Lockable
{
public:
    POINTER_DEFINITIONS(Lockable);
 
    virtual ~Lockable() {}
 
    virtual void lock() {}
    virtual void unlock() {}
};
 
class epicsShareClass ScopedLock {
    EPICS_NOT_COPYABLE(ScopedLock)
public:
 
    explicit ScopedLock(Lockable::shared_pointer const & li)
        : lockable(li), locked(true) {
        lockable->lock();
    }
 
    ~ScopedLock() {
        unlock();
    }
 
    void lock() {
        if(!locked) {
            lockable->lock();
            locked = true;
        }
    }
 
    void unlock() {
        if(locked) {
            lockable->unlock();
            locked=false;
        }
    }
 
    bool ownsLock() const {
        return locked;
    }
 
private:
 
    Lockable::shared_pointer const lockable;
    bool locked;
};
 
class Channel;
class ChannelProvider;
class ChannelArrayRequester;
class ChannelFindRequester;
class ChannelGetRequester;
class ChannelProcessRequester;
class ChannelPutRequester;
class ChannelPutGetRequester;
class ChannelRPCRequester;
 
struct epicsShareClass NetStats {
    struct Counter {
        size_t tx, rx;
 
        inline Counter() :tx(0u), rx(0u) {}
    };
    struct Stats {
        std::string transportPeer;
        Counter transportBytes;
        Counter operationBytes;
        bool populated;
 
        inline Stats() :populated(false) {}
    };
 
    virtual ~NetStats();
    virtual void stats(Stats& s) const =0;
};
 
struct epicsShareClass ChannelBaseRequester : virtual public epics::pvData::Requester
{
    POINTER_DEFINITIONS(ChannelBaseRequester);
 
    static size_t num_instances;
 
    ChannelBaseRequester();
    virtual ~ChannelBaseRequester();
 
    virtual void channelDisconnect(bool destroy) {}
 
private:
    ChannelBaseRequester(const ChannelBaseRequester&);
    ChannelBaseRequester& operator=(const ChannelBaseRequester&);
};
 
class epicsShareClass ChannelRequest : public virtual Destroyable, public Lockable {
public:
    POINTER_DEFINITIONS(ChannelRequest);
 
    static size_t num_instances;
 
    ChannelRequest();
    virtual ~ChannelRequest();
 
    virtual std::tr1::shared_ptr<Channel> getChannel() = 0;
 
    virtual void cancel() = 0;
 
    virtual void lastRequest() = 0;
 
private:
    EPICS_NOT_COPYABLE(ChannelRequest)
};
 
class epicsShareClass MonitorRequester : public ChannelBaseRequester {
    public:
    POINTER_DEFINITIONS(MonitorRequester);
    typedef Monitor operation_type;
 
    virtual ~MonitorRequester(){}
    virtual void monitorConnect(epics::pvData::Status const & status,
        MonitorPtr const & monitor, epics::pvData::StructureConstPtr const & structure) = 0;
    virtual void monitorEvent(MonitorPtr const & monitor) = 0;
    virtual void unlisten(MonitorPtr const & monitor) = 0;
};
 
class epicsShareClass ChannelArray : public ChannelRequest {
public:
    POINTER_DEFINITIONS(ChannelArray);
    typedef ChannelArrayRequester requester_type;
 
    virtual ~ChannelArray() {}
 
    virtual void putArray(
        epics::pvData::PVArray::shared_pointer const & putArray,
        size_t offset = 0, size_t count = 0, size_t stride = 1) = 0;
 
    virtual void getArray(size_t offset = 0, size_t count = 0, size_t stride = 1) = 0;
 
    virtual void getLength() = 0;
 
    virtual void setLength(size_t length) = 0;
};
 
class epicsShareClass ChannelArrayRequester : public ChannelBaseRequester {
public:
    POINTER_DEFINITIONS(ChannelArrayRequester);
    typedef ChannelArray operation_type;
 
    virtual ~ChannelArrayRequester() {}
 
    virtual void channelArrayConnect(
        const epics::pvData::Status& status,
        ChannelArray::shared_pointer const & channelArray,
        epics::pvData::Array::const_shared_pointer const & array) = 0;
 
    virtual void putArrayDone(
        const epics::pvData::Status& status,
        ChannelArray::shared_pointer const & channelArray) = 0;
 
    virtual void getArrayDone(
        const epics::pvData::Status& status,
        ChannelArray::shared_pointer const & channelArray,
        epics::pvData::PVArray::shared_pointer const & pvArray) = 0;
 
    virtual void getLengthDone(
        const epics::pvData::Status& status,
        ChannelArray::shared_pointer const & channelArray,
        size_t length) = 0;
 
    virtual void setLengthDone(
        const epics::pvData::Status& status,
        ChannelArray::shared_pointer const & channelArray) = 0;
};
 
 
class epicsShareClass ChannelFind : public Destroyable {
    EPICS_NOT_COPYABLE(ChannelFind)
public:
    POINTER_DEFINITIONS(ChannelFind);
    typedef ChannelFindRequester requester_type;
 
    ChannelFind() {}
    virtual ~ChannelFind() {}
 
    virtual std::tr1::shared_ptr<ChannelProvider> getChannelProvider() = 0;
    virtual void cancel() = 0;
 
    static ChannelFind::shared_pointer buildDummy(const std::tr1::shared_ptr<ChannelProvider>& provider);
};
 
struct PeerInfo; // see pv/security.h
 
class epicsShareClass ChannelFindRequester {
public:
    POINTER_DEFINITIONS(ChannelFindRequester);
    typedef ChannelFind operation_type;
 
    virtual ~ChannelFindRequester() {}
 
    virtual void channelFindResult(
        const epics::pvData::Status& status,
        ChannelFind::shared_pointer const & channelFind,
        bool wasFound) = 0;
 
    virtual std::tr1::shared_ptr<const PeerInfo> getPeerInfo()
    { return std::tr1::shared_ptr<const PeerInfo>(); }
};
 
class epicsShareClass ChannelListRequester {
public:
    POINTER_DEFINITIONS(ChannelListRequester);
    typedef ChannelFind operation_type;
 
    virtual ~ChannelListRequester() {}
 
    virtual void channelListResult(
        const epics::pvData::Status& status,
        ChannelFind::shared_pointer const & channelFind,
        epics::pvData::PVStringArray::const_svector const & channelNames,
        bool hasDynamic) = 0;
};
 
class epicsShareClass ChannelGet : public ChannelRequest {
public:
    POINTER_DEFINITIONS(ChannelGet);
    typedef ChannelGetRequester requester_type;
 
    virtual ~ChannelGet() {}
 
    virtual void get() = 0;
};
 
 
class epicsShareClass ChannelGetRequester : public ChannelBaseRequester {
public:
    POINTER_DEFINITIONS(ChannelGetRequester);
    typedef ChannelGet operation_type;
 
    virtual ~ChannelGetRequester() {}
 
    virtual void channelGetConnect(
        const epics::pvData::Status& status,
        ChannelGet::shared_pointer const & channelGet,
        epics::pvData::Structure::const_shared_pointer const & structure) = 0;
 
    virtual void getDone(
        const epics::pvData::Status& status,
        ChannelGet::shared_pointer const & channelGet,
        epics::pvData::PVStructure::shared_pointer const & pvStructure,
        epics::pvData::BitSet::shared_pointer const & bitSet) = 0;
};
 
 
class epicsShareClass ChannelProcess : public ChannelRequest {
public:
    POINTER_DEFINITIONS(ChannelProcess);
    typedef ChannelProcessRequester requester_type;
 
    virtual ~ChannelProcess() {}
 
    virtual void process() = 0;
};
 
 
class epicsShareClass ChannelProcessRequester : public ChannelBaseRequester {
public:
    POINTER_DEFINITIONS(ChannelProcessRequester);
    typedef ChannelProcess operation_type;
 
    virtual ~ChannelProcessRequester() {}
 
    virtual void channelProcessConnect(
        const epics::pvData::Status& status,
        ChannelProcess::shared_pointer const & channelProcess) = 0;
 
    virtual void processDone(
        const epics::pvData::Status& status,
        ChannelProcess::shared_pointer const & channelProcess) = 0;
};
 
 
class epicsShareClass ChannelPut : public ChannelRequest {
public:
    POINTER_DEFINITIONS(ChannelPut);
    typedef ChannelPutRequester requester_type;
 
    virtual ~ChannelPut() {}
 
    virtual void put(
        epics::pvData::PVStructure::shared_pointer const & pvPutStructure,
        epics::pvData::BitSet::shared_pointer const & putBitSet) = 0;
 
    virtual void get() = 0;
 
};
 
class epicsShareClass ChannelPutRequester : public ChannelBaseRequester {
public:
    POINTER_DEFINITIONS(ChannelPutRequester);
    typedef ChannelPut operation_type;
 
    virtual ~ChannelPutRequester() {}
 
    virtual void channelPutConnect(
        const epics::pvData::Status& status,
        ChannelPut::shared_pointer const & channelPut,
        epics::pvData::Structure::const_shared_pointer const & structure) = 0;
 
    virtual void putDone(
        const epics::pvData::Status& status,
        ChannelPut::shared_pointer const & channelPut) = 0;
 
    virtual void getDone(
        const epics::pvData::Status& status,
        ChannelPut::shared_pointer const & channelPut,
        epics::pvData::PVStructure::shared_pointer const & pvStructure,
        epics::pvData::BitSet::shared_pointer const & bitSet) = 0;
};
 
 
class epicsShareClass ChannelPutGet : public ChannelRequest {
public:
    POINTER_DEFINITIONS(ChannelPutGet);
    typedef ChannelPutGetRequester requester_type;
 
    virtual ~ChannelPutGet() {}
 
    virtual void putGet(
        epics::pvData::PVStructure::shared_pointer const & pvPutStructure,
        epics::pvData::BitSet::shared_pointer const & putBitSet) = 0;
 
    virtual void getPut() = 0;
 
    virtual void getGet() = 0;
};
 
 
class epicsShareClass ChannelPutGetRequester : public ChannelBaseRequester
{
public:
    POINTER_DEFINITIONS(ChannelPutGetRequester);
    typedef ChannelPutGet operation_type;
 
    virtual ~ChannelPutGetRequester() {}
 
    virtual void channelPutGetConnect(
        const epics::pvData::Status& status,
        ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::Structure::const_shared_pointer const & putStructure,
        epics::pvData::Structure::const_shared_pointer const & getStructure) = 0;
 
    virtual void putGetDone(
        const epics::pvData::Status& status,
        ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::PVStructure::shared_pointer const & pvGetStructure,
        epics::pvData::BitSet::shared_pointer const & getBitSet) = 0;
 
    virtual void getPutDone(
        const epics::pvData::Status& status,
        ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::PVStructure::shared_pointer const & pvPutStructure,
        epics::pvData::BitSet::shared_pointer const & putBitSet) = 0;
 
    virtual void getGetDone(
        const epics::pvData::Status& status,
        ChannelPutGet::shared_pointer const & channelPutGet,
        epics::pvData::PVStructure::shared_pointer const & pvGetStructure,
        epics::pvData::BitSet::shared_pointer const & getBitSet) = 0;
};
 
 
class epicsShareClass ChannelRPC : public ChannelRequest {
public:
    POINTER_DEFINITIONS(ChannelRPC);
    typedef ChannelRPCRequester requester_type;
 
    virtual ~ChannelRPC() {}
 
    virtual void request(epics::pvData::PVStructure::shared_pointer const & pvArgument) = 0;
};
 
 
class epicsShareClass ChannelRPCRequester : public ChannelBaseRequester {
public:
    POINTER_DEFINITIONS(ChannelRPCRequester);
    typedef ChannelRPC operation_type;
 
    virtual ~ChannelRPCRequester() {}
 
    virtual void channelRPCConnect(
        const epics::pvData::Status& status,
        ChannelRPC::shared_pointer const & operation) = 0;
 
    virtual void requestDone(
        const epics::pvData::Status& status,
        ChannelRPC::shared_pointer const & operation,
        epics::pvData::PVStructure::shared_pointer const & pvResponse) = 0;
};
 
 
class epicsShareClass GetFieldRequester : public ChannelBaseRequester {
public:
    POINTER_DEFINITIONS(GetFieldRequester);
 
    virtual ~GetFieldRequester() {}
 
    virtual void getDone(
        const epics::pvData::Status& status,
        epics::pvData::FieldConstPtr const & field) = 0;     // TODO naming convention
 
};
 
class ChannelRequester;
 
class epicsShareClass Channel :
    public Requester,
    public Destroyable
{
    EPICS_NOT_COPYABLE(Channel)
public:
    POINTER_DEFINITIONS(Channel);
    typedef ChannelRequester requester_type;
 
    static size_t num_instances;
 
    Channel();
    virtual ~Channel();
 
    virtual std::string getRequesterName();
    virtual void message(std::string const & message, epics::pvData::MessageType messageType);
 
    enum ConnectionState {
        NEVER_CONNECTED, CONNECTED, DISCONNECTED, DESTROYED
    };
 
    static const char* ConnectionStateNames[];
 
    virtual std::tr1::shared_ptr<ChannelProvider> getProvider() = 0;
 
    virtual std::string getRemoteAddress() = 0;
 
    virtual ConnectionState getConnectionState();
 
    virtual std::string getChannelName() = 0;
 
    virtual std::tr1::shared_ptr<ChannelRequester> getChannelRequester() = 0;
 
    virtual bool isConnected();
 
    virtual void getField(GetFieldRequester::shared_pointer const & requester,std::string const & subField);
 
    virtual AccessRights getAccessRights(epics::pvData::PVField::shared_pointer const & pvField);
 
    virtual ChannelProcess::shared_pointer createChannelProcess(
        ChannelProcessRequester::shared_pointer const & requester,
        epics::pvData::PVStructure::shared_pointer const & pvRequest);
 
    virtual ChannelGet::shared_pointer createChannelGet(
        ChannelGetRequester::shared_pointer const & requester,
        epics::pvData::PVStructure::shared_pointer const & pvRequest);
 
    virtual ChannelPut::shared_pointer createChannelPut(
        ChannelPutRequester::shared_pointer const & requester,
        epics::pvData::PVStructure::shared_pointer const & pvRequest);
 
    virtual ChannelPutGet::shared_pointer createChannelPutGet(
        ChannelPutGetRequester::shared_pointer const & requester,
        epics::pvData::PVStructure::shared_pointer const & pvRequest);
 
    virtual ChannelRPC::shared_pointer createChannelRPC(
        ChannelRPCRequester::shared_pointer const & requester,
        epics::pvData::PVStructure::shared_pointer const & pvRequest);
 
    virtual Monitor::shared_pointer createMonitor(
        MonitorRequester::shared_pointer const & requester,
        epics::pvData::PVStructure::shared_pointer const & pvRequest);
 
    virtual ChannelArray::shared_pointer createChannelArray(
        ChannelArrayRequester::shared_pointer const & requester,
        epics::pvData::PVStructure::shared_pointer const & pvRequest);
 
    virtual void printInfo() { printInfo(std::cout); }
 
    virtual void printInfo(std::ostream& out) {}
};
 
 
class epicsShareClass ChannelRequester : public virtual Requester
{
    ChannelRequester(const ChannelRequester&);
    ChannelRequester& operator=(const ChannelRequester&);
public:
    POINTER_DEFINITIONS(ChannelRequester);
    typedef Channel operation_type;
 
    static size_t num_instances;
 
    ChannelRequester();
    virtual ~ChannelRequester();
 
    virtual void channelCreated(const epics::pvData::Status& status, Channel::shared_pointer const & channel) = 0;
 
    virtual void channelStateChange(Channel::shared_pointer const & channel, Channel::ConnectionState connectionState) = 0;
 
    virtual std::tr1::shared_ptr<const PeerInfo> getPeerInfo();
};
 
struct epicsShareClass DefaultChannelRequester : public ChannelRequester
{
    virtual ~DefaultChannelRequester() {}
    virtual std::string getRequesterName() OVERRIDE FINAL;
    virtual void channelCreated(const epics::pvData::Status& status, Channel::shared_pointer const & channel) OVERRIDE FINAL;
    virtual void channelStateChange(Channel::shared_pointer const & channel, Channel::ConnectionState connectionState) OVERRIDE FINAL;
    static ChannelRequester::shared_pointer build();
};
 
enum FlushStrategy {
    IMMEDIATE, DELAYED, USER_CONTROLED
};
 
class epicsShareClass ChannelProvider : public Destroyable
{
    EPICS_NOT_COPYABLE(ChannelProvider)
public:
    POINTER_DEFINITIONS(ChannelProvider);
 
    static const short PRIORITY_MIN = 0;
    static const short PRIORITY_MAX = 99;
    static const short PRIORITY_DEFAULT = PRIORITY_MIN;
    static const short PRIORITY_LINKS_DB = PRIORITY_MAX;
    static const short PRIORITY_ARCHIVE = (PRIORITY_MAX + PRIORITY_MIN) / 2;
    static const short PRIORITY_OPI = PRIORITY_MIN;
 
    static size_t num_instances;
 
    ChannelProvider();
    virtual ~ChannelProvider();
 
    virtual std::string getProviderName() = 0;
 
    virtual ChannelFind::shared_pointer channelFind(std::string const & name,
            ChannelFindRequester::shared_pointer const & requester) = 0;
 
    virtual ChannelFind::shared_pointer channelList(ChannelListRequester::shared_pointer const & requester);
 
    virtual Channel::shared_pointer createChannel(std::string const & name,
                                                  ChannelRequester::shared_pointer const & requester = DefaultChannelRequester::build(),
                                                  short priority = PRIORITY_DEFAULT);
 
    virtual Channel::shared_pointer createChannel(std::string const & name,ChannelRequester::shared_pointer const & requester,
            short priority, std::string const & address) = 0;
};
 
class epicsShareClass ChannelProviderFactory {
    EPICS_NOT_COPYABLE(ChannelProviderFactory)
public:
    POINTER_DEFINITIONS(ChannelProviderFactory);
 
    ChannelProviderFactory() {}
    virtual ~ChannelProviderFactory() {}
 
    virtual std::string getFactoryName() = 0;
 
    virtual ChannelProvider::shared_pointer sharedInstance() = 0;
 
    virtual ChannelProvider::shared_pointer newInstance() {
        return newInstance(std::tr1::shared_ptr<Configuration>());
    }
 
    virtual ChannelProvider::shared_pointer newInstance(const std::tr1::shared_ptr<Configuration>&) {
        throw std::logic_error("This ChannelProviderFactory does not support non-default configurations");
    }
};
 
template<class Provider>
struct SimpleChannelProviderFactory : public ChannelProviderFactory
{
    SimpleChannelProviderFactory(const std::string& name) :pname(name) {}
    virtual ~SimpleChannelProviderFactory() {}
 
    virtual std::string getFactoryName() OVERRIDE FINAL { return pname; }
 
    virtual ChannelProvider::shared_pointer sharedInstance() OVERRIDE FINAL
    {
        epics::pvData::Lock L(sharedM);
        ChannelProvider::shared_pointer ret(shared.lock());
        if(!ret) {
            std::tr1::shared_ptr<Provider> inst(new Provider(std::tr1::shared_ptr<Configuration>()));
            shared = ret = inst;
        }
        return ret;
    }
 
    virtual ChannelProvider::shared_pointer newInstance(const std::tr1::shared_ptr<Configuration>& conf) OVERRIDE FINAL
    {
        std::tr1::shared_ptr<Provider> ret(new Provider(conf));
        return ret;
    }
 
private:
    const std::string pname;
    epics::pvData::Mutex sharedM;
    ChannelProvider::weak_pointer shared;
};
 
template<class Provider>
struct SingletonChannelProviderFactory : public ChannelProviderFactory
{
    SingletonChannelProviderFactory(const std::string& name,
                                    const std::tr1::shared_ptr<const Configuration>& conf = std::tr1::shared_ptr<const Configuration>())
        :pname(name), config(conf)
    {}
    virtual ~SingletonChannelProviderFactory() {}
 
    virtual std::string getFactoryName() OVERRIDE FINAL { return pname; }
 
    virtual ChannelProvider::shared_pointer sharedInstance() OVERRIDE FINAL
    {
        epics::pvData::Lock L(sharedM);
        ChannelProvider::shared_pointer ret(shared.lock());
        if(!ret) {
            std::tr1::shared_ptr<Provider> inst(new Provider(config));
            shared = ret = inst;
        }
        return ret;
    }
 
    virtual ChannelProvider::shared_pointer newInstance(const std::tr1::shared_ptr<Configuration>& conf) OVERRIDE FINAL
    {
        (void)conf; // ignore and use our Configuration
        return sharedInstance();
    }
private:
    const std::string pname;
    epics::pvData::Mutex sharedM;
    ChannelProvider::weak_pointer shared;
    const std::tr1::shared_ptr<const Configuration> config;
};
 
class epicsShareClass ChannelProviderRegistry {
public:
    POINTER_DEFINITIONS(ChannelProviderRegistry);
 
    typedef std::vector<std::string> stringVector_t;
 
    virtual ~ChannelProviderRegistry() {}
 
 
    static ChannelProviderRegistry::shared_pointer build();
    static ChannelProviderRegistry::shared_pointer clients();
    static ChannelProviderRegistry::shared_pointer servers();
 
    ChannelProvider::shared_pointer getProvider(std::string const & providerName);
 
    ChannelProvider::shared_pointer createProvider(std::string const & providerName,
                                                           const std::tr1::shared_ptr<Configuration>& conf = std::tr1::shared_ptr<Configuration>());
 
    virtual ChannelProviderFactory::shared_pointer getFactory(std::string const & providerName);
 
    typedef std::set<std::string> provider_name_set;
    virtual void getProviderNames(provider_name_set& names);
 
    virtual bool add(const ChannelProviderFactory::shared_pointer& fact, bool replace=true);
 
    template<class Provider>
    ChannelProviderFactory::shared_pointer add(const std::string& name, bool replace=true)
    {
        typedef SimpleChannelProviderFactory<Provider> Factory;
        typename Factory::shared_pointer fact(new Factory(name));
        return add(fact, replace) ? fact : typename Factory::shared_pointer();
    }
 
    typedef ChannelProvider::shared_pointer (*factoryfn_t)(const std::tr1::shared_ptr<Configuration>&);
 
    ChannelProviderFactory::shared_pointer add(const std::string& name, factoryfn_t, bool replace=true);
 
    template<class Provider>
    ChannelProviderFactory::shared_pointer addSingleton(const std::string& name,
                                                        const std::tr1::shared_ptr<const Configuration>& conf = std::tr1::shared_ptr<const Configuration>(),
                                                        bool replace=true)
    {
        typedef SingletonChannelProviderFactory<Provider> Factory;
        typename Factory::shared_pointer fact(new Factory(name, conf));
        return add(fact, replace) ? fact : typename Factory::shared_pointer();
    }
 
    ChannelProviderFactory::shared_pointer addSingleton(const ChannelProvider::shared_pointer& provider,
                                                        bool replace=true);
 
    ChannelProviderFactory::shared_pointer remove(const std::string& name);
 
    virtual bool remove(const ChannelProviderFactory::shared_pointer& factory);
 
    virtual void clear();
 
private:
    // ctor is hidden to ensure explict compile errors from a hypothetical sub-class
    // we no longer support sub-classing by outside code
    ChannelProviderRegistry() {}
    friend struct CompatRegistry;
 
    epics::pvData::Mutex mutex;
    typedef std::map<std::string, ChannelProviderFactory::shared_pointer> providers_t;
    providers_t providers;
};
 
/* Deprecated in favor of either ChannelProviderRegistry::clients() or ChannelProviderRegistry::servers()
 *
 * These functions have been removed as a signal that the shared_ptr ownership symantics of ChannelProvider
 * and friends has changed.
 */
#if __GNUC__>4 || (__GNUC__==4&&__GNUC_MINOR__>=3)
 
#define gCPRMSG __attribute__((error("ChannelProvider shared_ptr ownership rules have changed.")))
 
epicsShareFunc ChannelProviderRegistry::shared_pointer getChannelProviderRegistry() gCPRMSG;
// Shorthand for getChannelProviderRegistry()->add(channelProviderFactory);
epicsShareFunc void registerChannelProviderFactory(ChannelProviderFactory::shared_pointer const & channelProviderFactory) gCPRMSG;
// Shorthand for getChannelProviderRegistry()->remove(channelProviderFactory);
epicsShareFunc void unregisterChannelProviderFactory(ChannelProviderFactory::shared_pointer const & channelProviderFactory) gCPRMSG;
// Shorthand for getChannelProviderRegistry()->clear();
epicsShareFunc void unregisterAllChannelProviderFactory() gCPRMSG;
 
#undef gCPRMSG
 
#endif // __GNUC__
 
typedef Monitor PipelineMonitor;
 
 
}
}
 
// compatibility
namespace epics { namespace pvData {
using epics::pvAccess::MonitorRequester;
}}
 
 
#endif  /* PVACCESS_H */