array.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_utility.hpp"
#include "std_vector.hpp"
#include "std_initializer_list.hpp"
#include "value.hpp"
#include "make_node.hpp"
#include "header_start.hpp"
 
#ifndef TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN
#if TOML_GCC && TOML_GCC <= 7
#define TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN 1
#else
#define TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN 0
#endif
#endif
 
#if TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN && !defined(TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_ACKNOWLEDGED)
#define TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_MESSAGE                                                                  \
    "If you're seeing this error it's because you're using one of toml++'s for_each() functions on a compiler with "   \
    "known bugs in that area (e.g. GCC 7). On these compilers returning a bool (or bool-convertible) value from the "  \
    "for_each() callable causes spurious compilation failures, while returning nothing (void) works fine. "            \
    "If you believe this message is incorrect for your compiler, you can try your luck by #defining "                  \
    "TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN as 0 and recompiling - if it works, great! Let me know at "                 \
    "https://github.com/marzer/tomlplusplus/issues. Alternatively, if you don't have any need for early-exiting from " \
    "for_each(), you can suppress this error by #defining TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_ACKNOWLEDGED "         \
    "and moving on with your life."
#endif
 
TOML_IMPL_NAMESPACE_START
{
    template <bool IsConst>
    class TOML_TRIVIAL_ABI array_iterator
    {
      private:
        template <bool>
        friend class array_iterator;
 
        using mutable_vector_iterator = std::vector<node_ptr>::iterator;
        using const_vector_iterator   = std::vector<node_ptr>::const_iterator;
        using vector_iterator         = std::conditional_t<IsConst, const_vector_iterator, mutable_vector_iterator>;
 
        mutable vector_iterator iter_;
 
      public:
        using value_type        = std::conditional_t<IsConst, const node, node>;
        using reference         = value_type&;
        using pointer           = value_type*;
        using difference_type   = ptrdiff_t;
        using iterator_category = typename std::iterator_traits<vector_iterator>::iterator_category;
 
        TOML_NODISCARD_CTOR
        array_iterator() noexcept = default;
 
        TOML_NODISCARD_CTOR
        explicit array_iterator(mutable_vector_iterator iter) noexcept //
            : iter_{ iter }
        {}
 
        TOML_CONSTRAINED_TEMPLATE(C, bool C = IsConst)
        TOML_NODISCARD_CTOR
        explicit array_iterator(const_vector_iterator iter) noexcept //
            : iter_{ iter }
        {}
 
        TOML_CONSTRAINED_TEMPLATE(C, bool C = IsConst)
        TOML_NODISCARD_CTOR
        array_iterator(const array_iterator<false>& other) noexcept //
            : iter_{ other.iter_ }
        {}
 
        TOML_NODISCARD_CTOR
        array_iterator(const array_iterator&) noexcept = default;
 
        array_iterator& operator=(const array_iterator&) noexcept = default;
 
        array_iterator& operator++() noexcept // ++pre
        {
            ++iter_;
            return *this;
        }
 
        array_iterator operator++(int) noexcept // post++
        {
            array_iterator out{ iter_ };
            ++iter_;
            return out;
        }
 
        array_iterator& operator--() noexcept // --pre
        {
            --iter_;
            return *this;
        }
 
        array_iterator operator--(int) noexcept // post--
        {
            array_iterator out{ iter_ };
            --iter_;
            return out;
        }
 
        TOML_PURE_INLINE_GETTER
        reference operator*() const noexcept
        {
            return *iter_->get();
        }
 
        TOML_PURE_INLINE_GETTER
        pointer operator->() const noexcept
        {
            return iter_->get();
        }
 
        TOML_PURE_INLINE_GETTER
        explicit operator const vector_iterator&() const noexcept
        {
            return iter_;
        }
 
        TOML_CONSTRAINED_TEMPLATE(!C, bool C = IsConst)
        TOML_PURE_INLINE_GETTER
        explicit operator const const_vector_iterator() const noexcept
        {
            return iter_;
        }
 
        array_iterator& operator+=(ptrdiff_t rhs) noexcept
        {
            iter_ += rhs;
            return *this;
        }
 
        array_iterator& operator-=(ptrdiff_t rhs) noexcept
        {
            iter_ -= rhs;
            return *this;
        }
 
        TOML_NODISCARD
        friend array_iterator operator+(const array_iterator& lhs, ptrdiff_t rhs) noexcept
        {
            return array_iterator{ lhs.iter_ + rhs };
        }
 
        TOML_NODISCARD
        friend array_iterator operator+(ptrdiff_t lhs, const array_iterator& rhs) noexcept
        {
            return array_iterator{ rhs.iter_ + lhs };
        }
 
        TOML_NODISCARD
        friend array_iterator operator-(const array_iterator& lhs, ptrdiff_t rhs) noexcept
        {
            return array_iterator{ lhs.iter_ - rhs };
        }
 
        TOML_PURE_INLINE_GETTER
        friend ptrdiff_t operator-(const array_iterator& lhs, const array_iterator& rhs) noexcept
        {
            return lhs.iter_ - rhs.iter_;
        }
 
        TOML_PURE_INLINE_GETTER
        friend bool operator==(const array_iterator& lhs, const array_iterator& rhs) noexcept
        {
            return lhs.iter_ == rhs.iter_;
        }
 
        TOML_PURE_INLINE_GETTER
        friend bool operator!=(const array_iterator& lhs, const array_iterator& rhs) noexcept
        {
            return lhs.iter_ != rhs.iter_;
        }
 
        TOML_PURE_INLINE_GETTER
        friend bool operator<(const array_iterator& lhs, const array_iterator& rhs) noexcept
        {
            return lhs.iter_ < rhs.iter_;
        }
 
        TOML_PURE_INLINE_GETTER
        friend bool operator<=(const array_iterator& lhs, const array_iterator& rhs) noexcept
        {
            return lhs.iter_ <= rhs.iter_;
        }
 
        TOML_PURE_INLINE_GETTER
        friend bool operator>(const array_iterator& lhs, const array_iterator& rhs) noexcept
        {
            return lhs.iter_ > rhs.iter_;
        }
 
        TOML_PURE_INLINE_GETTER
        friend bool operator>=(const array_iterator& lhs, const array_iterator& rhs) noexcept
        {
            return lhs.iter_ >= rhs.iter_;
        }
 
        TOML_PURE_INLINE_GETTER
        reference operator[](ptrdiff_t idx) const noexcept
        {
            return *(iter_ + idx)->get();
        }
    };
 
    struct array_init_elem
    {
        mutable node_ptr value;
 
        template <typename T>
        TOML_NODISCARD_CTOR
        array_init_elem(T&& val, value_flags flags = preserve_source_value_flags) //
            : value{ make_node(static_cast<T&&>(val), flags) }
        {}
    };
}
TOML_IMPL_NAMESPACE_END;
 
TOML_NAMESPACE_START
{
    using array_iterator = POXY_IMPLEMENTATION_DETAIL(impl::array_iterator<false>);
 
    using const_array_iterator = POXY_IMPLEMENTATION_DETAIL(impl::array_iterator<true>);
 
    class TOML_EXPORTED_CLASS array : public node
    {
      private:
 
        using vector_type           = std::vector<impl::node_ptr>;
        using vector_iterator       = typename vector_type::iterator;
        using const_vector_iterator = typename vector_type::const_iterator;
        vector_type elems_;
 
        TOML_NODISCARD_CTOR
        TOML_EXPORTED_MEMBER_FUNCTION
        array(const impl::array_init_elem*, const impl::array_init_elem*);
 
        TOML_NODISCARD_CTOR
        array(std::false_type, std::initializer_list<impl::array_init_elem> elems) //
            : array{ elems.begin(), elems.end() }
        {}
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void preinsertion_resize(size_t idx, size_t count);
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void insert_at_back(impl::node_ptr&&);
 
        TOML_EXPORTED_MEMBER_FUNCTION
        vector_iterator insert_at(const_vector_iterator, impl::node_ptr&&);
 
        template <typename T>
        void emplace_back_if_not_empty_view(T&& val, value_flags flags)
        {
            if constexpr (is_node_view<T>)
            {
                if (!val)
                    return;
            }
            insert_at_back(impl::make_node(static_cast<T&&>(val), flags));
        }
 
        TOML_NODISCARD
        TOML_EXPORTED_MEMBER_FUNCTION
        size_t total_leaf_count() const noexcept;
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void flatten_child(array&& child, size_t& dest_index) noexcept;
 
 
      public:
        using value_type      = node;
        using size_type       = size_t;
        using difference_type = ptrdiff_t;
        using reference       = node&;
        using const_reference = const node&;
 
        TOML_NODISCARD_CTOR
        TOML_EXPORTED_MEMBER_FUNCTION
        array() noexcept;
 
        TOML_EXPORTED_MEMBER_FUNCTION
        ~array() noexcept;
 
        TOML_NODISCARD_CTOR
        TOML_EXPORTED_MEMBER_FUNCTION
        array(const array&);
 
        TOML_NODISCARD_CTOR
        TOML_EXPORTED_MEMBER_FUNCTION
        array(array&& other) noexcept;
 
        TOML_CONSTRAINED_TEMPLATE((sizeof...(ElemTypes) > 0 || !std::is_same_v<impl::remove_cvref<ElemType>, array>),
                                  typename ElemType,
                                  typename... ElemTypes)
        TOML_NODISCARD_CTOR
        explicit array(ElemType&& val, ElemTypes&&... vals)
            : array{ std::false_type{},
                     std::initializer_list<impl::array_init_elem>{ static_cast<ElemType&&>(val),
                                                                   static_cast<ElemTypes&&>(vals)... } }
        {}
 
        TOML_EXPORTED_MEMBER_FUNCTION
        array& operator=(const array&);
 
        TOML_EXPORTED_MEMBER_FUNCTION
        array& operator=(array&& rhs) noexcept;
 
 
        TOML_CONST_INLINE_GETTER
        node_type type() const noexcept final
        {
            return node_type::array;
        }
 
        TOML_PURE_GETTER
        TOML_EXPORTED_MEMBER_FUNCTION
        bool is_homogeneous(node_type ntype) const noexcept final;
 
        TOML_PURE_GETTER
        TOML_EXPORTED_MEMBER_FUNCTION
        bool is_homogeneous(node_type ntype, node*& first_nonmatch) noexcept final;
 
        TOML_PURE_GETTER
        TOML_EXPORTED_MEMBER_FUNCTION
        bool is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept final;
 
        template <typename ElemType = void>
        TOML_PURE_GETTER
        bool is_homogeneous() const noexcept
        {
            using type = impl::remove_cvref<impl::unwrap_node<ElemType>>;
            static_assert(std::is_void_v<type> || toml::is_value<type> || toml::is_container<type>,
                          "The template type argument of array::is_homogeneous() must be void or one "
                          "of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
 
            return is_homogeneous(impl::node_type_of<type>);
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_table() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_array() const noexcept final
        {
            return true;
        }
 
        TOML_PURE_GETTER
        bool is_array_of_tables() const noexcept final
        {
            return is_homogeneous(node_type::table);
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_value() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_string() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_integer() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_floating_point() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_number() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_boolean() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_date() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_time() const noexcept final
        {
            return false;
        }
 
        TOML_CONST_INLINE_GETTER
        bool is_date_time() const noexcept final
        {
            return false;
        }
 
 
 
        TOML_CONST_INLINE_GETTER
        table* as_table() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        array* as_array() noexcept final
        {
            return this;
        }
 
        TOML_CONST_INLINE_GETTER
        toml::value<std::string>* as_string() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        toml::value<int64_t>* as_integer() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        toml::value<double>* as_floating_point() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        toml::value<bool>* as_boolean() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        toml::value<date>* as_date() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        toml::value<time>* as_time() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        toml::value<date_time>* as_date_time() noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const table* as_table() const noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const array* as_array() const noexcept final
        {
            return this;
        }
 
        TOML_CONST_INLINE_GETTER
        const toml::value<std::string>* as_string() const noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const toml::value<int64_t>* as_integer() const noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const toml::value<double>* as_floating_point() const noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const toml::value<bool>* as_boolean() const noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const toml::value<date>* as_date() const noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const toml::value<time>* as_time() const noexcept final
        {
            return nullptr;
        }
 
        TOML_CONST_INLINE_GETTER
        const toml::value<date_time>* as_date_time() const noexcept final
        {
            return nullptr;
        }
 
 
 
        TOML_PURE_INLINE_GETTER
        node* get(size_t index) noexcept
        {
            return index < elems_.size() ? elems_[index].get() : nullptr;
        }
 
        TOML_PURE_INLINE_GETTER
        const node* get(size_t index) const noexcept
        {
            return const_cast<array&>(*this).get(index);
        }
 
        template <typename ElemType>
        TOML_NODISCARD
        impl::wrap_node<ElemType>* get_as(size_t index) noexcept
        {
            if (auto val = get(index))
                return val->template as<ElemType>();
            return nullptr;
        }
 
        template <typename ElemType>
        TOML_NODISCARD
        const impl::wrap_node<ElemType>* get_as(size_t index) const noexcept
        {
            return const_cast<array&>(*this).template get_as<ElemType>(index);
        }
 
        using node::operator[]; // inherit operator[toml::path]
 
        TOML_NODISCARD
        node& operator[](size_t index) noexcept
        {
            return *elems_[index];
        }
 
        TOML_NODISCARD
        const node& operator[](size_t index) const noexcept
        {
            return *elems_[index];
        }
 
        TOML_NODISCARD
        TOML_EXPORTED_MEMBER_FUNCTION
        node& at(size_t index);
 
        TOML_NODISCARD
        const node& at(size_t index) const
        {
            return const_cast<array&>(*this).at(index);
        }
 
        TOML_NODISCARD
        node& front() noexcept
        {
            return *elems_.front();
        }
 
        TOML_NODISCARD
        const node& front() const noexcept
        {
            return *elems_.front();
        }
 
        TOML_NODISCARD
        node& back() noexcept
        {
            return *elems_.back();
        }
 
        TOML_NODISCARD
        const node& back() const noexcept
        {
            return *elems_.back();
        }
 
 
 
        using iterator = array_iterator;
 
        using const_iterator = const_array_iterator;
 
        TOML_NODISCARD
        iterator begin() noexcept
        {
            return iterator{ elems_.begin() };
        }
 
        TOML_NODISCARD
        const_iterator begin() const noexcept
        {
            return const_iterator{ elems_.cbegin() };
        }
 
        TOML_NODISCARD
        const_iterator cbegin() const noexcept
        {
            return const_iterator{ elems_.cbegin() };
        }
 
        TOML_NODISCARD
        iterator end() noexcept
        {
            return iterator{ elems_.end() };
        }
 
        TOML_NODISCARD
        const_iterator end() const noexcept
        {
            return const_iterator{ elems_.cend() };
        }
 
        TOML_NODISCARD
        const_iterator cend() const noexcept
        {
            return const_iterator{ elems_.cend() };
        }
 
      private:
 
        template <typename T, typename Array>
        using for_each_elem_ref = impl::copy_cvref<impl::wrap_node<impl::remove_cvref<impl::unwrap_node<T>>>, Array>;
 
        template <typename Func, typename Array, typename T>
        using can_for_each = std::disjunction<std::is_invocable<Func, for_each_elem_ref<T, Array>, size_t>,
                                              std::is_invocable<Func, size_t, for_each_elem_ref<T, Array>>,
                                              std::is_invocable<Func, for_each_elem_ref<T, Array>>>;
 
        template <typename Func, typename Array, typename T>
        using can_for_each_nothrow = std::conditional_t<
            // first form
            std::is_invocable_v<Func, for_each_elem_ref<T, Array>, size_t>,
            std::is_nothrow_invocable<Func, for_each_elem_ref<T, Array>, size_t>,
            std::conditional_t<
                // second form
                std::is_invocable_v<Func, size_t, for_each_elem_ref<T, Array>>,
                std::is_nothrow_invocable<Func, size_t, for_each_elem_ref<T, Array>>,
                std::conditional_t<
                    // third form
                    std::is_invocable_v<Func, for_each_elem_ref<T, Array>>,
                    std::is_nothrow_invocable<Func, for_each_elem_ref<T, Array>>,
                    std::false_type>>>;
 
        template <typename Func, typename Array>
        using can_for_each_any = std::disjunction<can_for_each<Func, Array, table>,
                                                  can_for_each<Func, Array, array>,
                                                  can_for_each<Func, Array, std::string>,
                                                  can_for_each<Func, Array, int64_t>,
                                                  can_for_each<Func, Array, double>,
                                                  can_for_each<Func, Array, bool>,
                                                  can_for_each<Func, Array, date>,
                                                  can_for_each<Func, Array, time>,
                                                  can_for_each<Func, Array, date_time>>;
 
        template <typename Func, typename Array, typename T>
        using for_each_is_nothrow_one = std::disjunction<std::negation<can_for_each<Func, Array, T>>, //
                                                         can_for_each_nothrow<Func, Array, T>>;
 
        template <typename Func, typename Array>
        using for_each_is_nothrow = std::conjunction<for_each_is_nothrow_one<Func, Array, table>,
                                                     for_each_is_nothrow_one<Func, Array, array>,
                                                     for_each_is_nothrow_one<Func, Array, std::string>,
                                                     for_each_is_nothrow_one<Func, Array, int64_t>,
                                                     for_each_is_nothrow_one<Func, Array, double>,
                                                     for_each_is_nothrow_one<Func, Array, bool>,
                                                     for_each_is_nothrow_one<Func, Array, date>,
                                                     for_each_is_nothrow_one<Func, Array, time>,
                                                     for_each_is_nothrow_one<Func, Array, date_time>>;
 
        template <typename Func, typename Array>
        static void do_for_each(Func&& visitor, Array&& arr) //
            noexcept(for_each_is_nothrow<Func&&, Array&&>::value)
        {
            static_assert(can_for_each_any<Func&&, Array&&>::value,
                          "TOML array for_each visitors must be invocable for at least one of the toml::node "
                          "specializations:" TOML_SA_NODE_TYPE_LIST);
 
            for (size_t i = 0; i < arr.size(); i++)
            {
                using node_ref = impl::copy_cvref<toml::node, Array&&>;
                static_assert(std::is_reference_v<node_ref>);
 
#if TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN
 
#ifndef TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_ACKNOWLEDGED
                static_assert(impl::always_false<Func, Array, node_ref>, //
                              TOML_RETURN_BOOL_FROM_FOR_EACH_BROKEN_MESSAGE);
#endif
 
                static_cast<node_ref>(static_cast<Array&&>(arr)[i])
                    .visit(
                        [&]([[maybe_unused]] auto&& elem) //
                        noexcept(for_each_is_nothrow_one<Func&&, Array&&, decltype(elem)>::value)
                        {
                            using elem_ref = for_each_elem_ref<decltype(elem), Array&&>;
                            static_assert(std::is_reference_v<elem_ref>);
 
                            // func(elem, i)
                            if constexpr (std::is_invocable_v<Func&&, elem_ref, size_t>)
                            {
                                static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i);
                            }
 
                            // func(i, elem)
                            else if constexpr (std::is_invocable_v<Func&&, size_t, elem_ref>)
                            {
                                static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem));
                            }
 
                            // func(elem)
                            else if constexpr (std::is_invocable_v<Func&&, elem_ref>)
                            {
                                static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem));
                            }
                        });
 
#else
                const auto keep_going =
                    static_cast<node_ref>(static_cast<Array&&>(arr)[i])
                        .visit(
                            [&]([[maybe_unused]] auto&& elem) //
                            noexcept(for_each_is_nothrow_one<Func&&, Array&&, decltype(elem)>::value)
                            {
                                using elem_ref = for_each_elem_ref<decltype(elem), Array&&>;
                                static_assert(std::is_reference_v<elem_ref>);
 
                                // func(elem, i)
                                if constexpr (std::is_invocable_v<Func&&, elem_ref, size_t>)
                                {
                                    using return_type =
                                        decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
 
                                    if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
                                    {
                                        return static_cast<bool>(
                                            static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
                                    }
                                    else
                                    {
                                        static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i);
                                        return true;
                                    }
                                }
 
                                // func(i, elem)
                                else if constexpr (std::is_invocable_v<Func&&, size_t, elem_ref>)
                                {
                                    using return_type =
                                        decltype(static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
 
                                    if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
                                    {
                                        return static_cast<bool>(
                                            static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
                                    }
                                    else
                                    {
                                        static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem));
                                        return true;
                                    }
                                }
 
                                // func(elem)
                                else if constexpr (std::is_invocable_v<Func&&, elem_ref>)
                                {
                                    using return_type =
                                        decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
 
                                    if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
                                    {
                                        return static_cast<bool>(
                                            static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
                                    }
                                    else
                                    {
                                        static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem));
                                        return true;
                                    }
                                }
 
                                // visitor not compatible with this particular type
                                else
                                    return true;
                            });
 
                if (!keep_going)
                    return;
#endif
            }
        }
 
 
      public:
        template <typename Func>
        array& for_each(Func&& visitor) & //
            noexcept(for_each_is_nothrow<Func&&, array&>::value)
        {
            do_for_each(static_cast<Func&&>(visitor), *this);
            return *this;
        }
 
        template <typename Func>
        array&& for_each(Func&& visitor) && //
            noexcept(for_each_is_nothrow<Func&&, array&&>::value)
        {
            do_for_each(static_cast<Func&&>(visitor), static_cast<array&&>(*this));
            return static_cast<array&&>(*this);
        }
 
        template <typename Func>
        const array& for_each(Func&& visitor) const& //
            noexcept(for_each_is_nothrow<Func&&, const array&>::value)
        {
            do_for_each(static_cast<Func&&>(visitor), *this);
            return *this;
        }
 
        template <typename Func>
        const array&& for_each(Func&& visitor) const&& //
            noexcept(for_each_is_nothrow<Func&&, const array&&>::value)
        {
            do_for_each(static_cast<Func&&>(visitor), static_cast<const array&&>(*this));
            return static_cast<const array&&>(*this);
        }
 
 
 
        TOML_NODISCARD
        bool empty() const noexcept
        {
            return elems_.empty();
        }
 
        TOML_NODISCARD
        size_t size() const noexcept
        {
            return elems_.size();
        }
 
        TOML_NODISCARD
        size_t max_size() const noexcept
        {
            return elems_.max_size();
        }
 
        TOML_NODISCARD
        size_t capacity() const noexcept
        {
            return elems_.capacity();
        }
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void reserve(size_t new_capacity);
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void shrink_to_fit();
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void truncate(size_t new_size);
 
        template <typename ElemType>
        void resize(size_t new_size,
                    ElemType&& default_init_val,
                    value_flags default_init_flags = preserve_source_value_flags)
        {
            static_assert(!is_node_view<ElemType>,
                          "The default element type argument to toml::array::resize may not be toml::node_view.");
 
            if (!new_size)
                clear();
            else if (new_size > elems_.size())
                insert(cend(), new_size - elems_.size(), static_cast<ElemType&&>(default_init_val), default_init_flags);
            else
                truncate(new_size);
        }
 
 
 
        TOML_EXPORTED_MEMBER_FUNCTION
        iterator erase(const_iterator pos) noexcept;
 
        TOML_EXPORTED_MEMBER_FUNCTION
        iterator erase(const_iterator first, const_iterator last) noexcept;
 
        TOML_EXPORTED_MEMBER_FUNCTION
        array& flatten() &;
 
        array&& flatten() &&
        {
            return static_cast<toml::array&&>(this->flatten());
        }
 
        TOML_EXPORTED_MEMBER_FUNCTION
        array& prune(bool recursive = true) & noexcept;
 
        array&& prune(bool recursive = true) && noexcept
        {
            return static_cast<toml::array&&>(this->prune(recursive));
        }
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void pop_back() noexcept;
 
        TOML_EXPORTED_MEMBER_FUNCTION
        void clear() noexcept;
 
 
 
        template <typename ElemType>
        iterator insert(const_iterator pos, ElemType&& val, value_flags flags = preserve_source_value_flags)
        {
            if constexpr (is_node_view<ElemType>)
            {
                if (!val)
                    return end();
            }
            return iterator{ insert_at(const_vector_iterator{ pos },
                                       impl::make_node(static_cast<ElemType&&>(val), flags)) };
        }
 
        template <typename ElemType>
        iterator insert(const_iterator pos,
                        size_t count,
                        ElemType&& val,
                        value_flags flags = preserve_source_value_flags)
        {
            if constexpr (is_node_view<ElemType>)
            {
                if (!val)
                    return end();
            }
            switch (count)
            {
                case 0: return iterator{ elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin()) };
                case 1: return insert(pos, static_cast<ElemType&&>(val), flags);
                default:
                {
                    const auto start_idx = static_cast<size_t>(const_vector_iterator{ pos } - elems_.cbegin());
                    preinsertion_resize(start_idx, count);
                    size_t i = start_idx;
                    for (size_t e = start_idx + count - 1u; i < e; i++)
                        elems_[i] = impl::make_node(val, flags);
 
                    //# potentially move the initial value into the last element
                    elems_[i] = impl::make_node(static_cast<ElemType&&>(val), flags);
                    return iterator{ elems_.begin() + static_cast<ptrdiff_t>(start_idx) };
                }
            }
        }
 
        template <typename Iter>
        iterator insert(const_iterator pos, Iter first, Iter last, value_flags flags = preserve_source_value_flags)
        {
            const auto distance = std::distance(first, last);
            if (distance <= 0)
                return iterator{ elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin()) };
            else
            {
                auto count       = distance;
                using deref_type = decltype(*first);
                if constexpr (is_node_view<deref_type>)
                {
                    for (auto it = first; it != last; it++)
                        if (!(*it))
                            count--;
                    if (!count)
                        return iterator{ elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin()) };
                }
                const auto start_idx = static_cast<size_t>(const_vector_iterator{ pos } - elems_.cbegin());
                preinsertion_resize(start_idx, static_cast<size_t>(count));
                size_t i = start_idx;
                for (auto it = first; it != last; it++)
                {
                    if constexpr (is_node_view<deref_type>)
                    {
                        if (!(*it))
                            continue;
                    }
                    if constexpr (std::is_rvalue_reference_v<deref_type>)
                        elems_[i++] = impl::make_node(std::move(*it), flags);
                    else
                        elems_[i++] = impl::make_node(*it, flags);
                }
                return iterator{ elems_.begin() + static_cast<ptrdiff_t>(start_idx) };
            }
        }
 
        template <typename ElemType>
        iterator insert(const_iterator pos,
                        std::initializer_list<ElemType> ilist,
                        value_flags flags = preserve_source_value_flags)
        {
            return insert(pos, ilist.begin(), ilist.end(), flags);
        }
 
        template <typename ElemType = void, typename... Args>
        iterator emplace(const_iterator pos, Args&&... args)
        {
            using raw_elem_type = impl::remove_cvref<ElemType>;
            using elem_type     = std::conditional_t<std::is_void_v<raw_elem_type>, //
                                                 impl::emplaced_type_of<Args&&...>,
                                                 raw_elem_type>;
 
            using type = impl::remove_cvref<impl::unwrap_node<elem_type>>;
            static_assert(impl::is_native<type> || impl::is_one_of<type, table, array>,
                          "Emplacement type parameter must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
 
            return iterator{ insert_at(const_vector_iterator{ pos },
                                       impl::node_ptr{ new impl::wrap_node<type>{ static_cast<Args&&>(args)... } }) };
        }
 
        template <typename ElemType>
        iterator replace(const_iterator pos, ElemType&& val, value_flags flags = preserve_source_value_flags)
        {
            TOML_ASSERT(pos >= cbegin() && pos < cend());
 
            if constexpr (is_node_view<ElemType>)
            {
                if (!val)
                    return end();
            }
 
            const auto it = elems_.begin() + (const_vector_iterator{ pos } - elems_.cbegin());
            *it           = impl::make_node(static_cast<ElemType&&>(val), flags);
            return iterator{ it };
        }
 
        template <typename ElemType>
        void push_back(ElemType&& val, value_flags flags = preserve_source_value_flags)
        {
            emplace_back_if_not_empty_view(static_cast<ElemType&&>(val), flags);
        }
 
        template <typename ElemType = void, typename... Args>
        decltype(auto) emplace_back(Args&&... args)
        {
            using raw_elem_type = impl::remove_cvref<ElemType>;
            using elem_type     = std::conditional_t<std::is_void_v<raw_elem_type>, //
                                                 impl::emplaced_type_of<Args&&...>,
                                                 raw_elem_type>;
 
            static constexpr auto moving_node_ptr = std::is_same_v<elem_type, impl::node_ptr> //
                                                 && sizeof...(Args) == 1u                     //
                                                 && impl::first_is_same<impl::node_ptr&&, Args&&...>;
 
            using unwrapped_type = impl::remove_cvref<impl::unwrap_node<elem_type>>;
 
            static_assert(
                moving_node_ptr                                       //
                    || impl::is_native<unwrapped_type>                //
                    || impl::is_one_of<unwrapped_type, table, array>, //
                "ElemType argument of array::emplace_back() must be one of:" TOML_SA_UNWRAPPED_NODE_TYPE_LIST);
 
            if constexpr (moving_node_ptr)
            {
                insert_at_back(static_cast<Args&&>(args)...);
                return *elems_.back();
            }
            else
            {
                auto ptr = new impl::wrap_node<unwrapped_type>{ static_cast<Args&&>(args)... };
                insert_at_back(impl::node_ptr{ ptr });
                return *ptr;
            }
        }
 
 
      private:
 
        TOML_NODISCARD
        TOML_EXPORTED_STATIC_FUNCTION
        static bool TOML_CALLCONV equal(const array&, const array&) noexcept;
 
        template <typename T>
        TOML_NODISCARD
        static bool equal_to_container(const array& lhs, const T& rhs) noexcept
        {
            using element_type = std::remove_const_t<typename T::value_type>;
            static_assert(impl::is_losslessly_convertible_to_native<element_type>,
                          "Container element type must be losslessly convertible one of the native TOML value types");
 
            if (lhs.size() != rhs.size())
                return false;
            if (rhs.size() == 0u)
                return true;
 
            size_t i{};
            for (auto& list_elem : rhs)
            {
                const auto elem = lhs.get_as<impl::native_type_of<element_type>>(i++);
                if (!elem || *elem != list_elem)
                    return false;
            }
 
            return true;
        }
 
 
      public:
 
        TOML_NODISCARD
        friend bool operator==(const array& lhs, const array& rhs) noexcept
        {
            return equal(lhs, rhs);
        }
 
        TOML_NODISCARD
        friend bool operator!=(const array& lhs, const array& rhs) noexcept
        {
            return !equal(lhs, rhs);
        }
 
        template <typename T>
        TOML_NODISCARD
        friend bool operator==(const array& lhs, const std::initializer_list<T>& rhs) noexcept
        {
            return equal_to_container(lhs, rhs);
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const array&, const std::initializer_list<T>&, template <typename T>);
 
        template <typename T>
        TOML_NODISCARD
        friend bool operator==(const array& lhs, const std::vector<T>& rhs) noexcept
        {
            return equal_to_container(lhs, rhs);
        }
        TOML_ASYMMETRICAL_EQUALITY_OPS(const array&, const std::vector<T>&, template <typename T>);
 
 
#if TOML_ENABLE_FORMATTERS
 
        friend std::ostream& operator<<(std::ostream& lhs, const array& rhs)
        {
            impl::print_to_stream(lhs, rhs);
            return lhs;
        }
 
#endif
    };
}
TOML_NAMESPACE_END;
 
#include "header_end.hpp"