Environment.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/AppDomainSingleton.hxx"
#include "Arp/System/Core/Endianness.hpp"
#include <chrono>
#include <sstream>
#include <vector>
#include <set>
#include <map>

using namespace std::chrono;

namespace Arp { namespace System { namespace Commons
{

class Environment
{
public: // setup/dispose operations
    static void         Setup(void);
    static void         SetupSettings(int core);
    static void         SetupTrustStore(const std::vector<String>& trustStorePaths, const String& trustStoreEditPath);
    static void         SetupIdentityStore(const std::vector<String>& identityStorePaths, const String& identityStoreEditPath);
    static void         Dispose(void);

public: // static operations
    static int64        GetTickCount(void);
    static Endianness   GetEndianness(void);
    static String       GetVariable(const char* variableName);
    template<class T>
    static bool         GetVariableValue(const char* variableName, T& result);
    static bool         GetVariableValue(const char* variableName, String& value);
    template<class T>
    static bool         GetDefaultVariableValue(const char* variableName, T& result);
    static bool         GetDefaultVariableValue(const char* variableName, String& value);
    template<class T>
    static bool         AddVariable(const char* variableName, const T& value);
    static bool         AddVariable(const char* variableName, const String& value);
    template<class T>
    static bool         AddOverriddenVariable(const char* variableName, const T& value);
    static bool         AddOverriddenVariable(const char* variableName, const String& value);
    static bool         SetVariable(const char* variableName, const String& value);

private: // static methods
    static void         RegisterEnvironmentVariables(void);
    static bool         RegisterEnvironmentVariable(const String& name, const char* value);


private: // nested class EnvData
    class Data : public AppDomainSingleton<Data>
    {
        friend class Environment;

    public: // typedefs
        using VariableNames = std::set<String>; // <name>
        using EnvironmentVariables = std::map<String, String>; // <name, value>

    public: // Constructors
        Data(void) = default;
        ~Data(void) = default;

    public: // operations
        bool    AddDefaultVariable(const char* variableName, const String& value);
        bool    AddOverriddenVariable(const char* variableName, const String& value);
        bool    SetDefaultVariable(const char* variableName, const String& value);
        bool    SetOverriddenVariable(const char* variableName, const String& value);
        bool    GetCurrentVariableValue(const char* variableName, const char*& pResult)const;
        bool    GetDefaultVariableValue(const char* variableName, const char*& pResult)const;
        bool    GetOverriddenVariableValue(const char* variableName, const char*& pResult)const;

    private: // methods
        void    GetVariableNames(VariableNames& result);

    private: // static methods
        static bool GetVariableValueFrom(const EnvironmentVariables& items, const char* variableName, const char*& pResult);

    private: //fields
        EnvironmentVariables    environmentVariables;
        EnvironmentVariables    overriddenVariables;
    };
};

// inline methods of class Environment
inline int64 Environment::GetTickCount()
{
    return duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
}

inline Endianness Environment::GetEndianness(void)
{
    return Endianness::Current;
}

template<class T>
inline bool Environment::GetVariableValue(const char* variableName, T& result)
{
    String value;
    if (!GetVariableValue(variableName, value))
    {
        return false;
    }
    // else
    std::istringstream iss(value.CStr());
    iss >> boolalpha >> result;
    return !iss.fail();
}

inline String Environment::GetVariable(const char* variableName)
{
    String result;
    if (GetVariableValue(variableName, result))
    {
        return result;
    }
    // else
    return String::Empty;
}

template<class T>
inline bool Environment::GetDefaultVariableValue(const char* variableName, T& result)
{
    String value;
    if (!GetDefaultVariableValue(variableName, value))
    {
        return false;
    }
    // else
    std::istringstream iss(value.CStr());
    iss >> boolalpha >> result;
    return !iss.fail();
}

template<class T>
inline bool Environment::AddVariable(const char* variableName, const T& value)
{
    std::stringstream ss;
    ss << boolalpha << value;
    return Environment::AddVariable(variableName, String(ss.str()));
}

inline bool Environment::AddVariable(const char* variableName, const String& value)
{
    return Data::GetInstance().AddDefaultVariable(variableName, value);
}

template<class T>
inline bool Environment::AddOverriddenVariable(const char* variableName, const T& value)
{
    std::stringstream ss;
    ss << boolalpha << value;
    return Environment::AddOverriddenVariable(variableName, String(ss.str()));
}

inline bool Environment::AddOverriddenVariable(const char* variableName, const String& value)
{
    return Data::GetInstance().AddOverriddenVariable(variableName, value);
}

// inline methods of class Environment::Data
inline bool Environment::Data::GetCurrentVariableValue(const char* variableName, const char*& pResult)const
{
    // try to get value from overrides
    if (GetOverriddenVariableValue(variableName, pResult))
    {
        return true;
    }
    // else try to get default value
    return GetDefaultVariableValue(variableName, pResult);
}

inline bool Environment::Data::GetDefaultVariableValue(const char* variableName, const char*& pResult)const
{
    return GetVariableValueFrom(this->environmentVariables, variableName, pResult);
}

inline bool Environment::Data::GetOverriddenVariableValue(const char* variableName, const char*& pResult)const
{
    return GetVariableValueFrom(this->overriddenVariables, variableName, pResult);
}

}}} // end of namespace Arp::System::Commons