Diff coverage report for

//

//

// Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/cppalliance/http

// Official repository: https://github.com/cppalliance/http

//

//

#ifndef BOOST_HTTP_POLYSTORE_HPP

#ifndef BOOST_HTTP_POLYSTORE_HPP

#define BOOST_HTTP_POLYSTORE_HPP

#define BOOST_HTTP_POLYSTORE_HPP

#include <boost/http/detail/config.hpp>

#include <boost/http/detail/config.hpp>

#include <boost/http/detail/except.hpp>

#include <boost/http/detail/except.hpp>

#include <boost/core/typeinfo.hpp>

#include <boost/core/typeinfo.hpp>

#include <boost/core/detail/static_assert.hpp>

#include <boost/core/detail/static_assert.hpp>

#include <cstring>

#include <cstring>

#include <memory>

#include <memory>

#include <type_traits>

#include <type_traits>

#include <unordered_map>

#include <unordered_map>

#include <vector>

#include <vector>

#if ! defined( BOOST_NO_TYPEID )

#if ! defined( BOOST_NO_TYPEID )

#include <typeindex>

#include <typeindex>

#endif

#endif

namespace boost {

namespace boost {

namespace http {

namespace http {

namespace detail {

namespace detail {

#if defined( BOOST_NO_TYPEID )

#if defined( BOOST_NO_TYPEID )

struct typeindex

struct typeindex

{

{

    typeindex(

    typeindex(

        core::typeinfo const& ti) noexcept

        core::typeinfo const& ti) noexcept

        : n_(std::strlen(ti.name()))

        : n_(std::strlen(ti.name()))

        , ti_(&ti)

        , ti_(&ti)

    { 

    { 

    }

    }

    std::size_t hash_code() const noexcept

    std::size_t hash_code() const noexcept

    {

    {

        constexpr std::size_t offset_basis =

        constexpr std::size_t offset_basis =

            (sizeof(std::size_t) == 8)

            (sizeof(std::size_t) == 8)

                ? 1469598103934665603ull

                ? 1469598103934665603ull

                : 2166136261u;

                : 2166136261u;

        constexpr std::size_t prime =

        constexpr std::size_t prime =

            (sizeof(std::size_t) == 8)

            (sizeof(std::size_t) == 8)

                ? 1099511628211ull

                ? 1099511628211ull

                : 16777619u;

                : 16777619u;

        auto const s = ti_->name();

        auto const s = ti_->name();

        std::size_t h = offset_basis;

        std::size_t h = offset_basis;

        for(std::size_t i = 0; i < n_; ++i)

        for(std::size_t i = 0; i < n_; ++i)

            h = (h ^ static_cast<unsigned char>(s[i])) * prime;

            h = (h ^ static_cast<unsigned char>(s[i])) * prime;

        return h;

        return h;

    }

    }

    bool operator==(typeindex const& other) const noexcept

    bool operator==(typeindex const& other) const noexcept

    {

    {

        return n_ == other.n_ && *ti_ == *other.ti_;

        return n_ == other.n_ && *ti_ == *other.ti_;

    }

    }

private:

private:

    std::size_t n_;

    std::size_t n_;

    core::typeinfo const* ti_;

    core::typeinfo const* ti_;

};

};

} // detail

} // detail

} // http

} // http

} // boost

} // boost

namespace std {

namespace std {

template<>

template<>

struct hash< boost::http::detail::typeindex >

struct hash< boost::http::detail::typeindex >

{

{

    std::size_t operator()(

    std::size_t operator()(

        boost::http::detail::typeindex const& t) const noexcept

        boost::http::detail::typeindex const& t) const noexcept

    {

    {

        return t.hash_code();

        return t.hash_code();

    }

    }

};

};

} // std

} // std

namespace boost {

namespace boost {

namespace http {

namespace http {

namespace detail {

namespace detail {

#else

#else

using typeindex = std::type_index;

using typeindex = std::type_index;

#endif

#endif

//------------------------------------------------

//------------------------------------------------

//

//

// call_traits

// call_traits

//

//

//------------------------------------------------

//------------------------------------------------

template<class... Ts>

template<class... Ts>

struct type_list {};

struct type_list {};

template<class T>

template<class T>

struct call_traits : std::false_type {};

struct call_traits : std::false_type {};

template<class R, class... Args>

template<class R, class... Args>

struct call_traits<R(*)(Args...)> : std::true_type

struct call_traits<R(*)(Args...)> : std::true_type

{

{

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class R, class... Args>

template<class R, class... Args>

struct call_traits<R(&)(Args...)> : std::true_type

struct call_traits<R(&)(Args...)> : std::true_type

{

{

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class C, class R, class... Args>

template<class C, class R, class... Args>

struct call_traits<R(C::*)(Args...)> : std::true_type

struct call_traits<R(C::*)(Args...)> : std::true_type

{

{

    using class_type = C;

    using class_type = C;

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class C, class R, class... Args>

template<class C, class R, class... Args>

struct call_traits<R(C::*)(Args...) const> : std::true_type

struct call_traits<R(C::*)(Args...) const> : std::true_type

{

{

    using class_type = C;

    using class_type = C;

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class R, class... Args>

template<class R, class... Args>

struct call_traits<R(*)(Args...) noexcept> : std::true_type

struct call_traits<R(*)(Args...) noexcept> : std::true_type

{

{

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class R, class... Args>

template<class R, class... Args>

struct call_traits<R(&)(Args...) noexcept> : std::true_type

struct call_traits<R(&)(Args...) noexcept> : std::true_type

{

{

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class C, class R, class... Args>

template<class C, class R, class... Args>

struct call_traits<R(C::*)(Args...) noexcept> : std::true_type

struct call_traits<R(C::*)(Args...) noexcept> : std::true_type

{

{

    using class_type = C;

    using class_type = C;

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class C, class R, class... Args>

template<class C, class R, class... Args>

struct call_traits<R(C::*)(Args...) const noexcept> : std::true_type

struct call_traits<R(C::*)(Args...) const noexcept> : std::true_type

{

{

    using class_type = C;

    using class_type = C;

    using return_type = R;

    using return_type = R;

    using arg_types = type_list<Args...>;

    using arg_types = type_list<Args...>;

};

};

template<class F>

template<class F>

    requires requires { &F::operator(); } &&

    requires requires { &F::operator(); } &&

             std::is_member_function_pointer_v<decltype(&F::operator())>

             std::is_member_function_pointer_v<decltype(&F::operator())>

struct call_traits<F> : call_traits<decltype(&F::operator())> {};

struct call_traits<F> : call_traits<decltype(&F::operator())> {};

} // detail

} // detail

/** A container of type-erased objects

/** A container of type-erased objects

    Objects are stored and retrieved by their type.

    Objects are stored and retrieved by their type.

    Each type may be stored at most once. Types

    Each type may be stored at most once. Types

    may specify a nested `key_type` to be used

    may specify a nested `key_type` to be used

    as the unique identifier instead of the type

    as the unique identifier instead of the type

    itself. In this case, a reference to the type

    itself. In this case, a reference to the type

    must be convertible to a reference to the key type.

    must be convertible to a reference to the key type.

    @par Example

    @par Example

    @code

    @code

    struct A

    struct A

    {

    {

        int i = 1;

        int i = 1;

    };

    };

    struct B

    struct B

    {

    {

        char c = '2';

        char c = '2';

    };

    };

    struct C

    struct C

    {

    {

        double d;

        double d;

    };

    };

    struct D : C

    struct D : C

    {

    {

        using key_type = C;

        using key_type = C;

        D()

        D()

        {

        {

            d = 3.14;

            d = 3.14;

        }

        }

    };

    };

    polystore ps;

    polystore ps;

    A& a = ps.emplace<A>();

    A& a = ps.emplace<A>();

    B& b = ps.insert(B{});

    B& b = ps.insert(B{});

    C& c = ps.emplace<C>();

    C& c = ps.emplace<C>();

    assert(ps.get<A>().i == 1);

    assert(ps.get<A>().i == 1);

    assert(ps.get<B>().c == '2');

    assert(ps.get<B>().c == '2');

    assert(ps.get<C>().d == 3.14);

    assert(ps.get<C>().d == 3.14);

    invoke(ps, [](A& a){ a.i = 0; });

    invoke(ps, [](A& a){ a.i = 0; });

    invoke(ps, [](A const&, B& b){ b.c = 0; });

    invoke(ps, [](A const&, B& b){ b.c = 0; });

    assert(ps.get<A>().i == 0);

    assert(ps.get<A>().i == 0);

    assert(ps.get<B>().c == 0);

    assert(ps.get<B>().c == 0);

    @endcode

    @endcode

*/

*/

class polystore

class polystore

{

{

    template<class T, class = void>

    template<class T, class = void>

    struct get_key : std::false_type

    struct get_key : std::false_type

    {

    {

    };

    };

    template<class T>

    template<class T>

    struct get_key<T, typename std::enable_if<

    struct get_key<T, typename std::enable_if<

        ! std::is_same<T, typename T::key_type>::value>::type>

        ! std::is_same<T, typename T::key_type>::value>::type>

        : std::true_type

        : std::true_type

    {

    {

        using type = typename T::key_type;

        using type = typename T::key_type;

    };

    };

public:

public:

    /** Destructor

    /** Destructor

        All objects stored in the container are destroyed in

        All objects stored in the container are destroyed in

        the reverse order of construction.

        the reverse order of construction.

    */

    */

    BOOST_HTTP_DECL

    BOOST_HTTP_DECL

    ~polystore();

    ~polystore();

    /** Constructor

    /** Constructor

        The moved-from container will be empty.

        The moved-from container will be empty.

    */

    */

    BOOST_HTTP_DECL

    BOOST_HTTP_DECL

    polystore(polystore&& other) noexcept;

    polystore(polystore&& other) noexcept;

    /** Assignment operator

    /** Assignment operator

        The moved-from container will be empty.

        The moved-from container will be empty.

        @return A reference to `*this`.

        @return A reference to `*this`.

    */

    */

    BOOST_HTTP_DECL

    BOOST_HTTP_DECL

    polystore& operator=(polystore&& other) noexcept;

    polystore& operator=(polystore&& other) noexcept;

    /** Constructor

    /** Constructor

        The container is initially empty.

        The container is initially empty.

    */

    */

    /** Return a pointer to the object associated with type `T`, or `nullptr`

    /** Return a pointer to the object associated with type `T`, or `nullptr`

        If no object associated with `T` exists in the container,

        If no object associated with `T` exists in the container,

        `nullptr` is returned.

        `nullptr` is returned.

        @par Thread Safety

        @par Thread Safety

        `const` member function calls are thread-safe.

        `const` member function calls are thread-safe.

        Calls to non-`const` member functions must not run concurrently

        Calls to non-`const` member functions must not run concurrently

        with other member functions on the same object.

        with other member functions on the same object.

        @tparam T The type of object to find.

        @tparam T The type of object to find.

        @return A pointer to the associated object, or `nullptr` if none exists.

        @return A pointer to the associated object, or `nullptr` if none exists.

    */

    */

    template<class T>

    template<class T>

    {

    {

    }

    }

    /** Assign the pointer for the object associated with `T`, or `nullptr`.

    /** Assign the pointer for the object associated with `T`, or `nullptr`.

        If no object of type `T` is stored, @p t is set to `nullptr`.

        If no object of type `T` is stored, @p t is set to `nullptr`.

        @par Thread Safety

        @par Thread Safety

        `const` member functions are thread-safe. Non-`const` functions

        `const` member functions are thread-safe. Non-`const` functions

        must not run concurrently with any other member function on the

        must not run concurrently with any other member function on the

        same instance.

        same instance.

        @param t The pointer to assign.

        @param t The pointer to assign.

        @return `true` if an object of type `T` is present, otherwise `false`.

        @return `true` if an object of type `T` is present, otherwise `false`.

    */

    */

    template<class T>

    template<class T>

    bool find(T*& t) const noexcept

    bool find(T*& t) const noexcept

    {

    {

        t = find<T>();

        t = find<T>();

        return t != nullptr;

        return t != nullptr;

    }

    }

    /** Return a reference to the object associated with type T

    /** Return a reference to the object associated with type T

        If no such object exists in the container, an exception is thrown.

        If no such object exists in the container, an exception is thrown.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety

        Calls to `const` member functions are thread-safe.  

        Calls to `const` member functions are thread-safe.  

        Calls to non-`const` member functions must not run concurrently

        Calls to non-`const` member functions must not run concurrently

        with other member functions on the same object.

        with other member functions on the same object.

        @throws std::bad_typeid

        @throws std::bad_typeid

        If no object associated with type `T` is present.

        If no object associated with type `T` is present.

        @tparam T The type of object to retrieve.

        @tparam T The type of object to retrieve.

        @return A reference to the associated object.

        @return A reference to the associated object.

    */

    */

    template<class T>

    template<class T>

    {

    {

    }

    }

    /** Construct and insert an anonymous object into the container

    /** Construct and insert an anonymous object into the container

        A new object of type `T` is constructed in place using the provided

        A new object of type `T` is constructed in place using the provided

        arguments and inserted into the container without associating it

        arguments and inserted into the container without associating it

        with any key. A reference to the stored object is returned.

        with any key. A reference to the stored object is returned.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety

        Not thread-safe.

        Not thread-safe.

        @tparam T The type of object to construct and insert.

        @tparam T The type of object to construct and insert.

        @param args Arguments forwarded to the constructor of `T`.

        @param args Arguments forwarded to the constructor of `T`.

        @return A reference to the inserted object.

        @return A reference to the inserted object.

    */

    */

    template<class T, class... Args>

    template<class T, class... Args>

    {

    {

    }

    }

    /** Insert an anonymous object by moving or copying it into the container

    /** Insert an anonymous object by moving or copying it into the container

        A new object of type `T` is inserted into the container without

        A new object of type `T` is inserted into the container without

        associating it with any key. The object is move-constructed or

        associating it with any key. The object is move-constructed or

        copy-constructed from the provided argument, and a reference to

        copy-constructed from the provided argument, and a reference to

        the stored object is returned.

        the stored object is returned.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety

        Not thread-safe.

        Not thread-safe.

        @tparam T The type of object to insert.

        @tparam T The type of object to insert.

        @param t The object to insert.

        @param t The object to insert.

        @return A reference to the inserted object.

        @return A reference to the inserted object.

    */

    */

    template<class T>

    template<class T>

    T& insert_anon(T&& t)

    T& insert_anon(T&& t)

    {

    {

        return emplace_anon<typename

        return emplace_anon<typename

            std::remove_cv<T>::type>(

            std::remove_cv<T>::type>(

                std::forward<T>(t));

                std::forward<T>(t));

    }

    }

    /** Construct and insert an object with a nested key type

    /** Construct and insert an object with a nested key type

        A new object of type `T` is constructed in place using the provided

        A new object of type `T` is constructed in place using the provided

        arguments and inserted into the container. The type `T` must define

        arguments and inserted into the container. The type `T` must define

        a nested type `key_type`, which is used as the key for insertion.

        a nested type `key_type`, which is used as the key for insertion.

        No additional key types may be specified. The type `T&` must be

        No additional key types may be specified. The type `T&` must be

        convertible to a reference to `key_type`.

        convertible to a reference to `key_type`.

        @par Constraints

        @par Constraints

        `T::key_type` must name a type.

        `T::key_type` must name a type.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety

        Not thread-safe.

        Not thread-safe.

        @throws std::invalid_argument On duplicate insertion.

        @throws std::invalid_argument On duplicate insertion.

        @tparam T The type of object to construct and insert.

        @tparam T The type of object to construct and insert.

        @param args Arguments forwarded to the constructor of `T`.

        @param args Arguments forwarded to the constructor of `T`.

        @return A reference to the inserted object.

        @return A reference to the inserted object.

    */

    */

    template<class T, class... Keys, class... Args>

    template<class T, class... Keys, class... Args>

        typename std::enable_if<get_key<T>::value, T&>::type

        typename std::enable_if<get_key<T>::value, T&>::type

    {

    {

        // Can't have Keys with nested key_type

        // Can't have Keys with nested key_type

        BOOST_CORE_STATIC_ASSERT(sizeof...(Keys) == 0);

        BOOST_CORE_STATIC_ASSERT(sizeof...(Keys) == 0);

        // T& must be convertible to key_type&

        // T& must be convertible to key_type&

        BOOST_CORE_STATIC_ASSERT(std::is_convertible<

        BOOST_CORE_STATIC_ASSERT(std::is_convertible<

            T&, typename get_key<T>::type&>::value);

            T&, typename get_key<T>::type&>::value);

    /** Construct and insert an object into the container

    /** Construct and insert an object into the container

        A new object of type `T` is constructed in place using the provided

        A new object of type `T` is constructed in place using the provided

        arguments and inserted into the container. The type `T` must not

        arguments and inserted into the container. The type `T` must not

        already exist in the container, nor may any of the additional key

        already exist in the container, nor may any of the additional key

        types refer to an existing object. The type `T&` must be convertible

        types refer to an existing object. The type `T&` must be convertible

        to a reference to each specified key type.

        to a reference to each specified key type.

        @par Constraints

        @par Constraints

        `T::key_type` must not name a type.

        `T::key_type` must not name a type.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety

        Not thread-safe.

        Not thread-safe.

        @throws std::invalid_argument On duplicate insertion.

        @throws std::invalid_argument On duplicate insertion.

        @tparam T The type of object to construct and insert.

        @tparam T The type of object to construct and insert.

        @tparam Keys Optional key types associated with the object.

        @tparam Keys Optional key types associated with the object.

        @param args Arguments forwarded to the constructor of `T`.

        @param args Arguments forwarded to the constructor of `T`.

        @return A reference to the inserted object.

        @return A reference to the inserted object.

    */

    */

    template<class T, class... Keys, class... Args>

    template<class T, class... Keys, class... Args>

        typename std::enable_if<! get_key<T>::value, T&>::type

        typename std::enable_if<! get_key<T>::value, T&>::type

    {

    {

        // T& must be convertible to each of Keys&

        // T& must be convertible to each of Keys&

        BOOST_CORE_STATIC_ASSERT((std::is_convertible_v<T&, Keys&> && ...));

        BOOST_CORE_STATIC_ASSERT((std::is_convertible_v<T&, Keys&> && ...));

    /** Return an existing object, creating it if necessary

    /** Return an existing object, creating it if necessary

        If an object of the exact type `T` already exists in the container,

        If an object of the exact type `T` already exists in the container,

        a reference to that object is returned. Otherwise, a new object is

        a reference to that object is returned. Otherwise, a new object is

        constructed in place using the provided arguments, and a reference

        constructed in place using the provided arguments, and a reference

        to the newly created object is returned. The type `T` must not

        to the newly created object is returned. The type `T` must not

        already exist in the container, nor may any of the additional key

        already exist in the container, nor may any of the additional key

        types refer to an existing object. The type `T` must be convertible

        types refer to an existing object. The type `T` must be convertible

        to a reference to each additional key type.

        to a reference to each additional key type.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety

        Not thread-safe.

        Not thread-safe.

        @throws std::invalid_argument On duplicate insertion.

        @throws std::invalid_argument On duplicate insertion.

        @tparam T The type of object to return or create.

        @tparam T The type of object to return or create.

        @tparam Keys Optional key types associated with the object.

        @tparam Keys Optional key types associated with the object.

        @param args Arguments forwarded to the constructor of `T`.

        @param args Arguments forwarded to the constructor of `T`.

        @return A reference to the existing or newly created object.

        @return A reference to the existing or newly created object.

    */

    */

    template<class T, class... Keys, class... Args>

    template<class T, class... Keys, class... Args>

        typename std::enable_if<get_key<T>::value, T&>::type

        typename std::enable_if<get_key<T>::value, T&>::type

    {

    {

        // Can't have Keys with nested key_type

        // Can't have Keys with nested key_type

        BOOST_CORE_STATIC_ASSERT(sizeof...(Keys) == 0);

        BOOST_CORE_STATIC_ASSERT(sizeof...(Keys) == 0);

        // T& must be convertible to key_type&

        // T& must be convertible to key_type&

        BOOST_CORE_STATIC_ASSERT(std::is_convertible<

        BOOST_CORE_STATIC_ASSERT(std::is_convertible<

            T&, typename get_key<T>::type&>::value);

            T&, typename get_key<T>::type&>::value);

    /** Return an existing object, creating it if necessary

    /** Return an existing object, creating it if necessary

        If an object of the exact type `T` already exists in the container,

        If an object of the exact type `T` already exists in the container,

        a reference to that object is returned. Otherwise, a new object is

        a reference to that object is returned. Otherwise, a new object is

        constructed in place using the provided arguments, and a reference

        constructed in place using the provided arguments, and a reference

        to the newly created object is returned. The type `T` must not

        to the newly created object is returned. The type `T` must not

        already exist in the container, nor may any of the additional key

        already exist in the container, nor may any of the additional key

        types refer to an existing object. The type `T` must be convertible

        types refer to an existing object. The type `T` must be convertible

        to a reference to each additional key type.

        to a reference to each additional key type.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety

        `const` member function calls are thread-safe.

        `const` member function calls are thread-safe.

        Calls to non-`const` member functions must not run concurrently

        Calls to non-`const` member functions must not run concurrently

        with other member functions on the same object.

        with other member functions on the same object.

        @throws std::invalid_argument On duplicate insertion.

        @throws std::invalid_argument On duplicate insertion.

        @tparam T The type of object to return or create.

        @tparam T The type of object to return or create.

        @tparam Keys Optional key types associated with the object.

        @tparam Keys Optional key types associated with the object.

        @param args Arguments forwarded to the constructor of `T`.

        @param args Arguments forwarded to the constructor of `T`.

        @return A reference to the existing or newly created object.

        @return A reference to the existing or newly created object.

    */

    */

    template<class T, class... Keys, class... Args>

    template<class T, class... Keys, class... Args>

        typename std::enable_if<! get_key<T>::value, T&>::type

        typename std::enable_if<! get_key<T>::value, T&>::type

    {

    {

        // T& must be convertible to each of Keys&

        // T& must be convertible to each of Keys&

        BOOST_CORE_STATIC_ASSERT((std::is_convertible_v<T&, Keys&> && ...));

        BOOST_CORE_STATIC_ASSERT((std::is_convertible_v<T&, Keys&> && ...));

    /** Insert an object by moving or copying it into the container

    /** Insert an object by moving or copying it into the container

        If an object of the same type `T` already exists in the container,

        If an object of the same type `T` already exists in the container,

        or if any of the additional key types would refer to an existing

        or if any of the additional key types would refer to an existing

        object, an exception is thrown. Otherwise, the object is inserted

        object, an exception is thrown. Otherwise, the object is inserted

        by move or copy construction, and a reference to the stored object

        by move or copy construction, and a reference to the stored object

        is returned. The type `T` must be convertible to a reference to each

        is returned. The type `T` must be convertible to a reference to each

        additional key type.

        additional key type.

        @par Exception Safety

        @par Exception Safety

        Strong guarantee.

        Strong guarantee.

        @par Thread Safety

        @par Thread Safety