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 */