ConfigTree.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <boost/property_tree/ptree.hpp>
#include <filesystem>
#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)
        {
        }
 
        SubtreeIterator& operator++()
        {
            ++it_;
            has_incremented_ = true;
            return *this;
        }
 
        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_);
        }
 
        bool operator==(SubtreeIterator const& other) const
        {
            return it_ == other.it_;
        }
 
        bool operator!=(SubtreeIterator const& other) const
        {
            return it_ != other.it_;
        }
 
    private:
        bool has_incremented_ = true;
        Iterator it_;
 
    protected:
        std::string const tagname_;
        ConfigTree const& parent_;
    };

    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;
        }
    };

    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)
        {
        }
 
        ValueIterator<ValueType>& operator++()
        {
            ++it_;
            has_incremented_ = true;
            return *this;
        }
 
        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>();
        }
 
        bool operator==(ValueIterator<ValueType> const& other) const
        {
            return it_ == other.it_;
        }
 
        bool operator!=(ValueIterator<ValueType> const& other) const
        {
            return it_ != other.it_;
        }
 
    private:
        bool has_incremented_ = true;
        Iterator it_;
        std::string const tagname_;
        ConfigTree const& parent_;
    };

    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::filesystem::path const& projectFilePath() const { return filepath_; }
 
    std::filesystem::path projectDirectory() const;


    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;
    };

    enum class Attr : bool
    {
        TAG = false,
        ATTR = true
    };

    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::filesystem::path filepath_;

    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);
};
 
}  // namespace BaseLib
 
#include "ConfigTree-impl.h"  // IWYU pragma: keep