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>
 
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 : 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);
        void    LogVariables(void);
 
    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 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch()).count();
}
 
inline Endianness Environment::GetEndianness(void)
{
    return Endianness::Current;
}
 
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();
}
 
inline String Environment::GetVariable(const char* variableName)
{
    String result;
    if (GetVariableValue(variableName, result))
    {
        return result;
    }
    // else
    return String::Empty;
}
 
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()));
}
 
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 << std::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