BasicConfig.h

#pragma once
 
#include <xrpl/basics/contract.h>
 
#include <boost/lexical_cast.hpp>
 
#include <algorithm>
#include <cstddef>
#include <optional>
#include <ostream>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace xrpl {
 
using IniFileSections = std::unordered_map<std::string, std::vector<std::string>>;
 
//------------------------------------------------------------------------------

class Section
{
private:
    std::string name_;
    std::unordered_map<std::string, std::string> lookup_;
    std::vector<std::string> lines_;
    std::vector<std::string> values_;
    bool hadTrailingComments_ = false;
 
    using const_iterator = decltype(lookup_)::const_iterator;
 
public:
    explicit Section(std::string name = "");

    [[nodiscard]] std::string const&
    name() const
    {
        return name_;
    }

    [[nodiscard]] std::vector<std::string> const&
    lines() const
    {
        return lines_;
    }

    [[nodiscard]] std::vector<std::string> const&
    values() const
    {
        return values_;
    }

    void
    legacy(std::string value)
    {
        if (lines_.empty())
        {
            lines_.emplace_back(std::move(value));
        }
        else
        {
            lines_[0] = std::move(value);
        }
    }

    [[nodiscard]] std::string
    legacy() const
    {
        if (lines_.empty())
            return "";
        if (lines_.size() > 1)
        {
            Throw<std::runtime_error>(
                "A legacy value must have exactly one line. Section: " + name_);
        }
        return lines_[0];
    }

    void
    set(std::string const& key, std::string const& value);

    void
    append(std::vector<std::string> const& lines);

    void
    append(std::string const& line)
    {
        append(std::vector<std::string>{line});
    }

    [[nodiscard]] bool
    exists(std::string const& name) const;
 
    template <class T = std::string>
    [[nodiscard]] std::optional<T>
    get(std::string const& name) const
    {
        auto const iter = lookup_.find(name);
        if (iter == lookup_.end())
            return std::nullopt;
        return boost::lexical_cast<T>(iter->second);
    }

    template <class T>
    [[nodiscard]] T
    valueOr(std::string const& name, T const& other) const
    {
        auto const v = get<T>(name);
        return v.has_value() ? *v : other;
    }
 
    // indicates if trailing comments were seen
    // during the appending of any lines/values
    [[nodiscard]] bool
    hadTrailingComments() const
    {
        return hadTrailingComments_;
    }
 
    friend std::ostream&
    operator<<(std::ostream&, Section const& section);
 
    // Returns `true` if there are no key/value pairs.
    [[nodiscard]] bool
    empty() const
    {
        return lookup_.empty();
    }
 
    // Returns the number of key/value pairs.
    [[nodiscard]] std::size_t
    size() const
    {
        return lookup_.size();
    }
 
    // For iteration of key/value pairs.
    [[nodiscard]] const_iterator
    begin() const
    {
        return lookup_.cbegin();
    }
 
    // For iteration of key/value pairs.
    [[nodiscard]] const_iterator
    cbegin() const
    {
        return lookup_.cbegin();
    }
 
    // For iteration of key/value pairs.
    [[nodiscard]] const_iterator
    end() const
    {
        return lookup_.cend();
    }
 
    // For iteration of key/value pairs.
    [[nodiscard]] const_iterator
    cend() const
    {
        return lookup_.cend();
    }
};
 
//------------------------------------------------------------------------------

class BasicConfig
{
private:
    std::unordered_map<std::string, Section> map_;
 
public:
    [[nodiscard]] bool
    exists(std::string const& name) const;

    Section&
    section(std::string const& name);
 
    [[nodiscard]] Section const&
    section(std::string const& name) const;
 
    Section const&
    operator[](std::string const& name) const
    {
        return section(name);
    }
 
    Section&
    operator[](std::string const& name)
    {
        return section(name);
    }


    void
    overwrite(std::string const& section, std::string const& key, std::string const& value);

    void
    deprecatedClearSection(std::string const& section);

    void
    legacy(std::string const& section, std::string value);

    [[nodiscard]] std::string
    legacy(std::string const& sectionName) const;
 
    friend std::ostream&
    operator<<(std::ostream& ss, BasicConfig const& c);
 
    // indicates if trailing comments were seen
    // in any loaded Sections
    [[nodiscard]] bool
    hadTrailingComments() const
    {
        return std::ranges::any_of(map_, [](auto s) { return s.second.hadTrailingComments(); });
    }
 
protected:
    void
    build(IniFileSections const& ifs);
};
 
//------------------------------------------------------------------------------

template <class T>
bool
set(T& target, std::string const& name, Section const& section)
{
    bool foundAndValid = false;
    try
    {
        auto const val = section.get<T>(name);
        foundAndValid = val.has_value();
        if (foundAndValid)
            target = *val;
    }
    catch (boost::bad_lexical_cast const&)  // NOLINT(bugprone-empty-catch)
    {
    }
    return foundAndValid;
}

template <class T>
bool
set(T& target, T const& defaultValue, std::string const& name, Section const& section)
{
    bool const foundAndValid = set<T>(target, name, section);
    if (!foundAndValid)
        target = defaultValue;
    return foundAndValid;
}

// NOTE This routine might be more clumsy than the previous two
template <class T = std::string>
T
get(Section const& section, std::string const& name, T const& defaultValue = T{})
{
    try
    {
        return section.valueOr<T>(name, defaultValue);
    }
    catch (boost::bad_lexical_cast const&)  // NOLINT(bugprone-empty-catch)
    {
    }
    return defaultValue;
}
 
inline std::string
get(Section const& section, std::string const& name, char const* defaultValue)
{
    try
    {
        auto const val = section.get(name);
        if (val.has_value())
            return *val;
    }
    catch (boost::bad_lexical_cast const&)  // NOLINT(bugprone-empty-catch)
    {
    }
    return defaultValue;
}
 
template <class T>
bool
getIfExists(Section const& section, std::string const& name, T& v)
{
    return set<T>(v, name, section);
}
 
template <>
inline bool
getIfExists<bool>(Section const& section, std::string const& name, bool& v)
{
    int intVal = 0;
    auto stat = getIfExists(section, name, intVal);
    if (stat)
        v = bool(intVal);
    return stat;
}
 
}  // namespace xrpl