Environment.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Endianness.hpp"
#include <chrono>
#include <sstream>
#include <vector>
#include <set>
#include <map>
 
namespace Arp { namespace System { namespace Commons
{
 
class Environment
{
public: // Properties
    static const char*  ArpBinaryDirVariableName;
 
public: // setup/dispose operations
    static void         Setup(void);
    static void         SetupSettings(int core);
    static void         SetupSecuritySettings(const String& securitySettingsPath);
    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);
    static void         LogVariables(void);
    static void         RegisterEnvironmentVariables(void);
 
private: // static methods
    static bool         RegisterEnvironmentVariable(const String& name, const char* value);
 
private: // nested class EnvData
    class Data
    {
        friend class Environment;
 
    public: // usings
        using Instance = Data;
        using InstancePtr = std::unique_ptr<Instance>;
        using VariableNames = std::set<String>; // <name>
        using EnvironmentVariables = std::map<String, String>; // <name, value>
 
    public: // Constructors
        Data(void) = default;
 
    public: // static singleton operations
        static Instance&    CreateInstance(void);
        static bool         IsCreated(void);
        static void         DisposeInstance(void);
        static Instance&    GetInstance(void);
 
    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);
        void    LogVariables(void);
 
    private: // static methods
        static bool GetVariableValueFrom(const EnvironmentVariables& items, const char* variableName, const char*& pResult);
 
    private: //fields
        EnvironmentVariables    environmentVariables;
        EnvironmentVariables    overriddenVariables;
 
    private: // static fields
        static InstancePtr instancePtr;
    };
};
 
// inline methods of class Environment
 
template<>
inline bool Environment::GetVariableValue<String>(const char* variableName, String& result)
{
    return GetVariableValue(variableName, result);
}
 
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 >> std::boolalpha >> result;
    return !iss.fail();
}
 
template<>
inline bool Environment::GetDefaultVariableValue<String>(const char* variableName, String& result)
{
    return GetDefaultVariableValue(variableName, result);
}
 
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 >> std::boolalpha >> result;
    return !iss.fail();
}
 
template<class T>
inline bool Environment::AddVariable(const char* variableName, const T& value)
{
    std::stringstream ss;
    ss << std::boolalpha << value;
    return Environment::AddVariable(variableName, String(ss.str()));
}
 
template<class T>
inline bool Environment::AddOverriddenVariable(const char* variableName, const T& value)
{
    std::stringstream ss;
    ss << std::boolalpha << value;
    return Environment::AddOverriddenVariable(variableName, String(ss.str()));
}
 
}}} // end of namespace Arp::System::Commons