make_node.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 "forward_declarations.hpp"
#include "header_start.hpp"
 
TOML_IMPL_NAMESPACE_START
{
    template <typename T>
    TOML_NODISCARD
    TOML_ATTR(returns_nonnull)
    auto* make_node_impl_specialized(T && val, [[maybe_unused]] value_flags flags)
    {
        using unwrapped_type = unwrap_node<remove_cvref<T>>;
        static_assert(!std::is_same_v<unwrapped_type, node>);
        static_assert(!is_node_view<unwrapped_type>);
 
        // arrays + tables - invoke copy/move ctor
        if constexpr (is_one_of<unwrapped_type, array, table>)
        {
            return new unwrapped_type(static_cast<T&&>(val));
        }
 
        // values
        else
        {
            using native_type = native_type_of<unwrapped_type>;
            using value_type  = value<native_type>;
 
            value_type* out;
 
            // copy/move ctor
            if constexpr (std::is_same_v<remove_cvref<T>, value_type>)
            {
                out = new value_type{ static_cast<T&&>(val), flags };
            }
 
            // creating from raw value
            else
            {
                static_assert(!is_wide_string<T> || TOML_ENABLE_WINDOWS_COMPAT,
                              "Instantiating values from wide-character strings is only "
                              "supported on Windows with TOML_ENABLE_WINDOWS_COMPAT enabled.");
 
                if constexpr (!is_losslessly_convertible_to_native<unwrapped_type>)
                {
                    if constexpr (std::is_same_v<native_type, int64_t>)
                        static_assert(always_false<T>,
                                      "Integral value initializers must be losslessly convertible to int64_t");
                    else if constexpr (std::is_same_v<native_type, double>)
                        static_assert(always_false<T>,
                                      "Floating-point value initializers must be losslessly convertible to double");
                    else
                        static_assert(
                            always_false<T>,
                            "Value initializers must be losslessly convertible to one of the TOML value types");
                }
 
                if constexpr (is_wide_string<T>)
                {
#if TOML_ENABLE_WINDOWS_COMPAT
                    out = new value_type{ narrow(static_cast<T&&>(val)) };
#else
                    static_assert(always_false<T>, "Evaluated unreachable branch!");
#endif
                }
                else
                    out = new value_type{ static_cast<T&&>(val) };
 
                if (flags != preserve_source_value_flags)
                    out->flags(flags);
            }
 
            return out;
        }
    }
 
    template <typename T>
    TOML_NODISCARD
    auto* make_node_impl(T && val, value_flags flags = preserve_source_value_flags)
    {
        using unwrapped_type = unwrap_node<remove_cvref<T>>;
        if constexpr (std::is_same_v<unwrapped_type, node> || is_node_view<unwrapped_type>)
        {
            if constexpr (is_node_view<unwrapped_type>)
            {
                if (!val)
                    return static_cast<toml::node*>(nullptr);
            }
 
            return static_cast<T&&>(val).visit(
                [flags](auto&& concrete) {
                    return static_cast<toml::node*>(
                        make_node_impl_specialized(static_cast<decltype(concrete)&&>(concrete), flags));
                });
        }
        else
            return make_node_impl_specialized(static_cast<T&&>(val), flags);
    }
 
    template <typename T>
    TOML_NODISCARD
    auto* make_node_impl(inserter<T> && val, value_flags flags = preserve_source_value_flags)
    {
        return make_node_impl(static_cast<T&&>(val.value), flags);
    }
 
    template <typename T, bool = (is_node<T> || is_node_view<T> || is_value<T> || can_partially_represent_native<T>)>
    struct inserted_type_of_
    {
        using type = std::remove_pointer_t<decltype(make_node_impl(std::declval<T>()))>;
    };
 
    template <typename T>
    struct inserted_type_of_<inserter<T>, false>
    {
        using type = typename inserted_type_of_<remove_cvref<T>>::type;
    };
 
    template <typename T>
    struct inserted_type_of_<T, false>
    {
        using type = void;
    };
 
    template <typename T>
    TOML_NODISCARD
    node_ptr make_node(T && val, value_flags flags = preserve_source_value_flags)
    {
        return node_ptr{ make_node_impl(static_cast<T&&>(val), flags) };
    }
 
    template <typename... T>
    struct emplaced_type_of_
    {
        using type = void;
    };
 
    template <typename T>
    struct emplaced_type_of_<T>
    {
        using type = std::conditional_t<is_one_of<T, node, node_view<node>, node_view<const node>>,
                                        void,
                                        typename inserted_type_of_<T>::type>;
    };
 
    template <typename T>
    struct emplaced_type_of_<inserter<T>>
    {
        using type = typename emplaced_type_of_<remove_cvref<T>>::type;
    };
 
    template <typename... T>
    using emplaced_type_of = typename emplaced_type_of_<remove_cvref<T>...>::type;
}
TOML_IMPL_NAMESPACE_END;
 
TOML_NAMESPACE_START
{
    template <typename T>
    using inserted_type_of = POXY_IMPLEMENTATION_DETAIL(typename impl::inserted_type_of_<impl::remove_cvref<T>>::type);
}
TOML_NAMESPACE_END;
 
#include "header_end.hpp"