ConfigTree.h

Go to the documentation of this file.

 
#pragma once
 
#include <boost/property_tree/ptree.hpp>
#include <functional>
#include <iosfwd>
#include <iterator>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <typeindex>
#include <utility>
#include <vector>
 
extern template class boost::property_tree::basic_ptree<
    std::string, std::string, std::less<>>;
 
namespace BaseLib
{
class ConfigTree;
 
void checkAndInvalidate(ConfigTree* const conf);
 
void checkAndInvalidate(std::unique_ptr<ConfigTree> const& conf);
 
void checkAndInvalidate(ConfigTree& conf);
 
template <typename Iterator>
class Range;
 
class ConfigTree final
{
public:
    class SubtreeIterator
    {
    public:
        using iterator_category = std::input_iterator_tag;
        using value_type = ConfigTree;
        using difference_type = std::ptrdiff_t;
        using pointer = ConfigTree*;
        using reference = ConfigTree&;
 
        using Iterator = boost::property_tree::ptree::const_assoc_iterator;
 
        explicit SubtreeIterator(Iterator const& it, std::string const& root,
                                 ConfigTree const& parent)
            : it_(it), tagname_(root), parent_(parent)
        {
        }
        explicit SubtreeIterator(Iterator const& it, std::string const& root, {…}
 
        SubtreeIterator& operator++()
        {
            ++it_;
            has_incremented_ = true;
            return *this;
        }
        SubtreeIterator& operator++() {…}
 
        ConfigTree operator*()
        {
            // if this iterator has been incremented since the last dereference,
            // tell the parent_ instance that a subtree now has been parsed.
            if (has_incremented_)
            {
                has_incremented_ = false;
                parent_.markVisited(tagname_, Attr::TAG, false);
            }
            return ConfigTree(it_->second, parent_, tagname_);
        }
        ConfigTree operator*() {…}
 
        bool operator==(SubtreeIterator const& other) const
        {
            return it_ == other.it_;
        }
        bool operator==(SubtreeIterator const& other) const {…}
 
        bool operator!=(SubtreeIterator const& other) const
        {
            return it_ != other.it_;
        }
        bool operator!=(SubtreeIterator const& other) const {…}
 
    private:
        bool has_incremented_ = true;
        Iterator it_;
 
    protected:
        std::string const tagname_;
        ConfigTree const& parent_;
    };
    class SubtreeIterator {…};
 
    class ParameterIterator : public SubtreeIterator
    {
    public:
        using SubtreeIterator::SubtreeIterator;
 
        ConfigTree operator*()
        {
            auto st = SubtreeIterator::operator*();
            if (st.hasChildren())
            {
                parent_.error("The requested parameter <" + tagname_ +
                              "> has child elements.");
            }
            return st;
        }
        ConfigTree operator*() {…}
    };
    class ParameterIterator : public SubtreeIterator {…};
 
    template <typename ValueType>
    class ValueIterator
    {
    public:
        using iterator_category = std::input_iterator_tag;
        using value_type = ConfigTree;
        using difference_type = std::ptrdiff_t;
        using pointer = ConfigTree*;
        using reference = ConfigTree&;
 
        using Iterator = boost::property_tree::ptree::const_assoc_iterator;
 
        explicit ValueIterator(Iterator const& it, std::string const& root,
                               ConfigTree const& parent)
            : it_(it), tagname_(root), parent_(parent)
        {
        }
        explicit ValueIterator(Iterator const& it, std::string const& root, {…}
 
        ValueIterator<ValueType>& operator++()
        {
            ++it_;
            has_incremented_ = true;
            return *this;
        }
        ValueIterator<ValueType>& operator++() {…}
 
        ValueType operator*()
        {
            // if this iterator has been incremented since the last dereference,
            // tell the parent_ instance that a setting now has been parsed.
            if (has_incremented_)
            {
                has_incremented_ = false;
                parent_.markVisited<ValueType>(tagname_, Attr::TAG, false);
            }
            return ConfigTree(it_->second, parent_, tagname_)
                .getValue<ValueType>();
        }
        ValueType operator*() {…}
 
        bool operator==(ValueIterator<ValueType> const& other) const
        {
            return it_ == other.it_;
        }
        bool operator==(ValueIterator<ValueType> const& other) const {…}
 
        bool operator!=(ValueIterator<ValueType> const& other) const
        {
            return it_ != other.it_;
        }
        bool operator!=(ValueIterator<ValueType> const& other) const {…}
 
    private:
        bool has_incremented_ = true;
        Iterator it_;
        std::string const tagname_;
        ConfigTree const& parent_;
    };
    class ValueIterator {…};
 
    using PTree = boost::property_tree::ptree;
 
    using Callback = std::function<void(const std::string& filename,
                                        const std::string& path,
                                        const std::string& message)>;
 
    explicit ConfigTree(PTree&& top_level_tree,
                        std::string filename,
                        Callback error_cb,
                        Callback warning_cb);
 
    ConfigTree(ConfigTree const&) = delete;
 
    ConfigTree(ConfigTree&& other);
 
    ConfigTree& operator=(ConfigTree const&) = delete;
 
    ConfigTree& operator=(ConfigTree&& other);
 
    std::string const& getProjectFileName() const { return filename_; }
 
 
    template <typename T>
    T getConfigParameter(std::string const& param) const;
 
    template <typename T>
    T getConfigParameter(std::string const& param,
                         T const& default_value) const;
 
    template <typename T>
    std::optional<T> getConfigParameterOptional(std::string const& param) const;
 
    template <typename T>
    Range<ValueIterator<T>> getConfigParameterList(
        std::string const& param) const;
 
 
 
    ConfigTree getConfigParameter(std::string const& root) const;
 
    std::optional<ConfigTree> getConfigParameterOptional(
        std::string const& param) const;
 
    Range<ParameterIterator> getConfigParameterList(
        std::string const& param) const;
 
    template <typename T>
    T getValue() const;
 
    template <typename T>
    T getConfigAttribute(std::string const& attr) const;
 
    template <typename T>
    T getConfigAttribute(std::string const& attr, T const& default_value) const;
 
    template <typename T>
    std::optional<T> getConfigAttributeOptional(std::string const& attr) const;
 
 
 
    template <typename T>
    T peekConfigParameter(std::string const& param) const;
 
    void checkConfigParameter(std::string const& param,
                              std::string_view const value) const;
 
 
 
    ConfigTree getConfigSubtree(std::string const& root) const;
 
    std::optional<ConfigTree> getConfigSubtreeOptional(
        std::string const& root) const;
 
    Range<SubtreeIterator> getConfigSubtreeList(std::string const& root) const;
 
 
 
    void ignoreConfigParameter(std::string const& param) const;
 
    void ignoreConfigParameterAll(std::string const& param) const;
 
    void ignoreConfigAttribute(std::string const& attr) const;
 
 
    ~ConfigTree();
 
    static void onerror(std::string const& filename, std::string const& path,
                        std::string const& message);
 
    static void onwarning(std::string const& filename, std::string const& path,
                          std::string const& message);
 
    static void assertNoSwallowedErrors();
 
private:
    template <typename T>
    std::optional<T> getConfigParameterOptionalImpl(std::string const& param,
                                                    T* /*unused*/) const;
 
    template <typename T>
    std::optional<std::vector<T>> getConfigParameterOptionalImpl(
        std::string const& param, std::vector<T>* /*unused*/) const;
 
    struct CountType
    {
        int count;
        std::type_index type;
    };
    struct CountType {…};
 
    enum class Attr : bool
    {
        TAG = false,
        ATTR = true
    };
    enum class Attr : bool {…};
 
    explicit ConfigTree(PTree const& tree, ConfigTree const& parent,
                        std::string const& root);
 
    [[noreturn]] void error(std::string const& message) const;
 
    void warning(std::string const& message) const;
 
    void checkKeyname(std::string const& key) const;
 
    std::string joinPaths(std::string const& p1, std::string const& p2) const;
 
    void checkUnique(std::string const& key) const;
 
    void checkUniqueAttr(std::string const& attr) const;
 
    template <typename T>
    CountType& markVisited(std::string const& key, Attr const is_attr,
                           bool peek_only) const;
 
    CountType& markVisited(std::string const& key, Attr const is_attr,
                           bool const peek_only) const;
 
    void markVisitedDecrement(Attr const is_attr, std::string const& key) const;
 
    bool hasChildren() const;
 
    void checkAndInvalidate();
 
    static std::string shortString(std::string const& s);
 
    std::shared_ptr<PTree const> top_level_tree_;
 
    PTree const* tree_;
 
    std::string path_;
 
    std::string filename_;
 
    using KeyType = std::pair<Attr, std::string>;
 
    mutable std::map<KeyType, CountType> visited_params_;
 
    mutable bool have_read_data_ = false;
 
    Callback onerror_;    
    Callback onwarning_;  
 
    static const char pathseparator;
 
    static const std::string key_chars_start;
 
    static const std::string key_chars;
 
    friend void checkAndInvalidate(ConfigTree* const conf);
    friend void checkAndInvalidate(ConfigTree& conf);
    friend void checkAndInvalidate(std::unique_ptr<ConfigTree> const& conf);
};
class ConfigTree final {…};
 
}  // namespace BaseLib
 
#include "ConfigTree-impl.h"  // IWYU pragma: keep