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_STORAGE_PTR_HPP

#ifndef BOOST_JSON_STORAGE_PTR_HPP

#define BOOST_JSON_STORAGE_PTR_HPP

#define BOOST_JSON_STORAGE_PTR_HPP

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

#include <boost/container/pmr/polymorphic_allocator.hpp>

#include <boost/container/pmr/polymorphic_allocator.hpp>

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

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

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

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

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

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

#include <boost/json/is_deallocate_trivial.hpp>

#include <boost/json/is_deallocate_trivial.hpp>

#include <new>

#include <new>

#include <type_traits>

#include <type_traits>

#include <utility>

#include <utility>

namespace boost {

namespace boost {

namespace json {

namespace json {

/** A smart pointer to a memory resource.

/** A smart pointer to a memory resource.

    This class is used to hold a pointer to a memory resource. The pointed-to

    This container is used to hold a pointer to a memory resource. The

    resource is always valid. Depending on the means of construction, the

    pointed-to resource is always valid. Depending on the means of

    ownership will be either:

    construction, the ownership will be either:

    @li Non-owning, when constructing from a raw pointer to

    @li Non-owning, when constructing from a raw pointer to

    @ref boost::container::pmr::memory_resource or from a

    `boost::container::pmr::memory_resource` or from a

    @ref boost::container::pmr::polymorphic_allocator. In this case the caller

    `boost::container::pmr::polymorphic_allocator`. In this case the caller is

    is responsible for ensuring that the lifetime of the memory resource

    responsible for ensuring that the lifetime of the memory resource extends

    extends until there are no more calls to allocate or deallocate.

    until there are no more calls to allocate or deallocate.

    @li Owning, when constructing using the function @ref make_shared_resource.

    @li Owning, when constructing using the function

    In this case ownership is shared; the lifetime of the memory resource

    @ref make_shared_resource. In this case

    extends until the last copy of the `storage_ptr` is destroyed.

    ownership is shared; the lifetime of the memory

    resource extends until the last copy of the

    @ref storage_ptr is destroyed.

    These statements create a memory resource on the stack and construct

    a pointer from it without taking ownership:

    @par Examples

    @par Examples

    These statements create a memory resource on the

    stack and construct a pointer from it without

    taking ownership:

    @code

    @code

    monotonic_resource mr;                  // Create our memory resource on the stack

    monotonic_resource mr;                  // Create our memory resource on the stack

    storage_ptr sp( &mr );                  // Construct a non-owning pointer to the resource

    storage_ptr sp( &mr );                  // Construct a non-owning pointer to the resource

    @endcode

    @endcode

    This function creates a pointer to a memory resource using shared ownership

    This function creates a pointer to a memory

    and returns it. The lifetime of the memory resource extends until the last

    resource using shared ownership and returns it.

    copy of the pointer is destroyed:

    The lifetime of the memory resource extends until

    the last copy of the pointer is destroyed:

    @code

    @code

    // Create a counted memory resource and return it

    // Create a counted memory resource and return it

    storage_ptr make_storage()

    storage_ptr make_storage()

    {

    {

        return make_shared_resource< monotonic_resource >();

        return make_shared_resource< monotonic_resource >();

    }

    }

    @endcode

    @endcode

    @par Thread Safety

    @par Thread Safety

    Instances of this type provide the default level of thread safety for all

    C++ objects. Specifically, it conforms to

    Instances of this type provide the default level of

    [16.4.6.10 Data race avoidance](http://eel.is/c++draft/res.on.data.races).

    thread safety for all C++ objects. Specifically, it

    conforms to

    <a href="http://eel.is/c++draft/res.on.data.races">

        16.4.6.10 Data race avoidance</a>.

    @see

    @see

        @ref make_shared_resource,

        @ref make_shared_resource,

        @ref boost::container::pmr::polymorphic_allocator,

        @ref boost::container::pmr::polymorphic_allocator,

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

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

*/

*/

class storage_ptr

class storage_ptr

{

{

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

    // VFALCO doc toolchain shows this when it shouldn't

    // VFALCO doc toolchain shows this when it shouldn't

    friend struct detail::shared_resource;

    friend struct detail::shared_resource;

#endif

#endif

    using shared_resource =

    using shared_resource =

        detail::shared_resource;

        detail::shared_resource;

    using default_resource =

    using default_resource =

        detail::default_resource;

        detail::default_resource;

    std::uintptr_t i_;

    std::uintptr_t i_;

    shared_resource*

    shared_resource*

    {

    {

        return static_cast<shared_resource*>(

        return static_cast<shared_resource*>(

            reinterpret_cast<container::pmr::memory_resource*>(

            reinterpret_cast<container::pmr::memory_resource*>(

    }

    }

    void

    void

    {

    {

                1, std::memory_order_relaxed);

                1, std::memory_order_relaxed);

    void

    void

    {

    {

        {

        {

        }

        }

    template<class T>

    template<class T>

        detail::shared_resource_impl<T>* p) noexcept

        detail::shared_resource_impl<T>* p) noexcept

            (json::is_deallocate_trivial<T>::value ? 2 : 0))

            (json::is_deallocate_trivial<T>::value ? 2 : 0))

    {

    {

public:

public:

    /** Destructor.

    /** Destructor

        If the pointer has shared ownership of the resource, the shared

        If the pointer has shared ownership of the

        ownership is released. If this is the last owned copy, the memory

        resource, the shared ownership is released.

        If this is the last owned copy, the memory

        resource is destroyed.

        resource is destroyed.

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    {

    {

    /** Constructors.

    /** Constructor

        @li **(1)** constructs a non-owning pointer that refers to the

        This constructs a non-owning pointer that refers

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

        to the [default memory resource].

        @li **(2)** constructs a non-owning pointer that points to the memory

        @par Complexity

        resource `r`.

        Constant.

        @li **(3)** constructs a non-owning pointer that points to the same

        @par Exception Safety

        memory resource as `alloc`, obtained by calling `alloc.resource()`.

        No-throw guarantee.

        @li **(4)**, **(5)** construct a pointer to the same memory resource as

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

        `other`, with the same ownership.

    */

    {

        After **(4)** and **(5)** if `other` was owning, then the constructed

    /** Constructor

        pointer is also owning. In particular, **(4)** transfers ownership to

        the constructed pointer while **(5)** causes it to share ownership with

        `other`. Otherwise, and with other overloads the constructed pointer

        doesn't own its memory resource and the caller is responsible for

        maintaining the lifetime of the pointed-to

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

        After **(4)**, `other` will point to the default memory resource.

        This constructs a non-owning pointer that points to the memory resource

        `r`. The caller is responsible for maintaining the lifetime of the

        pointed-to `boost::container::pmr::memory_resource`.

        @par Constraints

        @par Constraints

        @code

        @code

        std::is_convertible< T*, boost::container::pmr::memory_resource* >::value == true

        std::is_convertible< T*, boost::container::pmr::memory_resource* >::value == true

        @endcode

        @endcode

        @pre

        @par Preconditions

        @code

        @code

        r != nullptr

        r != nullptr

        @endcode

        @endcode

        @par Complexity

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

        @{

        @param r A pointer to the memory resource to use.

    */

        This may not be null.

    {

    /** Overload

        @tparam T The type of memory resource.

        @param r A non-null pointer to the memory resource to use.

    */

    */

    template<class T

    template<class T

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

        , class = typename std::enable_if<

        , class = typename std::enable_if<

            std::is_convertible<T*,

            std::is_convertible<T*,

                container::pmr::memory_resource*>::value>::type

                container::pmr::memory_resource*>::value>::type

#endif

#endif

    >

    >

            (json::is_deallocate_trivial<T>::value ? 2 : 0))

            (json::is_deallocate_trivial<T>::value ? 2 : 0))

    {

    {

    /** Overload

    /** Constructor

        @tparam V Any type.

        This constructs a non-owning pointer that points to the same memory

        @param alloc A @ref boost::container::pmr::polymorphic_allocator to

        resource as `alloc`, obtained by calling `alloc.resource()`. The caller

        is responsible for maintaining the lifetime of the

        pointed-to `boost::container::pmr::memory_resource`.

        @par Constraints

        @code

        std::is_convertible< T*, boost::container::pmr::memory_resource* >::value == true

        @endcode

        @par Exception Safety

        No-throw guarantee.

        @param alloc A `boost::container::pmr::polymorphic_allocator` to

        construct from.

        construct from.

    */

    */

    template<class V>

    template<class T>

        container::pmr::polymorphic_allocator<V> const& alloc) noexcept

        container::pmr::polymorphic_allocator<T> const& alloc) noexcept

    {

    {

    /** Overload

    /** Move constructor

        @param other Another pointer.

        This function constructs a pointer that

        points to the same memory resource as `other`,

        with the same ownership:

        @li If `other` is non-owning, then `*this`

        will be be non-owning.

        @li If `other` has shared ownership, then

        ownership will be transferred to `*this`.

        After construction, `other` will point

        to the [default memory resource].

        @par Complexity

        Constant.

        @par Exception Safety

        No-throw guarantee.

        @param other The pointer to construct from.

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

    */

    */

        storage_ptr&& other) noexcept

        storage_ptr&& other) noexcept

    {

    {

    /** Overload

    /** Copy constructor

        @param other

        This function constructs a pointer that

        points to the same memory resource as `other`,

        with the same ownership:

        @li If `other` is non-owning, then `*this`

        will be be non-owning.

        @li If `other` has shared ownership, then

        `*this` will acquire shared ownership.

        @par Complexity

        Constant.

        @par Exception Safety

        No-throw guarantee.

        @param other The pointer to construct from.

    */

    */

        storage_ptr const& other) noexcept

        storage_ptr const& other) noexcept

    {

    {

    /** Assignment operators.

        This function assigns a pointer that points to the same memory resource

    /** Move assignment

        as `other`, with the same ownership:

        @li If `other` is non-owning, then the assigned-to pointer will be be

        This function assigns a pointer that

        non-owning.

        points to the same memory resource as `other`,

        with the same ownership:

        @li If `other` has shared ownership, then **(1)** transfers ownership

        @li If `other` is non-owning, then `*this`

        to the assigned-to pointer, while after **(2)** it shares the ownership

        will be be non-owning.

        with `other`.

        If the assigned-to pointer previously had shared ownership, it is

        @li If `other` has shared ownership, then

        released before the function returns.

        ownership will be transferred to `*this`.

        After **(1)**, `other` will point to the

        After assignment, `other` will point

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

        to the [default memory resource].

        If `*this` previously had shared ownership,

        it is released before the function returns.

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

        @param other Another pointer.

        @param other The storage pointer to move.

        @{

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

    */

    */

    storage_ptr&

    storage_ptr&

        storage_ptr&& other) noexcept

        storage_ptr&& other) noexcept

    {

    {

    }

    }

    /** Copy assignment.

        This function assigns a pointer that

        points to the same memory resource as `other`,

        with the same ownership:

        @li If `other` is non-owning, then `*this`

        will be be non-owning.

        @li If `other` has shared ownership, then

        `*this` will acquire shared ownership.

        If `*this` previously had shared ownership,

        it is released before the function returns.

        @par Complexity

        Constant.

        @par Exception Safety

        No-throw guarantee.

        @param other The storage pointer to copy.

    */

    storage_ptr&

    storage_ptr&

        storage_ptr const& other) noexcept

        storage_ptr const& other) noexcept

    {

    {

    /// @}

    }

    }

    /** Check if ownership of the memory resource is shared.

    /** Return `true` if ownership of the memory resource is shared.

        This function returns true for memory resources created using @ref

        This function returns true for memory resources

        make_shared_resource.

        created using @ref make_shared_resource.

    */

    */

    bool

    bool

    {

    {

    }

    }

    /** Check if calling `deallocate` on the memory resource has no effect.

    /** Return `true` if calling `deallocate` on the memory resource has no effect.

        This function is used to determine if the deallocate function of the

        This function is used to determine if the deallocate

        pointed to memory resource is trivial. The value of @ref

        function of the pointed to memory resource is trivial.

        is_deallocate_trivial is evaluated and saved when the memory resource

        The value of @ref is_deallocate_trivial is evaluated

        is constructed and the type is known, before the type is erased.

        and saved when the memory resource is constructed

        and the type is known, before the type is erased.

    */

    */

    bool

    bool

    {

    {

    }

    }

    /** Check if ownership of the memory resource is not shared and deallocate is trivial.

    /** Return `true` if ownership of the memory resource is not shared and deallocate is trivial.

        This function is used to determine if calls to deallocate can

        This function is used to determine if calls to deallocate

        effectively be skipped. Equivalent to `! is_shared() &&

        can effectively be skipped.

        is_deallocate_trivial()`.

        @par Effects

        Returns `! this->is_shared() && this->is_deallocate_trivial()`

    */

    */

    bool

    bool

    {

    {

    }

    }

    /** Return a pointer to the memory resource.

    /** Return a pointer to the memory resource.

        This function returns a pointer to the

        This function returns a pointer to the

        referenced @ref boost::container::pmr::memory_resource.

        referenced `boost::container::pmr::memory_resource`.

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    container::pmr::memory_resource*

    container::pmr::memory_resource*

    {

    {

            return reinterpret_cast<

            return reinterpret_cast<

    }

    }

    /** Return a pointer to the memory resource.

    /** Return a pointer to the memory resource.

        This function returns a pointer to the referenced @ref

        This function returns a pointer to the

        boost::container::pmr::memory_resource.

        referenced `boost::container::pmr::memory_resource`.

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    container::pmr::memory_resource*

    container::pmr::memory_resource*

    {

    {

    }

    }

    /** Return a reference to the memory resource.

    /** Return a reference to the memory resource.

        This function returns a reference to the pointed-to @ref

        This function returns a reference to the

        boost::container::pmr::memory_resource.

        pointed-to `boost::container::pmr::memory_resource`.

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    container::pmr::memory_resource&

    container::pmr::memory_resource&

    {

    {

    }

    }

    template<class U, class... Args>

    template<class U, class... Args>

    friend

    friend

    storage_ptr

    storage_ptr

    make_shared_resource(Args&&... args);

    make_shared_resource(Args&&... args);

};

};

#if defined(_MSC_VER)

#if defined(_MSC_VER)

# pragma warning( push )

# pragma warning( push )

# if !defined(__clang__) && _MSC_VER <= 1900

# if !defined(__clang__) && _MSC_VER <= 1900

#  pragma warning( disable : 4702 )

#  pragma warning( disable : 4702 )

# endif

# endif

#endif

#endif

/** Return shared ownership of a new, dynamically allocated memory resource.

/** Return a pointer that owns a new, dynamically allocated memory resource.

    This function dynamically allocates a new memory resource

    as if by `operator new` that uses shared ownership. The

    This function dynamically allocates a new memory resource as if by

    lifetime of the memory resource will be extended until

    `operator new` that uses shared ownership. The lifetime of the memory

    the last @ref storage_ptr which points to it is destroyed.

    resource will be extended until the last @ref storage_ptr which points to

    it is destroyed.

    @par Constraints

    @par Mandates

    @code

    @code

    std::is_base_of< boost::container::pmr::memory_resource, U >::value == true

    std::is_base_of< boost::container::pmr::memory_resource, U >::value == true

    @endcode

    @endcode

    @par Complexity

    @par Complexity

    Same as `new U( std::forward<Args>(args)... )`.

    Same as `new U( std::forward<Args>(args)... )`.

    @par Exception Safety

    @par Exception Safety

    Strong guarantee.

    Strong guarantee.

    @tparam U The type of memory resource to create.

    @tparam U The type of memory resource to create.

    @param args Parameters forwarded to the constructor of `U`.

    @param args Parameters forwarded to the constructor of `U`.

*/

*/

template<class U, class... Args>

template<class U, class... Args>

storage_ptr

storage_ptr

{

{

    // If this generates an error, it means that

    // If this generates an error, it means that

    // `T` is not a memory resource.

    // `T` is not a memory resource.

    BOOST_CORE_STATIC_ASSERT((

    BOOST_STATIC_ASSERT(

        std::is_base_of<container::pmr::memory_resource, U>::value));

        std::is_base_of<

            container::pmr::memory_resource, U>::value);

        detail::shared_resource_impl<U>(

        detail::shared_resource_impl<U>(

}

}

#if defined(_MSC_VER)

#if defined(_MSC_VER)

# pragma warning( pop )

# pragma warning( pop )

#endif

#endif

/// Overload

/** Return true if two storage pointers point to the same memory resource.

    This function returns `true` if the

    `boost::container::pmr::memory_resource` objects pointed to by `lhs` and

    `rhs` have the same address.

*/

inline

inline

bool

bool

    storage_ptr const& lhs,