CGlobalConfiguration.hpp

Go to the documentation of this file.

#ifndef CGLOBALCONFIGURATION_HPP
#define CGLOBALCONFIGURATION_HPP

#include <climits>
#include <string>
#include <vector>

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/asio/io_service.hpp>

namespace freedm {
namespace broker {

class CGlobalConfiguration : private boost::noncopyable
{
    public:
        static CGlobalConfiguration& Instance()
        {
            static CGlobalConfiguration instance;
            return instance;
        }
        void SetHostname(std::string h) { m_hostname = h; };
        void SetListenPort(std::string p) { m_port = p; };
        void SetUUID(std::string u) { m_uuid = u; };
        void SetListenAddress(std::string a) { m_address = a; };
        void SetClockSkew(boost::posix_time::time_duration t)
                { m_clockskew = t; };
        void SetFactoryPort(unsigned short port) { m_factory_port = port; }
        void SetDevicesEndpoint(std::string e) { m_devicesEndpoint = e; };
        void SetAdapterConfigPath(std::string ac) { m_adapterConfigPath = ac; };
        void SetDeviceConfigPath(std::string p) { m_deviceConfigPath = p; }
        void SetTopologyConfigPath(std::string p) { m_topologyConfigPath = p; }
        void SetMigrationStep(float v) { m_migrationStep = v; }
        void SetMaliciousFlag(bool flag) { m_malicious = flag; }
        void SetInvariantCheck(bool flag) { m_invariant = flag; }
        void SetMQTTId(std::string id) { m_mqtt_id = id; }
        void SetMQTTAddress(std::string address) { m_mqtt_address = address; }
        void SetMQTTSubscriptions(std::vector<std::string> subs) { m_mqtt_subscriptions = subs; }
        std::string GetHostname() const { return m_hostname; };
        std::string GetListenPort() const { return m_port; };
        std::string GetUUID() const { return m_uuid; };
        std::string GetListenAddress() const { return m_address; };
        boost::posix_time::time_duration GetClockSkew() const
                { return m_clockskew; };
        unsigned short GetFactoryPort() const { return m_factory_port; }
        std::string GetDevicesEndpoint() const { return m_devicesEndpoint; };
        std::string GetAdapterConfigPath() const { return m_adapterConfigPath; };
        std::string GetDeviceConfigPath() const { return m_deviceConfigPath; }
        static const short MAX_PACKET_SIZE = SHRT_MAX;
        std::string GetTopologyConfigPath() const { return m_topologyConfigPath; }
        float GetMigrationStep() const { return m_migrationStep; }
        bool GetMaliciousFlag() const { return m_malicious; }
        bool GetInvariantCheck() const { return m_invariant; }
        std::string GetMQTTId() const { return m_mqtt_id; }
        std::string GetMQTTAddress() const { return m_mqtt_address; }
        std::vector<std::string> GetMQTTSubscriptions() const { return m_mqtt_subscriptions; }
    private:
        std::string m_hostname; 
        std::string m_port; 
        std::string m_uuid; 
        std::string m_address; 
        boost::posix_time::time_duration m_clockskew; 
        unsigned short m_factory_port; 
        std::string m_devicesEndpoint; 
        std::string m_adapterConfigPath; 
        std::string m_deviceConfigPath; 
        std::string m_topologyConfigPath; 
        float m_migrationStep; 
        bool m_malicious; // Flag to indicate whether load balance is malicious
        bool m_invariant; // Flag that indicates whether to check the invariant
        std::string m_mqtt_id; 
        std::string m_mqtt_address; 
        std::vector<std::string> m_mqtt_subscriptions; 
};

} // namespace broker
} // namespace freedm

#endif