yaml_util.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include "yaml_util.h"
 
#include <entropic/types/logging.h>
#include <cstdlib>
#include <fstream>
#include <sstream>
 
static auto s_log = entropic::log::get("config");
 
namespace entropic::config {
 
std::string to_string(c4::csubstr s)
{
    return std::string(s.str, s.len);
}
 
std::string read_file(const std::filesystem::path& path)
{
    std::ifstream ifs(path);
    if (!ifs.is_open()) {
        s_log->error("Cannot open file: {}", path.string());
        return "";
    }
    std::ostringstream ss;
    ss << ifs.rdbuf();
    auto content = ss.str();
    s_log->info("Read file: {}, {} bytes", path.string(),
                content.size());
    return content;
}
 
std::filesystem::path expand_home(const std::filesystem::path& p)
{
    auto str = p.string();
    const char* home = std::getenv("HOME");
    bool needs_expansion = !str.empty() && str[0] == '~' && home != nullptr;
 
    if (!needs_expansion) {
        return p;
    }
 
    return (str.size() == 1)
        ? std::filesystem::path(home)
        : std::filesystem::path(home) / str.substr(2);
}
 
bool extract(ryml::ConstNodeRef node, c4::csubstr key, std::string& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.has_val() || child.val_is_null()) {
        return false;
    }
    out = to_string(child.val());
    return true;
}
 
bool extract(ryml::ConstNodeRef node, c4::csubstr key, int& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.has_val() || child.val_is_null()) {
        return false;
    }
    auto val = to_string(child.val());
    out = std::stoi(val);
    return true;
}
 
bool extract(ryml::ConstNodeRef node, c4::csubstr key, float& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.has_val() || child.val_is_null()) {
        return false;
    }
    auto val = to_string(child.val());
    out = std::stof(val);
    return true;
}
 
bool extract(ryml::ConstNodeRef node, c4::csubstr key, double& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.has_val() || child.val_is_null()) {
        return false;
    }
    auto val = to_string(child.val());
    out = std::stod(val);
    return true;
}
 
bool extract(ryml::ConstNodeRef node, c4::csubstr key, bool& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.has_val() || child.val_is_null()) {
        return false;
    }
    auto val = to_string(child.val());
    out = (val == "true" || val == "True" || val == "TRUE"
           || val == "yes" || val == "Yes" || val == "YES"
           || val == "on" || val == "On" || val == "ON"
           || val == "1");
    return true;
}
 
bool extract_path(ryml::ConstNodeRef node, c4::csubstr key,
                  std::filesystem::path& out)
{
    std::string val;
    if (!extract(node, key, val)) {
        return false;
    }
    out = expand_home(std::filesystem::path(val));
    return true;
}
 
bool extract_tri_state_path(
    ryml::ConstNodeRef node, c4::csubstr key,
    std::optional<std::filesystem::path>& out, bool& disabled)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    bool is_null = !child.has_val() || child.val_is_null();
    auto val = is_null ? std::string{} : to_string(child.val());
    bool is_false = (val == "false" || val == "False" || val == "FALSE");
 
    disabled = is_false;
    out = (is_null || is_false)
        ? std::nullopt
        : std::optional{expand_home(std::filesystem::path(val))};
    return true;
}
 
bool extract_inline_content(
    ryml::ConstNodeRef node, c4::csubstr key, std::optional<std::string>& out)
{
    bool matched = false;
    if (node.is_map() && node.has_child(key)) {
        auto child = node[key];
        if (child.is_map() && child.has_child("content")) {
            auto content = child["content"];
            if (content.has_val()) {
                out = to_string(content.val());
                matched = true;
            }
        }
    }
    return matched;
}
 
bool extract_string_list(ryml::ConstNodeRef node, c4::csubstr key,
                         std::vector<std::string>& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.is_seq()) {
        return false;
    }
    out.clear();
    for (auto item : child) {
        out.push_back(to_string(item.val()));
    }
    return true;
}
 
bool extract_string_list_opt(ryml::ConstNodeRef node, c4::csubstr key,
                             std::optional<std::vector<std::string>>& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.is_seq()) {
        bool is_null = !child.has_val() || child.val_is_null();
        out = is_null ? std::nullopt : out;
        return is_null;
    }
    std::vector<std::string> vec;
    for (auto item : child) {
        vec.push_back(to_string(item.val()));
    }
    out = std::move(vec);
    return true;
}
 
bool extract_string_map(ryml::ConstNodeRef node, c4::csubstr key,
                        std::unordered_map<std::string, std::string>& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.is_map()) {
        return false;
    }
    out.clear();
    for (auto item : child) {
        out[to_string(item.key())] = to_string(item.val());
    }
    return true;
}
 
bool extract_string_list_map(
    ryml::ConstNodeRef node, c4::csubstr key,
    std::unordered_map<std::string, std::vector<std::string>>& out)
{
    if (!node.is_map() || !node.has_child(key)) {
        return false;
    }
    auto child = node[key];
    if (!child.is_map()) {
        return false;
    }
    out.clear();
    for (auto item : child) {
        std::vector<std::string> vec;
        if (item.is_seq()) {
            for (auto elem : item) {
                vec.push_back(to_string(elem.val()));
            }
        }
        out[to_string(item.key())] = std::move(vec);
    }
    return true;
}
 
} // namespace entropic::config