get_config.h

Namespaces

Name
libtextworker::get_config
libtextworker

Classes

	Name
class	libtextworker::get_config::JSONException
class	libtextworker::get_config::GetConfig

Types

	Name
enum	JSONErrorCodes { UNMATCHED_TYPE, UNKNOWN_SECTION, UNKNOWN_OPTION}

Functions

	Name
void	JSONAssert(bool condition, const char * file, const char * section, const char * option, JSONErrorCodes errorCode) Throws a JSONException if the condition is false.

Attributes

	Name
const Json::Value	nullValue

Types Documentation

enum JSONErrorCodes

Enumerator	Value	Description
UNMATCHED_TYPE
UNKNOWN_SECTION
UNKNOWN_OPTION

Functions Documentation

function JSONAssert

void JSONAssert(
    bool condition,
    const char * file,
    const char * section,
    const char * option,
    JSONErrorCodes errorCode
)

Throws a JSONException if the condition is false.

Attributes Documentation

variable nullValue

static const Json::Value nullValue = Json::Value(Json::nullValue);

Source code

#pragma once

#include <json/json.h>
#include <libtextworker/general.h>
#include <format>

namespace libtextworker
{
    namespace get_config
    {
        static const Json::Value nullValue = Json::Value(Json::nullValue);
        
        enum JSONErrorCodes
        {
            UNKNOWN_SECTION,
            UNKNOWN_OPTION,
            UNMATCHED_TYPE
        };

        class JSONException : public std::exception
        {
        public:
            JSONException(
                const char* file, const char* section,
                const char* option, JSONErrorCodes errorCode
            )
            {
                _file = file;
                _section = section;
                _option = option;
                _error_code = errorCode;
            }

            const char* _file; const char* _section; const char* _option;
            JSONErrorCodes _error_code;

            const char* what() const noexcept override
            {
                const char* errorCode =
                    _error_code == JSONErrorCodes::UNKNOWN_SECTION ? "unknown section" :
                    _error_code == JSONErrorCodes::UNKNOWN_OPTION ? "unknown option" :
                    _error_code == JSONErrorCodes::UNMATCHED_TYPE ? "unmatched type" : "unknown error";

                return std::format(
                    "Error reading {}, [{} -> {}]: {}",
                    _file, _section, _option, errorCode
                ).c_str();
            }
        };

        void JSONAssert(
            bool condition, const char* file, const char* section,
            const char* option, JSONErrorCodes errorCode);

        class GetConfig
        {
        protected:
            const char* _file;
            Json::Value JSONreader;

            Json::Value OEMSettings;

        public:
            std::vector<const char*> true_values = {"yes", "True", "1", "on"};

            std::vector<const char*> false_values = {"no", "False", "0", "off"};

            std::map<Json::Value, Json::Value> aliases;

            Json::Value backups;

            GetConfig();

            GetConfig(Json::Value& OEMconfig, const char* targetFile);

            void Create(Json::Value& OEMconfig, const char* targetFile);

            Json::Value& operator[](const char* arg) {
                return JSONreader[arg];
            };

            Json::Value& operator[](std::string& arg) {
                return JSONreader[arg];
            };

            void Reset(bool restore = false);

            Json::Value& Backup(Json::Value& keys, bool directly_to_keys = false);

            void Restore(Json::Value keys);

            void WriteBack(const char* path);

            void WriteBack();

            Json::Value Get(
                const char* section, const char* option, const Json::Value& defaultValue = nullValue,
                bool silent = false, bool defaultsFromOEM = false);

            void Set(const char* section, const char* option, Json::Value value);
            
            void Alias(const char* from, Json::Value to);

            void AliasYesNo(const char* yesValue, const char* noValue);

            void Move(std::map<const char*, std::map<const char*, const char*>> dictionary);

            void SetAndUpdate(const char* section, const char* option, Json::Value value)
            {
                this->Set(section, option, value);
                this->WriteBack();
            };
        };
    }
}

---

Updated on 2025-03-30 at 22:24:10 +0700