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 class is used to hold a pointer to a memory resource. The pointed-to

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

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

    ownership will be either:

    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

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

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

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

    is responsible for ensuring that the lifetime of the memory resource

    is responsible for ensuring that the lifetime of the memory resource

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

    extends 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 @ref make_shared_resource.

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

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

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

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

    @par Examples

    @par Examples

    These statements create a memory resource on the stack and construct

    These statements create a memory resource on the stack and construct

    a pointer from it without taking ownership:

    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 resource using shared ownership

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

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

    copy of the pointer is destroyed:

    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

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

    C++ objects. Specifically, it conforms to

    C++ objects. Specifically, it conforms to

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

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

    @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 resource, the shared

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

        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.

    /** Constructors.

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

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

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

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

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

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

        resource `r`.

        resource `r`.

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

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

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

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

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

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

        `other`, with the same ownership.

        `other`, with the same ownership.

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

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

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

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

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

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

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

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

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

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

        maintaining the lifetime of the pointed-to

        maintaining the lifetime of the pointed-to

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

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

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

        After **(4)**, `other` will point to the default 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

        @pre

        @code

        @code

        r != nullptr

        r != nullptr

        @endcode

        @endcode

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

        @{

        @{

    */

    */

    {

    {

    /** Overload

    /** Overload

        @tparam T The type of memory resource.

        @tparam T The type of memory resource.

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

        @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

    /** Overload

        @tparam V Any type.

        @tparam V Any type.

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

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

        construct from.

        construct from.

    */

    */

    template<class V>

    template<class V>

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

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

    {

    {

    /** Overload

    /** Overload

        @param other Another pointer.

        @param other Another pointer.

    */

    */

        storage_ptr&& other) noexcept

        storage_ptr&& other) noexcept

    {

    {

    /** Overload

    /** Overload

        @param other

        @param other

    */

    */

        storage_ptr const& other) noexcept

        storage_ptr const& other) noexcept

    {

    {

    /// @}

    /// @}

    /** Assignment operators.

    /** Assignment operators.

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

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

        as `other`, with the same ownership:

        as `other`, with the same ownership:

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

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

        non-owning.

        non-owning.

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

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

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

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

        with `other`.

        with `other`.

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

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

        released before the function returns.

        released before the function returns.

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

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

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

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

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

        @param other Another pointer.

        @param other Another pointer.

        @{

        @{

    */

    */

    storage_ptr&

    storage_ptr&

        storage_ptr&& other) noexcept

        storage_ptr&& other) noexcept

    {

    {

    }

    }

    storage_ptr&

    storage_ptr&

        storage_ptr const& other) noexcept

        storage_ptr const& other) noexcept

    {

    {

    }

    }

    /// @}

    /// @}

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

    /** Check 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 created using @ref

        make_shared_resource.

        make_shared_resource.

    */

    */

    bool

    bool

    {

    {

    }

    }

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

    /** Check 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 function of the

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

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

        is_deallocate_trivial is evaluated and saved when the memory resource

        is_deallocate_trivial is evaluated and saved when the memory resource

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

        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.

    /** Check 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 can

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

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

        is_deallocate_trivial()`.

        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 @ref 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 referenced @ref

        boost::container::pmr::memory_resource.

        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 pointed-to @ref

        boost::container::pmr::memory_resource.

        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 a pointer that owns 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

    This function dynamically allocates a new memory resource as if by

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

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

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

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

    it is destroyed.

    it is destroyed.

    @par Constraints

    @par Constraints

    @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

/// Overload

inline

inline

bool

bool

    storage_ptr const& lhs,

    storage_ptr const& lhs,

    storage_ptr const& rhs) noexcept

    storage_ptr const& rhs) noexcept

{

{

}

}

/// Overload

/// Overload

inline

inline

bool

bool

operator!=(

operator!=(

    storage_ptr const& lhs,

    storage_ptr const& lhs,

    storage_ptr const& rhs) noexcept

    storage_ptr const& rhs) noexcept

{

{

    return lhs.get() != rhs.get();

    return lhs.get() != rhs.get();

}

}

} // namespace json

} // namespace json

} // namespace boost

} // namespace boost

#endif

#endif