Configurable.h

/***************************************************************************
 * \file Configurable.h
 * \brief Defines the basic interface for an object configurable through
 *    dictionaries.
 * \author DA
 * \author NH
 * \author MN
 * \copyright (c) 2017 CyberRadio Solutions, Inc.  All rights reserved.
 *
 ***************************************************************************/
 
#ifndef INCLUDED_LIBCYBERRADIO_DRIVER_CONFIGURABLE_H
#define INCLUDED_LIBCYBERRADIO_DRIVER_CONFIGURABLE_H
 
#include "LibCyberRadio/Common/BasicDict.h"
#include "LibCyberRadio/Common/Debuggable.h"
#include "LibCyberRadio/Driver/ConfigString.h"
#include <string>
#include <ostream>
 

namespace LibCyberRadio
{
    namespace Driver
    {
        //typedef BASIC_DICT_CONTAINER<std::string, ConfigString> ConfigurationDict;
        class ConfigurationDict : public BASIC_DICT_CONTAINER<std::string, ConfigString>
        {
            public:
                ConfigurationDict();
                virtual ~ConfigurationDict();
                virtual std::string toString() const;
                virtual bool hasKey(const std::string& key) const;
 
        };

        class Configurable : public Debuggable
        {
            public:
                Configurable(const std::string& name = "<unknown>", bool debug = false);
                virtual ~Configurable();
                Configurable(const Configurable& other);
                virtual Configurable& operator=(const Configurable& other);
                virtual std::string getName() const;
                virtual void setName(const std::string &name);
                virtual ConfigurationDict getConfiguration() const;
                virtual ConfigString getConfigurationValue(const std::string& key) const;
                virtual bool getConfigurationValueAsBool(const std::string& key) const;
                virtual int getConfigurationValueAsInt(const std::string& key) const;
                virtual unsigned int getConfigurationValueAsUInt(const std::string& key) const;
                virtual double getConfigurationValueAsDbl(const std::string& key) const;
                virtual bool setConfiguration(ConfigurationDict& cfg);
                virtual bool setConfigurationValue(const std::string& key,
                        const std::string& value);
                virtual bool setConfigurationValueToBool(const std::string& key,
                        const bool value);
                virtual bool setConfigurationValueToInt(const std::string& key,
                        const int value);
                virtual bool setConfigurationValueToUInt(const std::string& key,
                        const unsigned int value);
                virtual bool setConfigurationValueToDbl(const std::string& key,
                        const double value);
                virtual void queryConfiguration();
 
            protected:
                virtual void initConfigurationDict();
                virtual void updateConfigurationDict();
                virtual ConfigurationDict normalizedConfigurationDict(
                        const ConfigurationDict& cfg);
                virtual std::string normalizedBool(const std::string& val);
                virtual void dumpConfiguration();
 
            protected:
                // Name of this configurable object
                std::string _name;
                // Configuration dictionary
                ConfigurationDict _config;
 
        }; // class Configurable
 
    } // namespace Driver
 
} // namespace LibCyberRadio

std::ostream& operator<<(std::ostream& os, const LibCyberRadio::Driver::ConfigurationDict& obj);
 
 
#endif // INCLUDED_LIBCYBERRADIO_DRIVER_CONFIGURABLE_H