BasicConfig.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012, 2013 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_BASICS_BASICCONFIG_H_INCLUDED
#define RIPPLE_BASICS_BASICCONFIG_H_INCLUDED
 
#include <ripple/basics/contract.h>
#include <boost/beast/core/string.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <map>
#include <optional>
#include <ostream>
#include <string>
#include <vector>
 
namespace ripple {
 
using IniFileSections = std::map<std::string, std::vector<std::string>>;
 
//------------------------------------------------------------------------------
 
class Section
{
private:
    std::string name_;
    std::map<std::string, std::string> lookup_;
    std::vector<std::string> lines_;
    std::vector<std::string> values_;
    bool had_trailing_comments_ = false;
 
    using const_iterator = decltype(lookup_)::const_iterator;
 
public:
    explicit Section(std::string const& name = "");
 
    std::string const&
    name() const
    {
        return name_;
    }
 
    std::vector<std::string> const&
    lines() const
    {
        return lines_;
    }
 
    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);
    }
 
    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});
    }
 
    bool
    exists(std::string const& name) const;
 
    template <class T = std::string>
    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>
    T
    value_or(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
    bool
    had_trailing_comments() const
    {
        return had_trailing_comments_;
    }
 
    friend std::ostream&
    operator<<(std::ostream&, Section const& section);
 
    // Returns `true` if there are no key/value pairs.
    bool
    empty() const
    {
        return lookup_.empty();
    }
 
    // Returns the number of key/value pairs.
    std::size_t
    size() const
    {
        return lookup_.size();
    }
 
    // For iteration of key/value pairs.
    const_iterator
    begin() const
    {
        return lookup_.cbegin();
    }
 
    // For iteration of key/value pairs.
    const_iterator
    cbegin() const
    {
        return lookup_.cbegin();
    }
 
    // For iteration of key/value pairs.
    const_iterator
    end() const
    {
        return lookup_.cend();
    }
 
    // For iteration of key/value pairs.
    const_iterator
    cend() const
    {
        return lookup_.cend();
    }
};
 
//------------------------------------------------------------------------------
 
class BasicConfig
{
private:
    std::map<std::string, Section, boost::beast::iless> map_;
 
public:
    bool
    exists(std::string const& name) const;
 
    Section&
    section(std::string const& name);
 
    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);
 
    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
    bool
    had_trailing_comments() const
    {
        return std::any_of(map_.cbegin(), map_.cend(), [](auto s) {
            return s.second.had_trailing_comments();
        });
    }
 
protected:
    void
    build(IniFileSections const& ifs);
};
 
//------------------------------------------------------------------------------
 
template <class T>
bool
set(T& target, std::string const& name, Section const& section)
{
    bool found_and_valid = false;
    try
    {
        auto const val = section.get<T>(name);
        if ((found_and_valid = val.has_value()))
            target = *val;
    }
    catch (boost::bad_lexical_cast&)
    {
    }
    return found_and_valid;
}
 
template <class T>
bool
set(T& target,
    T const& defaultValue,
    std::string const& name,
    Section const& section)
{
    bool found_and_valid = set<T>(target, name, section);
    if (!found_and_valid)
        target = defaultValue;
    return found_and_valid;
}
 
// 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.value_or<T>(name, defaultValue);
    }
    catch (boost::bad_lexical_cast&)
    {
    }
    return defaultValue;
}
 
inline std::string
get(Section const& section, std::string const& name, const char* defaultValue)
{
    try
    {
        auto const val = section.get(name);
        if (val.has_value())
            return *val;
    }
    catch (boost::bad_lexical_cast&)
    {
    }
    return defaultValue;
}
 
template <class T>
bool
get_if_exists(Section const& section, std::string const& name, T& v)
{
    return set<T>(v, name, section);
}
 
template <>
inline bool
get_if_exists<bool>(Section const& section, std::string const& name, bool& v)
{
    int intVal = 0;
    auto stat = get_if_exists(section, name, intVal);
    if (stat)
        v = bool(intVal);
    return stat;
}
 
}  // namespace ripple
 
#endif