configuration.h

#ifndef CONFIGURATION_H
#define CONFIGURATION_H

#include <string.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <map>
#include <set>

#ifdef epicsExportSharedSymbols
#   define configurationEpicsExportSharedSymbols
#   undef epicsExportSharedSymbols
#endif

#include <pv/pvType.h>
#include <pv/noDefaultMethods.h>
#include <pv/lock.h>
#include <pv/sharedPtr.h>

#include <envDefs.h>
#ifdef configurationEpicsExportSharedSymbols
#   define epicsExportSharedSymbols
#   undef configurationEpicsExportSharedSymbols
#endif

#include <shareLib.h>

union osiSockAddr; // defined in osiSock;

namespace epics {
namespace pvAccess {

class ConfigurationStack;

class epicsShareClass Configuration
{
    EPICS_NOT_COPYABLE(Configuration)
public:
    POINTER_DEFINITIONS(Configuration);

    Configuration() {}
    virtual ~Configuration() =0;
    bool getPropertyAsBoolean(const std::string &name, const bool defaultValue) const;
    epics::pvData::int32 getPropertyAsInteger(const std::string &name, const epics::pvData::int32 defaultValue) const;
    float getPropertyAsFloat(const std::string &name, const float defaultValue) const;
    double getPropertyAsDouble(const std::string &name, const double defaultValue) const;
    std::string getPropertyAsString(const std::string &name, const std::string &defaultValue) const;
    bool getPropertyAsAddress(const std::string& name, osiSockAddr* addr) const;

    bool hasProperty(const std::string &name) const;

    typedef std::set<std::string> keys_t;
    keys_t keys() const
    {
        keys_t ret;
        addKeys(ret);
        return ret;
    }

protected:
    friend class ConfigurationStack;
    virtual bool tryGetPropertyAsString(const std::string& name, std::string* val) const = 0;
    virtual void addKeys(keys_t&) const {}
};

class epicsShareClass ConfigurationMap: public Configuration
{
    EPICS_NOT_COPYABLE(ConfigurationMap)
public:
    typedef std::map<std::string, std::string> properties_t;
    properties_t properties;
    ConfigurationMap() {}
    ConfigurationMap(const properties_t& p) :properties(p) {}
    virtual ~ConfigurationMap() {}
private:
    virtual bool tryGetPropertyAsString(const std::string& name, std::string* val) const;
    virtual void addKeys(keys_t&) const;
};

class epicsShareClass ConfigurationEnviron: public Configuration
{
    EPICS_NOT_COPYABLE(ConfigurationEnviron)
public:
    ConfigurationEnviron() {}
    virtual ~ConfigurationEnviron() {}
private:
    virtual bool tryGetPropertyAsString(const std::string& name, std::string* val) const;
};

typedef ConfigurationEnviron SystemConfigurationImpl;

class epicsShareClass ConfigurationStack : public Configuration
{
    EPICS_NOT_COPYABLE(ConfigurationStack)
    typedef std::vector<std::tr1::shared_ptr<Configuration> > confs_t;
    confs_t confs;
    virtual bool tryGetPropertyAsString(const std::string& name, std::string* val) const;
    virtual void addKeys(keys_t&) const;
public:
    ConfigurationStack() {}
    virtual ~ConfigurationStack() {}
    inline void push_back(const confs_t::value_type& conf) {
        confs.push_back(conf);
    }
    inline confs_t::value_type pop_back() {
        if(confs.empty())
            throw std::runtime_error("Stack empty");
        confs_t::value_type ret(confs.back());
        confs.pop_back();
        return ret;
    }
    inline size_t size() const {
        return confs.size();
    }
};

struct epicsShareClass ConfigurationBuilder
{
    ConfigurationBuilder();
    ConfigurationBuilder& push_env();
    ConfigurationBuilder& push_map();
    ConfigurationBuilder& push_config(const Configuration::shared_pointer&);
    template<typename V>
    ConfigurationBuilder& add(const std::string& name, const V& val)
    {
        std::ostringstream strm;
        strm<<val;
        return _add(name, strm.str());
    }
    Configuration::shared_pointer build();
private:
    ConfigurationBuilder& _add(const std::string& name, const std::string& val);
    ConfigurationMap::properties_t mymap;
    std::tr1::shared_ptr<ConfigurationStack> stack;
    friend ConfigurationBuilder& operator<<(ConfigurationBuilder&, const std::string& s);
};

class epicsShareClass ConfigurationProvider
{
    EPICS_NOT_COPYABLE(ConfigurationProvider)
public:
    POINTER_DEFINITIONS(ConfigurationProvider);
    ConfigurationProvider() {}
    virtual ~ConfigurationProvider() {}
    virtual Configuration::shared_pointer getConfiguration(const std::string &name) = 0;
    virtual void registerConfiguration(const std::string &name, Configuration::shared_pointer const & configuration) = 0;
};

class ConfigurationProviderImpl: public ConfigurationProvider
{
    EPICS_NOT_COPYABLE(ConfigurationProviderImpl)
public:
    ConfigurationProviderImpl() {}
    virtual ~ConfigurationProviderImpl() {}
    Configuration::shared_pointer getConfiguration(const std::string &name);
    void registerConfiguration(const std::string &name, Configuration::shared_pointer const & configuration);
private:
    epics::pvData::Mutex _mutex;
    std::map<std::string,Configuration::shared_pointer> _configs;
};

class epicsShareClass ConfigurationFactory
{
    EPICS_NOT_COPYABLE(ConfigurationFactory)
public:
    POINTER_DEFINITIONS(ConfigurationFactory);

    static ConfigurationProvider::shared_pointer getProvider();
    static void registerConfiguration(const std::string &name, Configuration::shared_pointer const & configuration)
    {
        getProvider()->registerConfiguration(name, configuration);
    }
    static Configuration::shared_pointer getConfiguration(const std::string& name)
    {
        return getProvider()->getConfiguration(name);
    }

private:
    ConfigurationFactory() {};
};

}
}

#endif  /* CONFIGURATION_H */