ConfigTool.h

Go to the documentation of this file.

//***************************************************************************************
//***************************************************************************************
 
#pragma once
 
#include "NAGASH/Global.h"
#include "NAGASH/MSGTool.h"
 
namespace NAGASH
{
    class ConfigTool
    {
    public:
        ConfigTool() { msg = std::make_shared<MSGTool>(); };
        ConfigTool(const char *inputfilename);
        ConfigTool(const ConfigTool &c) = default;
        ConfigTool &operator=(const ConfigTool &c) = default;
        ConfigTool(ConfigTool &&c) = default;
        ConfigTool &operator=(ConfigTool &&c) = default;
 
        template <typename T>
        void BookPar(const TString &name, const T &value);
        template <class T>
        T GetPar(const TString &name, bool *doexist = nullptr) const;
        std::shared_ptr<MSGTool> MSGUser() const;
        void SetMSG(std::shared_ptr<MSGTool> MSG);
        void RemovePar(const TString &name);
 
    private:
        std::map<TString, std::any> ParMap;
        std::map<TString, std::any> ParMapFile;
        std::vector<TString> InputMD5Sum;
        mutable std::shared_ptr<MSGTool> msg = nullptr;
        template <typename T>
        void BookParFile(const TString &name, const T &value);
        void ReadConfigFromFile(const TString &filename);
        std::string Exec(std::string command);
    };
 
    inline std::shared_ptr<MSGTool> ConfigTool::MSGUser() const { return msg; }
 
    inline void ConfigTool::SetMSG(std::shared_ptr<MSGTool> MSG) { msg = MSG; }
 
    inline void ConfigTool::RemovePar(const TString &name)
    {
        ParMap.erase(name);
        ParMapFile.erase(name);
    }
 
    template <typename T>
    inline void ConfigTool::BookPar(const TString &name, const T &value)
    {
        static_assert(!std::is_pointer<T>::value, "class ConfigTool : Can not book parameter in pointer type");
        static_assert(std::is_default_constructible<T>::value, "class ConfigTool : Can not book parameter in not_default_constructible type");
 
        std::any temp = std::make_any<T>(value);
        if (ParMap.find(name) != ParMap.end())
        {
            MSGUser()->StartTitle("ConfigTool::BookPar");
            MSGUser()->MSG(MSGLevel::WARNING, "parameter ", name, " has already existed, will be overwritten");
            MSGUser()->EndTitle();
            ParMap[name] = temp;
        }
        else
        {
            ParMap.insert(std::pair<TString, std::any>(name, temp));
        }
    }
 
    template <typename T>
    inline void ConfigTool::BookParFile(const TString &name, const T &value)
    {
        static_assert(!std::is_pointer<T>::value, "class ConfigTool : Can not book parameter in pointer type");
        static_assert(std::is_default_constructible<T>::value, "class ConfigTool : Can not book parameter in not_default_constructible type");
 
        std::any temp = std::make_any<T>(value);
        if (ParMapFile.find(name) != ParMapFile.end())
        {
            MSGUser()->StartTitle("ConfigTool::BookPar");
            MSGUser()->MSG(MSGLevel::WARNING, "parameter ", name, " has already existed, will be overwritten");
            MSGUser()->EndTitle();
            ParMapFile[name] = temp;
        }
        else
        {
            ParMapFile.insert(std::pair<TString, std::any>(name, temp));
        }
    }
 
 
    template <class T>
    inline T ConfigTool::GetPar(const TString &name, bool *doexist) const
    {
        static_assert(std::is_default_constructible<T>::value, "class ConfigTool : Can not get parameter in no_default_constructible type");
        auto re = ParMap.find(name);
        auto reF = ParMapFile.find(name);
        if (reF != ParMapFile.end())
        {
            try
            {
                auto par = std::any_cast<T>(reF->second);
                if (doexist != nullptr)
                    *doexist = true;
                return par;
            }
            catch (const std::bad_any_cast &e)
            {
                MSGUser()->StartTitle("ConfigTool::GetPar");
                MSGUser()->MSG(MSGLevel::ERROR, "parameter ", name, " type is not the given type, will return null");
                MSGUser()->EndTitle();
                return T();
            }
        }
        else if (re != ParMap.end())
        {
            try
            {
                auto par = std::any_cast<T>(re->second);
                if (doexist != nullptr)
                    *doexist = true;
                return par;
            }
            catch (const std::bad_any_cast &e)
            {
                MSGUser()->StartTitle("ConfigTool::GetPar");
                MSGUser()->MSG(MSGLevel::ERROR, "parameter ", name, " type is not the given type, will return null");
                MSGUser()->EndTitle();
                return T();
            }
        }
        else
        {
            MSGUser()->StartTitle("ConfigTool::GetPar");
            MSGUser()->MSG(MSGLevel::ERROR, "parameter ", name, " does not exist, will return null");
            MSGUser()->EndTitle();
            if (doexist != nullptr)
                *doexist = false;
            return T();
        }
    };
 
} // namespace NAGASH