gui_layout_node.hpp

#ifndef LXGUI_GUI_LAYOUT_NODE_HPP
#define LXGUI_GUI_LAYOUT_NODE_HPP
 
#include "lxgui/gui_out.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
#include "lxgui/utils_exception.hpp"
#include "lxgui/utils_string.hpp"
#include "lxgui/utils_view.hpp"
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace lxgui::gui {
 
class layout_attribute {
public:
    layout_attribute()                        = default;
    layout_attribute(const layout_attribute&) = default;
    layout_attribute(layout_attribute&&)      = default;
    layout_attribute& operator=(const layout_attribute&) = default;
    layout_attribute& operator=(layout_attribute&&) = default;
 
    std::string_view get_location() const noexcept {
        return location_;
    }
 
    std::string_view get_value_location() const noexcept {
        return value_location_;
    }
 
    std::string_view get_filename() const noexcept {
        auto pos = location_.find(':');
        return std::string_view(location_.c_str(), pos == location_.npos ? location_.size() : pos);
    }
 
    std::size_t get_line_number() const noexcept {
        std::size_t line = std::numeric_limits<std::size_t>::max();
        auto        pos  = location_.find(':');
        if (pos != location_.npos && pos < location_.size() - 1) {
            line = utils::from_string<std::size_t>(location_.substr(pos + 1)).value_or(line);
        }
        return line;
    }
 
    std::size_t get_value_line_number() const noexcept {
        std::size_t line = std::numeric_limits<std::size_t>::max();
        auto        pos  = value_location_.find(':');
        if (pos != value_location_.npos && pos < value_location_.size() - 1) {
            line = utils::from_string<std::size_t>(value_location_.substr(pos + 1)).value_or(line);
        }
        return line;
    }
 
    std::string_view get_name() const noexcept {
        return name_;
    }
 
    std::string_view get_value() const noexcept {
        accessed_ = true;
        return value_;
    }
 
    template<typename T>
    std::optional<T> try_get_value() const noexcept {
        accessed_  = true;
        auto value = utils::from_string<T>(value_);
        if (!value.has_value()) {
            gui::out << gui::warning << std::string(get_location())
                     << ": could not parse value for '" << std::string(name_) << "': '"
                     << std::string(value_) << "'; ignoring" << std::endl;
        }
        return value;
    }
 
    template<typename T>
    T get_value() const {
        accessed_  = true;
        auto value = utils::from_string<T>(value_);
        if (!value.has_value()) {
            throw utils::exception(
                std::string(get_location()) + ": could not parse value for '" + std::string(name_) +
                "': '" + std::string(value_) + "'");
        }
 
        return value.value();
    }
 
    template<typename T>
    T get_value_or(T fallback) const noexcept {
        accessed_  = true;
        auto value = utils::from_string<T>(value_);
        if (!value.has_value()) {
            gui::out << gui::warning << std::string(get_location())
                     << ": could not parse value for '" << std::string(name_) << "': '"
                     << std::string(value_) << "'; using '" << utils::to_string(fallback) << "'"
                     << std::endl;
            return fallback;
        }
        return value.value();
    }
 
    void set_location(std::string location) noexcept {
        location_ = std::move(location);
    }
 
    void set_value_location(std::string location) noexcept {
        value_location_ = std::move(location);
    }
 
    void set_name(std::string name) noexcept {
        name_ = std::move(name);
    }
 
    void set_value(std::string value) noexcept {
        value_ = std::move(value);
    }
 
    void mark_as_not_accessed() const noexcept {
        accessed_ = false;
    }
 
    void bypass_access_check() const noexcept {
        access_bypass_ = true;
    }
 
    bool was_accessed() const noexcept {
        return accessed_;
    }
 
    bool is_access_check_bypassed() const noexcept {
        return access_bypass_;
    }
 
protected:
    std::string name_;
    std::string value_;
    std::string location_;
    std::string value_location_;
 
    mutable bool accessed_      = false;
    mutable bool access_bypass_ = false;
};
 
class layout_node : public layout_attribute {
public:
    layout_node()                   = default;
    layout_node(const layout_node&) = default;
    layout_node(layout_node&&)      = default;
    layout_node& operator=(const layout_node&) = default;
    layout_node& operator=(layout_node&&) = default;
 
    using child_list    = std::vector<layout_node>;
    using children_view = utils::view::
        adaptor<const child_list, utils::view::standard_dereferencer, utils::view::no_filter>;
 
    std::size_t get_child_count() const noexcept {
        return child_list_.size();
    }
 
    const layout_node& get_child(std::size_t index) const noexcept {
        accessed_ = true;
        return child_list_[index];
    }
 
    children_view get_children() const noexcept {
        accessed_ = true;
        return children_view(child_list_);
    }
 
    template<typename BaseIterator>
    struct name_filter {
        std::string_view filter;
 
        bool is_included(const BaseIterator& iter) const noexcept {
            return iter->get_name() == filter;
        }
    };
 
    using filtered_children_view =
        utils::view::adaptor<const child_list, utils::view::standard_dereferencer, name_filter>;
 
    filtered_children_view get_children(std::string_view name) const noexcept {
        accessed_ = true;
        return filtered_children_view(child_list_, {}, {name});
    }
 
    const layout_node* try_get_child(std::string_view name) const noexcept {
        accessed_ = true;
        for (const layout_node& node : get_children(name)) {
            return &node;
        }
 
        return nullptr;
    }
 
    const layout_node& get_child(std::string_view name) const {
        if (const auto* child = try_get_child(name))
            return *child;
 
        throw utils::exception(
            std::string(get_location()) + ": no child found with name '" + std::string(name) +
            "' in '" + std::string(name_) + "'");
    }
 
    bool has_child(std::string_view name) const noexcept {
        return try_get_child(name) != nullptr;
    }
 
    const layout_attribute* try_get_attribute(std::string_view name) const noexcept {
        accessed_ = true;
        for (const layout_attribute& node : attr_list_) {
            if (node.get_name() == name)
                return &node;
        }
 
        return nullptr;
    }
 
    const layout_attribute& get_attribute(std::string_view name) const {
        if (const auto* attr = try_get_attribute(name))
            return *attr;
 
        throw utils::exception(
            std::string(get_location()) + ": no attribute found with name '" + std::string(name) +
            "' in '" + std::string(name_) + "'");
    }
 
    bool has_attribute(std::string_view name) const noexcept {
        return try_get_attribute(name) != nullptr;
    }
 
    std::optional<std::string_view> try_get_attribute_value(std::string_view name) const noexcept {
        if (const auto* attr = try_get_attribute(name))
            return attr->get_value();
 
        return std::nullopt;
    }
 
    template<typename T>
    std::optional<T> try_get_attribute_value(std::string_view name) const noexcept {
        if (const auto* attr = try_get_attribute(name))
            return attr->try_get_value<T>();
 
        return std::nullopt;
    }
 
    template<typename T>
    T get_attribute_value_or(std::string_view name, T fallback) const noexcept {
        if (const auto* attr = try_get_attribute(name))
            return attr->get_value_or<T>(fallback);
 
        return fallback;
    }
 
    std::string_view get_attribute_value(std::string_view name) const {
        return get_attribute(name).get_value();
    }
 
    template<typename T>
    T get_attribute_value(std::string_view name) const {
        return get_attribute(name).get_value<T>();
    }
 
    using attribute_list = std::vector<layout_attribute>;
    using attribute_view = utils::view::
        adaptor<const attribute_list, utils::view::standard_dereferencer, utils::view::no_filter>;
 
    attribute_view get_attributes() const noexcept {
        accessed_ = true;
        return attribute_view(attr_list_);
    }
 
    layout_node& add_child() {
        return child_list_.emplace_back();
    }
 
    layout_attribute& add_attribute() {
        return attr_list_.emplace_back();
    }
 
    std::string_view get_or_set_attribute_value(std::string_view name, std::string_view value) {
        accessed_ = true;
        if (const auto* attr = try_get_attribute(name))
            return attr->get_value();
 
        auto& attr = add_attribute();
        attr.set_name(std::string(name));
        attr.set_value(std::string(value));
        return value;
    }
 
private:
    child_list     child_list_;
    attribute_list attr_list_;
};
 
template<>
inline std::optional<std::string> layout_attribute::try_get_value<std::string>() const noexcept {
    accessed_ = true;
    return value_;
}
 
template<>
inline std::string layout_attribute::get_value<std::string>() const {
    accessed_ = true;
    return value_;
}
 
template<>
inline std::string layout_attribute::get_value_or<std::string>(std::string) const noexcept {
    accessed_ = true;
    return value_;
}
 
} // namespace lxgui::gui
 
#endif