Sophiar2/src/utility/config_utility.hpp

#ifndef SOPHIAR2_CONFIG_UTILITY_HPP
#define SOPHIAR2_CONFIG_UTILITY_HPP

#include "core/global_defs.h"
#include "core/sophiar_pool.h"

#include <nlohmann/json.hpp>

#define ENSURE_ARRAY(item_name) \
    assert(config.contains(item_name)); \
    assert(config[item_name].is_array());

#define ENSURE_STRING(item_name) \
    assert(config.contains(item_name)); \
    assert(config[item_name].is_string());

#define ENSURE_STRING2(config, item_name) \
    assert(config.contains(item_name)); \
    assert(config[item_name].is_string());

inline auto LOAD_BOOL_ITEM2(const nlohmann::json &config,
                            const std::string &item_name) {
    assert(config.contains(item_name));
    assert(config[item_name].is_boolean());
    return config[item_name].get<bool>();
}

#define LOAD_BOOL_ITEM(item_name) \
    LOAD_BOOL_ITEM2(config, item_name)

inline auto LOAD_FLOAT_ITEM2(const nlohmann::json &config,
                             const std::string &item_name) {
    assert(config.contains(item_name));
    assert(config[item_name].is_boolean());
    return config[item_name].get<double>();
}

#define LOAD_FLOAT_ITEM(item_name) \
    LOAD_FLOAT_ITEM2(config, item_name)

inline auto LOAD_UINT_ITEM2(const nlohmann::json &config,
                            const std::string &item_name) {
    assert(config.contains(item_name));
    assert(config[item_name].is_boolean());
    return config[item_name].get<uint64_t>();
}

#define LOAD_UINT_ITEM(item_name) \
    LOAD_UINT_ITEM2(config, item_name)

inline auto LOAD_STRING_ITEM2(const nlohmann::json &config,
                              const std::string &item_name) {
    ENSURE_STRING2(config, item_name) \
    return config[item_name].get<std::string>();
}

#define LOAD_STRING_ITEM(item_name) \
    LOAD_STRING_ITEM2(config, item_name)

template<typename SmallObjType>
inline auto LOAD_VARIABLE_INDEX2_IMPL(const nlohmann::json &config,
                                      const std::string &var_name) {
    auto name = LOAD_STRING_ITEM2(config, var_name);
    using namespace sophiar;
    return REQUIRE_VARIABLE(SmallObjType, name);
}

#define LOAD_VARIABLE_INDEX2(config, var_type, var_name) \
    LOAD_VARIABLE_INDEX2_IMPL<var_type>(config, var_name)

#define LOAD_VARIABLE_INDEX(var_type, var_name) \
    LOAD_VARIABLE_INDEX2(config ,var_type, var_name)

inline auto TRY_LOAD_BOOL_ITEM2(const nlohmann::json &config,
                                const std::string &var_name, bool default_val) {
    if (config.contains(var_name)) {
        assert(config[var_name].is_number());
        return config[var_name].get<bool>();
    } else {
        return default_val;
    }
}

#define TRY_LOAD_BOOL_ITEM(var_name, default_val) \
    TRY_LOAD_BOOL_ITEM2(config, var_name, default_val)

inline auto TRY_LOAD_FLOAT_ITEM2(const nlohmann::json &config,
                                 const std::string &var_name, double default_val) {
    if (config.contains(var_name)) {
        assert(config[var_name].is_number());
        return config[var_name].get<double>();
    } else {
        return default_val;
    }
}

#define TRY_LOAD_FLOAT_ITEM(var_name, default_val) \
    TRY_LOAD_FLOAT_ITEM2(config, var_name, default_val)

template<typename SmallObjType>
inline sophiar::variable_index_type
TRY_LOAD_VARIABLE_INDEX2_IMPL(const nlohmann::json &config,
                              const std::string &var_name) {
    using namespace sophiar;
    if (config.contains(var_name)) {
        assert(config[var_name].is_string());
        auto _name = config[var_name].get<std::string>();
        return REQUIRE_VARIABLE(SmallObjType, _name);
    } else {
        return invalid_variable_index;
    }
}

#define TRY_LOAD_VARIABLE_INDEX2(config, var_type, var_name) \
    TRY_LOAD_VARIABLE_INDEX2_IMPL<var_type>(config, var_name)

#define TRY_LOAD_VARIABLE_INDEX(var_type, var_name) \
    TRY_LOAD_VARIABLE_INDEX2(config, var_type, var_name)

template<typename SmallObjType>
inline auto LOAD_VARIABLE_INDEX_WITH_NAME_IMPL(const nlohmann::json &config,
                                               const std::string &var_name, std::string &var_name_out) {
    var_name_out = LOAD_STRING_ITEM(var_name);
    using namespace sophiar;
    return REQUIRE_VARIABLE(SmallObjType, var_name_out);
}

#define LOAD_VARIABLE_INDEX_WITH_NAME(var_type, var_name, var_name_out) \
    LOAD_VARIABLE_INDEX_WITH_NAME_IMPL<var_type>(config, var_name, var_name_out)

#endif //SOPHIAR2_CONFIG_UTILITY_HPP