server.h

/*
 * Copyright information and license terms for this software can be
 * found in the file LICENSE that is included with the distribution
 */
#ifndef PVA_SERVER_H
#define PVA_SERVER_H
 
#include <string>
#include <vector>
#include <map>
 
#include <shareLib.h>
#include <pv/sharedPtr.h>
#include <pv/sharedVector.h>
 
namespace epics{namespace pvAccess{
class ChannelProvider;
class Channel;
class ChannelRequester;
struct PeerInfo; // see pv/security.h
}} // epics::pvAccess

namespace pvas {


class epicsShareClass StaticProvider {
public:
    POINTER_DEFINITIONS(StaticProvider);
    struct Impl;
private:
    std::tr1::shared_ptr<Impl> impl; // const after ctor
public:

    struct epicsShareClass ChannelBuilder {
        POINTER_DEFINITIONS(ChannelBuilder);
        virtual ~ChannelBuilder();
        virtual std::tr1::shared_ptr<epics::pvAccess::Channel> connect(const std::tr1::shared_ptr<epics::pvAccess::ChannelProvider>& provider,
                                                                       const std::string& name,
                                                                       const std::tr1::shared_ptr<epics::pvAccess::ChannelRequester>& requester) =0;
        virtual void disconnect(bool destroy, const epics::pvAccess::ChannelProvider* provider) =0;
    };
private:
    typedef std::map<std::string, std::tr1::shared_ptr<ChannelBuilder> > builders_t;
public:
    typedef builders_t::const_iterator const_iterator;

    explicit StaticProvider(const std::string& name);
    ~StaticProvider();

    void close(bool destroy=false);

    void add(const std::string& name,
             const std::tr1::shared_ptr<ChannelBuilder>& builder);
    std::tr1::shared_ptr<ChannelBuilder> remove(const std::string& name);

    std::tr1::shared_ptr<epics::pvAccess::ChannelProvider> provider() const;
 
    // iterate through currently add()'d PVs.  Iteraters are invalidated by concurrent add() or remove()
    const_iterator begin() const;
    const_iterator end() const;
};

class epicsShareClass DynamicProvider {
public:
    POINTER_DEFINITIONS(DynamicProvider);
    struct Impl;
private:
    std::tr1::shared_ptr<Impl> impl; // const after ctor
public:
    class Search {
        friend struct Impl;
        bool isclaimed;
        std::string cname;
        const ::epics::pvAccess::PeerInfo* peerinfo;
        Search(const std::string& name, const ::epics::pvAccess::PeerInfo* peer)
            :isclaimed(false),cname(name),peerinfo(peer)
        {}
    public:
        const std::string& name() const { return cname; }
        bool claimed() const { return isclaimed; }
        void claim() { isclaimed = true; }
        const ::epics::pvAccess::PeerInfo* peer() const { return peerinfo; }
    };
    typedef std::vector<Search> search_type;

    struct epicsShareClass Handler {
        POINTER_DEFINITIONS(Handler);
        typedef epics::pvData::shared_vector<std::string> names_type;
        virtual ~Handler() {}
        virtual void hasChannels(search_type& name) =0;
        virtual void listChannels(names_type& names, bool& dynamic) {}
        virtual std::tr1::shared_ptr<epics::pvAccess::Channel> createChannel(const std::tr1::shared_ptr<epics::pvAccess::ChannelProvider>& provider,
                                                                             const std::string& name,
                                                                             const std::tr1::shared_ptr<epics::pvAccess::ChannelRequester>& requester) =0;
        virtual void destroy() {}
    };

    DynamicProvider(const std::string& name,
                    const std::tr1::shared_ptr<Handler>& handler);
    ~DynamicProvider();
 
    Handler::shared_pointer getHandler() const;
 
    //void close();

    std::tr1::shared_ptr<epics::pvAccess::ChannelProvider> provider() const;
};

 
} // namespace pvas
 
#endif // PVA_SERVER_H