vinniefalco

static
void
serialize_impl(
    string& s,
    serializer& sr)
{
    // serialize to a small buffer
    // to avoid most reallocations
    char buf[16384];
    string_view sv;

vinniefalco

    /** Return an @ref array pointer if this is an array, else return `nullptr`

        If `this->kind() == kind::array`, then a pointer
        to the underlying array is returned. Otherwise,
        `nullptr` is returned.

        @par Example

        The semantics of the function allow the return
        value to be used in a conditional expression as

vinniefalco

void*
static_resource::
do_allocate(
    std::size_t n,
    std::size_t align)
{
    std::size_t const extra = (
        align * ((i_ + align - 1) / align)) - i_;
    if( extra > n_ ||
        n > n_ ||

vinniefalco

void*
static_resource::
do_allocate(
    std::size_t n,
    std::size_t align)
{
    auto const i = reinterpret_cast<
        std::uintptr_t>(buffer_ + used_);
    std::size_t const extra = (
        align * ((i + align - 1) / align)) - i;

vinniefalco

    /** Constructor

        This constructs a non-owning pointer that
        points to the specified memory resource `r`.
        The caller is responsible for maintaining the
        lifetime of the pointed-to @ref memory_resource.

        @par Constraints
        @code
        std::is_convertible< T*, memory_resource* >::value == true

vinniefalco

A polymorphic allocator constructs with a pointer to a memory resource:

    // A type of memory resource
    std::pmr::monotonic_buffer_resource mr;

    // Construct a vector using the monotonic buffer resource
    std::pmr::vector< T > v1( std::pmr::polymorphic_allocator< T >(&mr) );

    // Or this way, since construction from memory_resource* is implicit:
    std::pmr::vector< T > v2( &mr );

vinniefalco

    /** Push an object formed by popping `n` key/value pairs from the stack.

        This function pushes an @ref object value
        onto the stack. The object is formed by first
        popping the top `n` key/value pairs from the
        stack. If the stack contains fewer than `n`
        key/value pairs, or if any of the top `n` key/value
        pairs on the stack does not consist of exactly one
        key followed by one value, the behavior is undefined.
    \n

vinniefalco

    /** Push an object formed by popping `n` key/value pairs from the stack.

        This function pushes an @ref object value
        onto the stack. The object is formed by first
        popping the top `n` key/value pairs from the
        stack. If the stack contains fewer than `n`
        key/value pairs, or if any of the top `n` key/value
        pairs on the stack does not consist of exactly one
        key followed by one value, the behavior is undefined.
    \n

vinniefalco

    /** Push an array formed by popping `n` values from the stack.

        This function pushes an @ref array value
        onto the stack. The array is formed by first
        popping the top `n` values from the stack.
        If the stack contains fewer than `n` values,
        or if any of the top `n` values on the stack
        is a key, the behavior is undefined.

        @param n The number of values to pop from the

vinniefalco

    // Construct the builder using a local buffer
    char temp[4096];
    value_builder vb( storage_ptr(), temp, sizeof(temp) );

    // Create a monotonic resource with a local initial buffer
    char buf[4096];
    monotonic_resource mr( buf, sizeof(buf) );

    // The builder will create a value using `mr`
    vb.reset(&mr);