Diff coverage report for

//

//

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

// Copyright (c) 2019 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/boostorg/json

// Official repository: https://github.com/boostorg/json

//

//

#ifndef BOOST_JSON_OBJECT_HPP

#ifndef BOOST_JSON_OBJECT_HPP

#define BOOST_JSON_OBJECT_HPP

#define BOOST_JSON_OBJECT_HPP

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

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

#include <boost/json/detail/object.hpp>

#include <boost/json/detail/object.hpp>

#include <boost/json/detail/value.hpp>

#include <boost/json/detail/value.hpp>

#include <boost/json/kind.hpp>

#include <boost/json/kind.hpp>

#include <boost/json/pilfer.hpp>

#include <boost/json/pilfer.hpp>

#include <boost/system/result.hpp>

#include <boost/system/result.hpp>

#include <boost/json/storage_ptr.hpp>

#include <boost/json/storage_ptr.hpp>

#include <boost/json/string_view.hpp>

#include <boost/json/string_view.hpp>

#include <cstdlib>

#include <cstdlib>

#include <initializer_list>

#include <initializer_list>

#include <iterator>

#include <iterator>

#include <type_traits>

#include <type_traits>

#include <utility>

#include <utility>

namespace boost {

namespace boost {

namespace json {

namespace json {

class value;

class value;

class value_ref;

class value_ref;

class key_value_pair;

class key_value_pair;

/** A dynamically sized associative container of JSON key/value pairs.

/** A dynamically sized associative container of JSON key/value pairs.

    This is an associative container whose elements are key/value pairs with

    This is an associative container whose elements

    unique keys.

    are key/value pairs with unique keys.

    The elements are stored contiguously; iterators are ordinary pointers,

    The elements are stored contiguously; iterators are

    allowing random access pointer arithmetic for retrieving elements. In

    ordinary pointers, allowing random access pointer

    addition, the container maintains an internal index to speed up find

    arithmetic for retrieving elements.

    operations, reducing the average complexity for most lookups and

    In addition, the container maintains an internal

    insertions.

    index to speed up find operations, reducing the

    average complexity for most lookups and insertions.

    Reallocations are usually costly operations in terms of performance, as

    Reallocations are usually costly operations in terms of

    elements are copied and the internal index must be rebuilt. The @ref

    performance, as elements are copied and the internal

    reserve function can be used to eliminate reallocations if the number of

    index must be rebuilt. The @ref reserve function can

    be used to eliminate reallocations if the number of

    elements is known beforehand.

    elements is known beforehand.

    @par Allocators

    @par Allocators

    All elements stored in the container, and their children if any, will use

    the same memory resource that was used to construct the container.

    All elements stored in the container, and their

    children if any, will use the same memory resource that

    was used to construct the container.

    @par Thread Safety

    @par Thread Safety

    Non-const member functions may not be called concurrently with any other

    member functions.

    Non-const member functions may not be called

    concurrently with any other member functions.

    @par Satisfies

    @par Satisfies

        [ContiguousContainer](https://en.cppreference.com/w/cpp/named_req/ContiguousContainer),

        <a href="https://en.cppreference.com/w/cpp/named_req/ContiguousContainer"><em>ContiguousContainer</em></a>,

        [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer), and

        <a href="https://en.cppreference.com/w/cpp/named_req/ReversibleContainer"><em>ReversibleContainer</em></a>, and

        {req_SequenceContainer}.

        <a href="https://en.cppreference.com/w/cpp/named_req/SequenceContainer"><em>SequenceContainer</em></a>.

*/

*/

class object

class object

{

{

    struct table;

    struct table;

    class revert_construct;

    class revert_construct;

    class revert_insert;

    class revert_insert;

    friend class value;

    friend class value;

    friend class object_test;

    friend class object_test;

    using access = detail::access;

    using access = detail::access;

    using index_t = std::uint32_t;

    using index_t = std::uint32_t;

    static index_t constexpr null_index_ =

    static index_t constexpr null_index_ =

        std::uint32_t(-1);

        std::uint32_t(-1);

    storage_ptr sp_;            // must come first

    storage_ptr sp_;            // must come first

    kind k_ = kind::object;     // must come second

    kind k_ = kind::object;     // must come second

    table* t_;

    table* t_;

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    static table empty_;

    static table empty_;

    template<class T>

    template<class T>

    using is_inputit = typename std::enable_if<

    using is_inputit = typename std::enable_if<

        std::is_constructible<key_value_pair,

        std::is_constructible<key_value_pair,

        typename std::iterator_traits<T>::reference

        typename std::iterator_traits<T>::reference

            >::value>::type;

            >::value>::type;

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    explicit

    explicit

    object(detail::unchecked_object&& uo);

    object(detail::unchecked_object&& uo);

public:

public:

    /// Associated [Allocator](https://en.cppreference.com/w/cpp/named_req/Allocator)

    /// Associated [Allocator](https://en.cppreference.com/w/cpp/named_req/Allocator)

    using allocator_type = container::pmr::polymorphic_allocator<value>;

    using allocator_type = container::pmr::polymorphic_allocator<value>;

    /** The type of keys.

    /** The type of keys.

        The function @ref string::max_size returns the

        The function @ref string::max_size returns the

        maximum allowed size of strings used as keys.

        maximum allowed size of strings used as keys.

    */

    */

    using key_type = string_view;

    using key_type = string_view;

    /// The type of mapped values

    /// The type of mapped values

    using mapped_type = value;

    using mapped_type = value;

    /// The element type

    /// The element type

    using value_type = key_value_pair;

    using value_type = key_value_pair;

    /// The type used to represent unsigned integers

    /// The type used to represent unsigned integers

    using size_type = std::size_t;

    using size_type = std::size_t;

    /// The type used to represent signed integers

    /// The type used to represent signed integers

    using difference_type = std::ptrdiff_t;

    using difference_type = std::ptrdiff_t;

    /// A reference to an element

    /// A reference to an element

    using reference = value_type&;

    using reference = value_type&;

    /// A const reference to an element

    /// A const reference to an element

    using const_reference = value_type const&;

    using const_reference = value_type const&;

    /// A pointer to an element

    /// A pointer to an element

    using pointer = value_type*;

    using pointer = value_type*;

    /// A const pointer to an element

    /// A const pointer to an element

    using const_pointer = value_type const*;

    using const_pointer = value_type const*;

    /// A random access iterator to an element

    /// A random access iterator to an element

    using iterator = value_type*;

    using iterator = value_type*;

    /// A const random access iterator to an element

    /// A const random access iterator to an element

    using const_iterator = value_type const*;

    using const_iterator = value_type const*;

    /// A reverse random access iterator to an element

    /// A reverse random access iterator to an element

    using reverse_iterator =

    using reverse_iterator =

        std::reverse_iterator<iterator>;

        std::reverse_iterator<iterator>;

    /// A const reverse random access iterator to an element

    /// A const reverse random access iterator to an element

    using const_reverse_iterator =

    using const_reverse_iterator =

        std::reverse_iterator<const_iterator>;

        std::reverse_iterator<const_iterator>;

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

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

    /** Destructor.

    /** Destructor.

        The destructor for each element is called if needed, any used memory is

        The destructor for each element is called if needed, any used memory is

        deallocated, and shared ownership of the

        deallocated, and shared ownership of the

        @ref boost::container::pmr::memory_resource is released.

        `boost::container::pmr::memory_resource` is released.

        @par Complexity

        @par Complexity

        Constant, or linear in @ref size().

        Constant, or linear in @ref size().

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    ~object() noexcept;

    ~object() noexcept;

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

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

    /** Constructors.

    /** Default constructor.

        Constructs an object.

        @li **(1)**--**(3)** the object is empty.

        @li **(4)** the object is filled with values in the range

            `[first, last)`.

        @li **(5)**, **(6)** the object is filled with copies of the values in

            `init`.

        @li **(7)**, **(8)** the object is filled with copies of the elements

            of `other`.

        @li **(9)** the object acquires ownership of the contents of `other`.

        @li **(10)** equivalent to **(9)** if `*sp == *other.storage()`;

            otherwise equivalent to **(8)**.

        @li **(11)** the object acquires ownership of the contents of `other`

            using pilfer semantics. This is more efficient than move

            construction, when it is known that the moved-from object will be

            immediately destroyed afterwards.

        Upon construction, @ref capacity() will be large enough to store the

        object's elements. In addition, with **(3)**, **(4)**, and **(6)** the

        capacity will not be smaller than `min_capacity`.

        With **(2)**--**(6)**, **(8)**, **(10)** the constructed object uses

        memory resource of `sp`. With **(7)**, **(9)**, **(11)** it uses

        `other`'s memory resource. In either case the object will share the

        ownership of the memory resource. With **(1)** it uses the

        \<\<default_memory_resource,default memory resource\>\>.

        After **(9)** `other` behaves as if newly constructed with its current

        storage pointer.

        After **(11)** `other` is not in a usable state and may only be

        destroyed.

        If `init` or `[first, last)` have elements with duplicate keys, only

        the first of those equivalent elements will be inserted.

        @par Constraints

        The constructed object is empty with zero

        @code

        capacity, using the [default memory resource].

        std::is_constructible_v<

            key_value_pair,

            std::iterator_traits<InputIt>::reference>

        @endcode

        @par Complexity

        @par Complexity

        @li **(1)**--**(3)**, **(9)**, **(11)** constant.

        Constant.

        @li **(4)** linear in `std::distance(first, last)`.

        @li **(5)**, **(6)** linear in `init.size()`.

        @li **(7)**, **(8)** linear in `other.size()`.

        @li **(10)** constant if `*sp == *other.storage()`; otherwise linear in

            `other.size()`.

        @par Exception Safety

        @par Exception Safety

        @li **(1)**, **(2)**, **(9)**, **(11)** no-throw guarantee.

        No-throw guarantee.

        @li **(3)**, **(5)**, **(6)**--**(8)**, **(10)** strong guarantee.

        @li **(4)** strong guarantee if `InputIt` satisfies

            {req_ForwardIterator}, basic guarantee otherwise.

        Calls to `memory_resource::allocate` may throw.

        @see @ref pilfer,

             [Valueless Variants Considered Harmful](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html).

        @{

        [default memory resource]: json/allocators/storage_ptr.html#json.allocators.storage_ptr.default_memory_resource

    */

    */

    {

    {

    /** Overload

    /** Constructor.

        @param sp A pointer to the @ref boost::container::pmr::memory_resource

        The constructed object is empty with zero

               to use.

        capacity, using the specified memory resource.

        @par Complexity

        Constant.

        @par Exception Safety

        No-throw guarantee.

        @param sp A pointer to the `boost::container::pmr::memory_resource` to

        use. The container will acquire shared ownership of the memory

        resource.

    */

    */

    explicit

    explicit

    {

    {

    /** Overload

    /** Constructor.

        @param min_capacity The minimum number of elements for which capacity

        The constructed object is empty with capacity

               is guaranteed without a subsequent reallocation.

        equal to the specified minimum capacity,

        @param sp

        using the specified memory resource.

        @par Complexity

        Constant.

        @par Exception Safety

        Strong guarantee.

        Calls to `memory_resource::allocate` may throw.

        @param min_capacity The minimum number

        of elements for which capacity is guaranteed

        without a subsequent reallocation.

        @param sp A pointer to the `boost::container::pmr::memory_resource` to

        use. The container will acquire shared ownership of the memory

        resource.

    */

    */

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    object(

    object(

        std::size_t min_capacity,

        std::size_t min_capacity,

        storage_ptr sp = {});

        storage_ptr sp = {});

    /** Overload

    /** Constructor.

        @param first An input iterator pointing to the first element to insert,

        The object is constructed with the elements

               or pointing to the end of the range.

        in the range `{first, last)`, preserving order,

        @param last An input iterator pointing to the end of the range.

        using the specified memory resource.

        @param min_capacity

        If there are elements with duplicate keys; that

        @param sp

        is, if multiple elements in the range have keys

        that compare equal, only the first equivalent

        element will be inserted.

        @tparam InputIt a type satisfying the requirements of

        @par Constraints

                {req_InputIterator}.

        @code

        std::is_constructible_v<

            key_value_pair,

            std::iterator_traits<InputIt>::reference>

        @endcode

        @par Complexity

        Linear in `std::distance(first, last)`.

        @par Exception Safety

        Strong guarantee.

        Calls to `memory_resource::allocate` may throw.

        @param first An input iterator pointing to the

        first element to insert, or pointing to the end

        of the range.

        @param last An input iterator pointing to the end

        of the range.

        @param min_capacity The minimum number

        of elements for which capacity is guaranteed

        without a subsequent reallocation.

        Upon construction, @ref capacity() will be greater

        than or equal to this number.

        @param sp A pointer to the `boost::container::pmr::memory_resource` to

        use. The container will acquire shared ownership of the memory

        resource.

        @tparam InputIt a type satisfying the requirements

        of __InputIterator__.

    */

    */

    template<

    template<

        class InputIt

        class InputIt

    #ifndef BOOST_JSON_DOCS

    #ifndef BOOST_JSON_DOCS

        ,class = is_inputit<InputIt>

        ,class = is_inputit<InputIt>

    #endif

    #endif

    >

    >

        InputIt first,

        InputIt first,

        InputIt last,

        InputIt last,

        std::size_t min_capacity = 0,

        std::size_t min_capacity = 0,

        storage_ptr sp = {})

        storage_ptr sp = {})

    {

    {

            first, last,

            first, last,

            min_capacity,

            min_capacity,

            typename std::iterator_traits<

            typename std::iterator_traits<

                InputIt>::iterator_category{});

                InputIt>::iterator_category{});

    /** Overload

    /** Move constructor.

        @param init The initializer list to insert.

        The object is constructed by acquiring ownership of

        @param sp

        the contents of `other` and shared ownership

        of `other`'s memory resource.

        @note

        After construction, the moved-from object behaves

        as if newly constructed with its current memory resource.

        @par Complexity

        Constant.

        @par Exception Safety

        No-throw guarantee.

        @param other The object to move.

    */

    */

        std::initializer_list<

    object(object&& other) noexcept;

            std::pair<string_view, value_ref>> init,

        storage_ptr sp = {})

    {

    /** Overload

    /** Move constructor.

        @param init

        The object is constructed with the contents of

        @param min_capacity

        `other` by move semantics, using the specified

        @param sp

        memory resource:

        @li If `*other.storage() == *sp`, ownership of

        the underlying memory is transferred in constant

        time, with no possibility of exceptions.

        After construction, the moved-from object behaves

        as if newly constructed with its current storage

        pointer.

        @li If `*other.storage() != *sp`, an

        element-wise copy is performed, which may throw.

        In this case, the moved-from object is not

        changed.

        @par Complexity

        Constant or linear in `other.size()`.

        @par Exception Safety

        Strong guarantee.

        Calls to `memory_resource::allocate` may throw.

        @param other The object to move.

        @param sp A pointer to the `boost::container::pmr::memory_resource` to

        use. The container will acquire shared ownership of the memory

        resource.

    */

    */

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    object(

    object(

        std::initializer_list<

        object&& other,

            std::pair<string_view, value_ref>> init,

        storage_ptr sp);

        std::size_t min_capacity,

        storage_ptr sp = {});

    /** Overload

    /** Pilfer constructor.

        @param other Another object.

        The object is constructed by acquiring ownership

        of the contents of `other` using pilfer semantics.

        This is more efficient than move construction, when

        it is known that the moved-from object will be

        immediately destroyed afterwards.

        @par Complexity

        Constant.

        @par Exception Safety

        No-throw guarantee.

        @param other The value to pilfer. After pilfer

        construction, `other` is not in a usable state

        and may only be destroyed.

        @see @ref pilfer,

            <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html">

                Valueless Variants Considered Harmful</a>

    */

    {

    /** Copy constructor.

        The object is constructed with a copy of the

        contents of `other`, using `other`'s memory resource.

        @par Complexity

        Linear in `other.size()`.

        @par Exception Safety

        Strong guarantee.

        Calls to `memory_resource::allocate` may throw.

        @param other The object to copy.

    */

    */

        object const& other)

        object const& other)

    {

    {

    /** Overload

    /** Copy constructor.

        @param other

        The object is constructed with a copy of the

        @param sp

        contents of `other`, using the specified memory resource.

        @par Complexity

        Linear in `other.size()`.

        @par Exception Safety

        Strong guarantee.

        Calls to `memory_resource::allocate` may throw.

        @param other The object to copy.

        @param sp A pointer to the `boost::container::pmr::memory_resource` to

        use. The container will acquire shared ownership of the memory

        resource.

    */

    */

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    object(

    object(

        object const& other,

        object const& other,

        storage_ptr sp);

        storage_ptr sp);

    /** Overload

    /** Construct from initializer-list.

        @param other

        The object is constructed with a copy of the values

    */

        in the initializer-list in order, using the

    BOOST_JSON_DECL

        specified memory resource.

    object(object&& other) noexcept;

        If there are elements with duplicate keys; that

        is, if multiple elements in the range have keys

        that compare equal, only the first equivalent

        element will be inserted.

    /** Overload

        @par Complexity

        Linear in `init.size()`.

        @param other

        @par Exception Safety

        @param sp

        Strong guarantee.

    */

        Calls to `memory_resource::allocate` may throw.

    BOOST_JSON_DECL

    object(

        object&& other,

        storage_ptr sp);

    /** Overload

        @param init The initializer list to insert.

        @param other

        @param sp A pointer to the `boost::container::pmr::memory_resource` to

        use. The container will acquire shared ownership of the memory

        resource.

    */

    */

    {

    {

    /// @}

    /** Construct from initializer-list.

        Storage for at least `min_capacity` elements is

        reserved, and then

        the object is constructed with a copy of the values

        in the initializer-list in order, using the

        specified memory resource.

        If there are elements with duplicate keys; that

        is, if multiple elements in the range have keys

        that compare equal, only the first equivalent

        element will be inserted.

        @par Complexity

        Linear in `init.size()`.

        @par Exception Safety

        Strong guarantee.

        Calls to `memory_resource::allocate` may throw.

        @param init The initializer list to insert.

        @param min_capacity The minimum number

        of elements for which capacity is guaranteed

        without a subsequent reallocation.