node_view.hpp

Go to the documentation of this file.

//# This file is a part of toml++ and is subject to the the terms of the MIT license.
//# Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
//# See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
// SPDX-License-Identifier: MIT
#pragma once
 
#include "std_vector.hpp"
#include "std_initializer_list.hpp"
#include "print_to_stream.hpp"
#include "node.hpp"
#include "header_start.hpp"
TOML_DISABLE_ARITHMETIC_WARNINGS;
 
TOML_NAMESPACE_START
{
    template <typename ViewedType>
    class TOML_TRIVIAL_ABI node_view
    {
        static_assert(impl::is_one_of<ViewedType, toml::node, const toml::node>,
                      "A toml::node_view<> must wrap toml::node or const toml::node.");
 
      public:
        using viewed_type = ViewedType;
 
      private:
        template <typename T>
        friend class node_view;
 
        mutable viewed_type* node_ = nullptr;
 
      public:
        TOML_NODISCARD_CTOR
        node_view() noexcept = default;
 
        TOML_NODISCARD_CTOR
        explicit node_view(viewed_type* node) noexcept //
            : node_{ node }
        {}
 
        TOML_NODISCARD_CTOR
        explicit node_view(viewed_type& node) noexcept //
            : node_{ &node }
        {}
 
        TOML_NODISCARD_CTOR
        node_view(const node_view&) noexcept = default;
 
        TOML_NODISCARD_CTOR
        node_view(node_view&&) noexcept = default;
 
        node_view& operator=(const node_view&) & noexcept = default;
 
        node_view& operator=(node_view&&) & noexcept = default;
 
        TOML_PURE_INLINE_GETTER
        explicit operator bool() const noexcept
        {
            return node_ != nullptr;
        }
 
        TOML_PURE_INLINE_GETTER
        viewed_type* node() const noexcept
        {
            return node_;
        }
 
 
        TOML_PURE_GETTER
        node_type type() const noexcept
        {
            return node_ ? node_->type() : node_type::none;
        }
 
        TOML_PURE_GETTER
        bool is_table() const noexcept
        {
            return node_ && node_->is_table();
        }
 
        TOML_PURE_GETTER
        bool is_array() const noexcept
        {
            return node_ && node_->is_array();
        }
 
        TOML_PURE_GETTER
        bool is_value() const noexcept
        {
            return node_ && node_->is_value();
        }
 
        TOML_PURE_GETTER
        bool is_string() const noexcept
        {
            return node_ && node_->is_string();
        }
 
        TOML_PURE_GETTER
        bool is_integer() const noexcept
        {
            return node_ && node_->is_integer();
        }
 
        TOML_PURE_GETTER
        bool is_floating_point() const noexcept
        {
            return node_ && node_->is_floating_point();
        }
 
        TOML_PURE_GETTER
        bool is_number() const noexcept
        {
            return node_ && node_->is_number();
        }
 
        TOML_PURE_GETTER
        bool is_boolean() const noexcept
        {
            return node_ && node_->is_boolean();
        }
 
        TOML_PURE_GETTER
        bool is_date() const noexcept
        {
            return node_ && node_->is_date();
        }
 
        TOML_PURE_GETTER
        bool is_time() const noexcept
        {
            return node_ && node_->is_time();
        }
 
        TOML_PURE_GETTER
        bool is_date_time() const noexcept
        {
            return node_ && node_->is_date_time();
        }
 
        TOML_PURE_GETTER
        bool is_array_of_tables() const noexcept
        {
            return node_ && node_->is_array_of_tables();
        }
 
        template <typename T>
        TOML_PURE_GETTER
        bool is() const noexcept
        {
            return node_ ? node_->template is<impl::unwrap_node<impl::remove_cvref<T>>>() : false;
        }
 
        TOML_NODISCARD
        bool is_homogeneous(node_type ntype, viewed_type*& first_nonmatch) const noexcept
        {
            if (!node_)
            {
                first_nonmatch = {};
                return false;
            }
            return node_->is_homogeneous(ntype, first_nonmatch);
        }
 
        TOML_NODISCARD
        bool is_homogeneous(node_type ntype) const noexcept
        {
            return node_ ? node_->is_homogeneous(ntype) : false;
        }
 
        template <typename ElemType = void>
        TOML_PURE_GETTER
        bool is_homogeneous() const noexcept
        {
            return node_ ? node_->template is_homogeneous<impl::unwrap_node<impl::remove_cvref<ElemType>>>() : false;
        }
 
 
 
        template <typename T>
        TOML_PURE_GETTER
        auto* as() const noexcept
        {
            return node_ ? node_->template as<T>() : nullptr;
        }
 
        TOML_PURE_GETTER
        auto* as_table() const noexcept
        {
            return as<table>();
        }
 
        TOML_PURE_GETTER
        auto* as_array() const noexcept
        {
            return as<array>();
        }
 
        TOML_PURE_GETTER
        auto* as_string() const noexcept
        {
            return as<std::string>();
        }
 
        TOML_PURE_GETTER
        auto* as_integer() const noexcept
        {
            return as<int64_t>();
        }
 
        TOML_PURE_GETTER
        auto* as_floating_point() const noexcept
        {
            return as<double>();
        }
 
        TOML_PURE_GETTER
        auto* as_boolean() const noexcept
        {
            return as<bool>();
        }
 
        TOML_PURE_GETTER
        auto* as_date() const noexcept
        {
            return as<date>();
        }
 
        TOML_PURE_GETTER
        auto* as_time() const noexcept
        {
            return as<time>();
        }
 
        TOML_PURE_GETTER
        auto* as_date_time() const noexcept
        {
            return as<date_time>();
        }
 
 
 
        template <typename T>
        TOML_NODISCARD
        optional<T> value_exact() const noexcept(impl::value_retrieval_is_nothrow<T>)
        {
            if (node_)
                return node_->template value_exact<T>();
            return {};
        }
 
        template <typename T>
        TOML_NODISCARD
        optional<T> value() const noexcept(impl::value_retrieval_is_nothrow<T>)
        {
            if (node_)
                return node_->template value<T>();
            return {};
        }
 
        template <typename T>
        TOML_NODISCARD
        auto value_or(T&& default_value) const noexcept(impl::value_retrieval_is_nothrow<T>)
        {
            using namespace ::toml::impl;
 
            static_assert(!is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
                          "Retrieving values as wide-character strings is only "
                          "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
 
            if constexpr (is_wide_string<T>)
            {
#if TOML_ENABLE_WINDOWS_COMPAT
 
                if (node_)
                    return node_->value_or(static_cast<T&&>(default_value));
                return std::wstring{ static_cast<T&&>(default_value) };
 
#else
 
                static_assert(impl::always_false<T>, "Evaluated unreachable branch!");
 
#endif
            }
            else
            {
                using value_type =
                    std::conditional_t<std::is_pointer_v<std::decay_t<T>>,
                                       std::add_pointer_t<std::add_const_t<std::remove_pointer_t<std::decay_t<T>>>>,
                                       std::decay_t<T>>;
 
                if (node_)
                    return node_->value_or(static_cast<T&&>(default_value));
                if constexpr (std::is_pointer_v<value_type>)
                    return value_type{ default_value };
                else
                    return static_cast<T&&>(default_value);
            }
        }
 
        template <typename T>
        TOML_PURE_INLINE_GETTER
        decltype(auto) ref() const noexcept
        {
            TOML_ASSERT_ASSUME(node_ && "toml::node_view::ref() called on a node_view that did not reference a node");
            return node_->template ref<T>();
        }
 
 
 
      private:
        template <typename Func>
        static constexpr bool visit_is_nothrow = noexcept(std::declval<viewed_type*>()->visit(std::declval<Func>()));
 
      public:
        template <typename Func>
        decltype(auto) visit(Func&& visitor) const noexcept(visit_is_nothrow<Func&&>)
        {
            using return_type = decltype(node_->visit(static_cast<Func&&>(visitor)));
            if (node_)
                return node_->visit(static_cast<Func&&>(visitor));
            if constexpr (!std::is_void_v<return_type>)
                return return_type{};
        }
 
 
 
      public:
        template <typename T>
        TOML_PURE_GETTER
        friend bool operator==(const node_view& lhs, const node_view<T>& rhs) noexcept
        {
            return impl::node_deep_equality(lhs.node_, rhs.node_);
        }
 
        template <typename T>
        TOML_PURE_GETTER
        friend bool operator!=(const node_view& lhs, const node_view<T>& rhs) noexcept
        {
            return !impl::node_deep_equality(lhs.node_, rhs.node_);
        }
 
        TOML_NODISCARD
        friend bool operator==(const node_view& lhs, const table& rhs) noexcept
        {
            if (lhs.node_ == &rhs)
                return true;
            const auto tbl = lhs.as<table>();
            return tbl && *tbl == rhs;
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const table&, );
 
        TOML_NODISCARD
        friend bool operator==(const node_view& lhs, const array& rhs) noexcept
        {
            if (lhs.node_ == &rhs)
                return true;
            const auto arr = lhs.as<array>();
            return arr && *arr == rhs;
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const array&, );
 
        template <typename T>
        TOML_NODISCARD
        friend bool operator==(const node_view& lhs, const toml::value<T>& rhs) noexcept
        {
            if (lhs.node_ == &rhs)
                return true;
            const auto val = lhs.as<T>();
            return val && *val == rhs;
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const toml::value<T>&, template <typename T>);
 
        TOML_CONSTRAINED_TEMPLATE(impl::is_losslessly_convertible_to_native<T>, typename T)
        TOML_NODISCARD
        friend bool operator==(const node_view& lhs, const T& rhs) noexcept(!impl::is_wide_string<T>)
        {
            static_assert(!impl::is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
                          "Comparison with wide-character strings is only "
                          "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
 
            if constexpr (impl::is_wide_string<T>)
            {
#if TOML_ENABLE_WINDOWS_COMPAT
                return lhs == impl::narrow(rhs);
#else
                static_assert(impl::always_false<T>, "Evaluated unreachable branch!");
#endif
            }
            else
            {
                const auto val = lhs.as<impl::native_type_of<T>>();
                return val && *val == rhs;
            }
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&,
                                       const T&,
                                       TOML_CONSTRAINED_TEMPLATE(impl::is_losslessly_convertible_to_native<T>,
                                                                 typename T));
 
        template <typename T>
        TOML_NODISCARD
        friend bool operator==(const node_view& lhs,
                               const std::initializer_list<T>& rhs) noexcept(!impl::is_wide_string<T>)
        {
            const auto arr = lhs.as<array>();
            return arr && *arr == rhs;
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const std::initializer_list<T>&, template <typename T>);
 
        template <typename T>
        TOML_NODISCARD
        friend bool operator==(const node_view& lhs, const std::vector<T>& rhs) noexcept(!impl::is_wide_string<T>)
        {
            const auto arr = lhs.as<array>();
            return arr && *arr == rhs;
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const node_view&, const std::vector<T>&, template <typename T>);
 
 
 
        TOML_NODISCARD
        node_view operator[](std::string_view key) const noexcept
        {
            if (auto tbl = this->as_table())
                return node_view{ tbl->get(key) };
            return {};
        }
 
        TOML_NODISCARD
        node_view operator[](const toml::path& path) const noexcept
        {
            return node_ ? node_->at_path(path) : node_view{};
        }
 
        TOML_NODISCARD
        node_view at_path(std::string_view path) const noexcept
        {
            return node_ ? node_->at_path(path) : node_view{};
        }
 
        TOML_NODISCARD
        node_view at_path(const toml::path& path) const noexcept
        {
            return node_ ? node_->at_path(path) : node_view{};
        }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
        TOML_NODISCARD
        node_view operator[](std::wstring_view key) const
        {
            if (auto tbl = this->as_table())
                return node_view{ tbl->get(key) };
            return {};
        }
 
        TOML_NODISCARD
        node_view at_path(std::wstring_view path) const
        {
            return node_ ? node_->at_path(path) : node_view{};
        }
 
#endif // TOML_ENABLE_WINDOWS_COMPAT
 
        TOML_NODISCARD
        node_view operator[](size_t index) const noexcept
        {
            if (auto arr = this->as_array())
                return node_view{ arr->get(index) };
            return {};
        }
 
 
#if TOML_ENABLE_FORMATTERS
 
        friend std::ostream& operator<<(std::ostream& os, const node_view& nv)
        {
            if (nv.node_)
                nv.node_->visit([&os](const auto& n) { os << n; });
            return os;
        }
 
#endif
    };
 
 
    template <typename T>
    node_view(const T&) -> node_view<const node>;
 
    template <typename T>
    node_view(const T*) -> node_view<const node>;
 
    template <typename T>
    node_view(T&) -> node_view<node>;
 
    template <typename T>
    node_view(T*) -> node_view<node>;
 
}
TOML_NAMESPACE_END;
 
TOML_NAMESPACE_START
{
    inline node::operator node_view<node>() noexcept
    {
        return node_view<node>{ this };
    }
 
    inline node::operator node_view<const node>() const noexcept
    {
        return node_view<const node>{ this };
    }
}
TOML_NAMESPACE_END;
 
#include "header_end.hpp"