Diff coverage report for

//

//

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

// Copyright (c) 2020 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_STATIC_RESOURCE_HPP

#ifndef BOOST_JSON_STATIC_RESOURCE_HPP

#define BOOST_JSON_STATIC_RESOURCE_HPP

#define BOOST_JSON_STATIC_RESOURCE_HPP

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

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

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

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

#include <boost/json/is_deallocate_trivial.hpp>

#include <boost/json/is_deallocate_trivial.hpp>

#include <cstddef>

#include <cstddef>

namespace boost {

namespace boost {

namespace json {

namespace json {

#ifdef _MSC_VER

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(push)

#pragma warning(disable: 4275) // non dll-interface class used as base for dll-interface class

#pragma warning(disable: 4275) // non dll-interface class used as base for dll-interface class

#endif

#endif

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

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

/** A resource using a caller-owned buffer, with a trivial deallocate.

/** A resource using a caller-owned buffer, with a trivial deallocate.

    This memory resource is a special-purpose resource that releases allocated

    This memory resource is a special-purpose resource that releases allocated

    memory only when the resource is destroyed (or when @ref release is

    memory only when the resource is destroyed (or when @ref release is

    called). It has a trivial deallocate function; that is, the metafunction

    called). It has a trivial deallocate function; that is, the metafunction

    @ref is_deallocate_trivial returns `true`.

    @ref is_deallocate_trivial returns `true`.

    The resource is constructed from a caller-owned buffer from which

    The resource is constructed from a caller-owned buffer from which

    subsequent calls to allocate are apportioned. When a memory request cannot

    subsequent calls to allocate are apportioned. When a memory request cannot

    be satisfied from the free bytes remaining in the buffer, the allocation

    be satisfied from the free bytes remaining in the buffer, the allocation

    request fails with the exception `std::bad_alloc`.

    request fails with the exception `std::bad_alloc`.

    @par Example

    @par Example

    This parses a JSON text into a value which uses a local stack buffer, then

    This parses a JSON text into a value which uses a local stack buffer, then

    prints the result.

    prints the result.

    @code

    @code

    unsigned char buf[ 4000 ];

    unsigned char buf[ 4000 ];

    static_resource mr( buf );

    static_resource mr( buf );

    // Parse the string, using our memory resource

    // Parse the string, using our memory resource

    value const jv = parse( "[1,2,3]", &mr );

    value const jv = parse( "[1,2,3]", &mr );

    // Print the JSON

    // Print the JSON

    std::cout << jv;

    std::cout << jv;

    @endcode

    @endcode

    @par Thread Safety

    @par Thread Safety

    Members of the same instance may not be called concurrently.

    Members of the same instance may not be called concurrently.

    @see https://en.wikipedia.org/wiki/Region-based_memory_management

    @see https://en.wikipedia.org/wiki/Region-based_memory_management

*/

*/

class

class

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    BOOST_SYMBOL_VISIBLE

    BOOST_SYMBOL_VISIBLE

static_resource final

static_resource final

    : public container::pmr::memory_resource

    : public container::pmr::memory_resource

{

{

    void* p_;

    void* p_;

    std::size_t n_;

    std::size_t n_;

    std::size_t size_;

    std::size_t size_;

public:

public:

    /** Assignment operator.

    /** Assignment operator.

        The type is neither copyable nor movable, so this operator is deleted.

        The type is neither copyable nor movable, so this operator is deleted.

    */

    */

    static_resource& operator=(

    static_resource& operator=(

        static_resource const&) = delete;

        static_resource const&) = delete;

    /** Constructors.

    /** Constructors.

        These construct the resource to use the specified buffer for subsequent

        These construct the resource to use the specified buffer for subsequent

        calls to allocate. When the buffer is exhausted, allocate will throw

        calls to allocate. When the buffer is exhausted, allocate will throw

        `std::bad_alloc`.

        `std::bad_alloc`.

        Ownership of `buffer` is not transferred; the caller is responsible for

        Ownership of `buffer` is not transferred; the caller is responsible for

        ensuring that its lifetime extends until the resource is destroyed.

        ensuring that its lifetime extends until the resource is destroyed.

        Overload **(5)** is the copy constructor. The type is neither copyable

        Overload **(5)** is the copy constructor. The type is neither copyable

        nor movable, so this overload is deleted.

        nor movable, so this overload is deleted.

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

        @param buffer The buffer to use.

        @param buffer The buffer to use.

        @param size The number of valid bytes pointed to by `buffer`.

        @param size The number of valid bytes pointed to by `buffer`.

        @{

        @{

    */

    */

    static_resource(

    static_resource(

        unsigned char* buffer,

        unsigned char* buffer,

        std::size_t size) noexcept;

        std::size_t size) noexcept;

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

    static_resource(

    static_resource(

        std::byte* buffer,

        std::byte* buffer,

        std::size_t size) noexcept

        std::size_t size) noexcept

        : static_resource(reinterpret_cast<

        : static_resource(reinterpret_cast<

            unsigned char*>(buffer), size)

            unsigned char*>(buffer), size)

    {

    {

    }

    }

#endif

#endif

    /** Overload

    /** Overload

        @tparam N The size of `buffer`.

        @tparam N The size of `buffer`.

        @param buffer

        @param buffer

    */

    */

    template<std::size_t N>

    template<std::size_t N>

    explicit

    explicit

        unsigned char(&buffer)[N]) noexcept

        unsigned char(&buffer)[N]) noexcept

    {

    {

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

    /** Overload

    /** Overload

        @tparam N

        @tparam N

        @param buffer

        @param buffer

    */

    */

    template<std::size_t N>

    template<std::size_t N>

    explicit

    explicit

    static_resource(

    static_resource(

        std::byte(&buffer)[N]) noexcept

        std::byte(&buffer)[N]) noexcept

        : static_resource(&buffer[0], N)

        : static_resource(&buffer[0], N)

    {

    {

    }

    }

#endif

#endif

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

    // Safety net for accidental buffer overflows

    // Safety net for accidental buffer overflows

    template<std::size_t N>

    template<std::size_t N>

    static_resource(

    static_resource(

        unsigned char(&buffer)[N], std::size_t n) noexcept

        unsigned char(&buffer)[N], std::size_t n) noexcept

        : static_resource(&buffer[0], n)

        : static_resource(&buffer[0], n)

    {

    {

        // If this goes off, check your parameters

        // If this goes off, check your parameters

        // closely, chances are you passed an array

        // closely, chances are you passed an array

        // thinking it was a pointer.

        // thinking it was a pointer.

        BOOST_ASSERT(n <= N);

        BOOST_ASSERT(n <= N);

    }

    }

#ifdef __cpp_lib_byte

#ifdef __cpp_lib_byte

    // Safety net for accidental buffer overflows

    // Safety net for accidental buffer overflows

    template<std::size_t N>

    template<std::size_t N>

    static_resource(

    static_resource(

        std::byte(&buffer)[N], std::size_t n) noexcept

        std::byte(&buffer)[N], std::size_t n) noexcept

        : static_resource(&buffer[0], n)

        : static_resource(&buffer[0], n)

    {

    {

        // If this goes off, check your parameters

        // If this goes off, check your parameters

        // closely, chances are you passed an array

        // closely, chances are you passed an array

        // thinking it was a pointer.

        // thinking it was a pointer.

        BOOST_ASSERT(n <= N);

        BOOST_ASSERT(n <= N);

    }

    }

#endif

#endif

#endif

#endif

    /// Overload

    /// Overload

    static_resource(

    static_resource(

        static_resource const&) = delete;

        static_resource const&) = delete;

    /// @}

    /// @}

    /** Release all allocated memory.

    /** Release all allocated memory.

        This function resets the buffer provided upon construction so that all

        This function resets the buffer provided upon construction so that all

        of the valid bytes are available for subsequent allocation.

        of the valid bytes are available for subsequent allocation.

        @par Complexity

        @par Complexity

        Constant

        Constant

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    void

    void

    release() noexcept;

    release() noexcept;

protected:

protected:

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

    void*

    void*

    do_allocate(

    do_allocate(

        std::size_t n,

        std::size_t n,

        std::size_t align) override;

        std::size_t align) override;

    void

    void

    do_deallocate(

    do_deallocate(

        void* p,

        void* p,

        std::size_t n,

        std::size_t n,

        std::size_t align) override;

        std::size_t align) override;

    bool

    bool

    do_is_equal(

    do_is_equal(

        memory_resource const& mr

        memory_resource const& mr

            ) const noexcept override;

            ) const noexcept override;

#endif

#endif

};

};

#ifdef _MSC_VER

#ifdef _MSC_VER

#pragma warning(pop)

#pragma warning(pop)

#endif

#endif

template<>

template<>

struct is_deallocate_trivial<

struct is_deallocate_trivial<

    static_resource>

    static_resource>

{

{

    static constexpr bool value = true;

    static constexpr bool value = true;

};

};

} // namespace json

} // namespace json

} // namespace boost

} // namespace boost

#endif

#endif