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_PILFER_HPP

#ifndef BOOST_JSON_PILFER_HPP

#define BOOST_JSON_PILFER_HPP

#define BOOST_JSON_PILFER_HPP

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

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

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

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

#include <type_traits>

#include <type_traits>

#include <utility>

#include <utility>

/*

/*

    Implements "pilfering" from P0308R0

    Implements "pilfering" from P0308R0

    @see

    @see

        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html

        http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html

*/

*/

namespace boost {

namespace boost {

namespace json {

namespace json {

/** Tag wrapper to specify pilfer-construction.

/** Tag wrapper to specify pilfer-construction.

    This wrapper is used to specify a pilfer constructor

    This wrapper is used to specify a pilfer constructor

    overload.

    overload.

    @par Example

    @par Example

    A pilfer constructor accepts a single argument

    A pilfer constructor accepts a single argument

    of type @ref pilfered and throws nothing:

    of type @ref pilfered and throws nothing:

    @code

    @code

    struct T

    struct T

    {

    {

        T( pilfered<T> ) noexcept;

        T( pilfered<T> ) noexcept;

    };

    };

    @endcode

    @endcode

    @note

    @note

    The constructor should not be marked explicit.

    The constructor should not be marked explicit.

    @see @ref pilfer, @ref is_pilfer_constructible,

    @see @ref pilfer, @ref is_pilfer_constructible,

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

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

        Valueless Variants Considered Harmful</a>

        Valueless Variants Considered Harmful</a>

*/

*/

template<class T>

template<class T>

class pilfered

class pilfered

{

{

    T& t_;

    T& t_;

public:

public:

    /** Constructor

    /** Constructor

        Construct the wrapper from `t`.

        Construct the wrapper from `t`.

        @param t The pilferable object. Ownership

        @param t The pilferable object. Ownership

        is not transferred.

        is not transferred.

    */

    */

    explicit

    explicit

    constexpr

    constexpr

    {

    {

    /** Return a reference to the pilferable object.

    /** Return a reference to the pilferable object.

        This returns a reference to the wrapped object.

        This returns a reference to the wrapped object.

    */

    */

    constexpr T&

    constexpr T&

    {

    {

    }

    }

    /** Return a pointer to the pilferable object.

    /** Return a pointer to the pilferable object.

        This returns a pointer to the wrapped object.

        This returns a pointer to the wrapped object.

    */

    */

    constexpr T*

    constexpr T*

    operator->() const noexcept

    operator->() const noexcept

    {

    {

        //return std::addressof(t_);

        //return std::addressof(t_);

        return reinterpret_cast<T*>(

        return reinterpret_cast<T*>(

            const_cast<char *>(

            const_cast<char *>(

                &reinterpret_cast<

                &reinterpret_cast<

                    const volatile char &>(t_)));

                    const volatile char &>(t_)));

    }

    }

};

};

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

// VFALCO Renamed this to work around an msvc bug

// VFALCO Renamed this to work around an msvc bug

namespace detail_pilfer {

namespace detail_pilfer {

template<class>

template<class>

struct not_pilfered

struct not_pilfered

{

{

};

};

} // detail_pilfer

} // detail_pilfer

#endif

#endif

/** Metafunction returning `true` if `T` is <em>PilferConstructible</em>

/** Metafunction returning `true` if `T` is <em>PilferConstructible</em>

    If `T` can be pilfer constructed, this metafunction is

    If `T` can be pilfer constructed, this metafunction is

    equal to `std::true_type`. Otherwise it is equal to

    equal to `std::true_type`. Otherwise it is equal to

    `std::false_type`.

    `std::false_type`.

    @see @ref pilfer, @ref pilfered,

    @see @ref pilfer, @ref pilfered,

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

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

        Valueless Variants Considered Harmful</a>

        Valueless Variants Considered Harmful</a>

*/

*/

template<class T>

template<class T>

struct is_pilfer_constructible

struct is_pilfer_constructible

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

    : std::integral_constant<bool,

    : std::integral_constant<bool,

        std::is_nothrow_move_constructible<T>::value ||

        std::is_nothrow_move_constructible<T>::value ||

        (

        (

            std::is_nothrow_constructible<

            std::is_nothrow_constructible<

                T, pilfered<T> >::value &&

                T, pilfered<T> >::value &&

            ! std::is_nothrow_constructible<

            ! std::is_nothrow_constructible<

                T, detail_pilfer::not_pilfered<T> >::value

                T, detail_pilfer::not_pilfered<T> >::value

        )>

        )>

#endif

#endif

{

{

};

};

/** Indicate that an object `t` may be pilfered from.

/** Indicate that an object `t` may be pilfered from.

    A <em>pilfer</em> operation is the construction

    A <em>pilfer</em> operation is the construction

    of a new object of type `T` from an existing

    of a new object of type `T` from an existing

    object `t`. After the construction, the only

    object `t`. After the construction, the only

    valid operation on the pilfered-from object is

    valid operation on the pilfered-from object is

    destruction. This permits optimizations beyond

    destruction. This permits optimizations beyond

    those available for a move-construction, as the

    those available for a move-construction, as the

    pilfered-from object is not required to be in

    pilfered-from object is not required to be in

    a "usable" state.

    a "usable" state.

\n

\n

    This is used similarly to `std::move`.

    This is used similarly to `std::move`.

    @par Example

    @par Example

    A pilfer constructor accepts a single argument

    A pilfer constructor accepts a single argument

    of type @ref pilfered and throws nothing:

    of type @ref pilfered and throws nothing:

    @code

    @code

    struct T

    struct T

    {

    {

        T( pilfered<T> ) noexcept;

        T( pilfered<T> ) noexcept;

    };

    };

    @endcode

    @endcode

    Pilfer construction is performed using @ref pilfer :

    Pilfer construction is performed using @ref pilfer :

    @code

    @code

    {

    {

        T t1;                       // default construction

        T t1;                       // default construction

        T t2( pilfer( t1 ) );       // pilfer-construct from t1

        T t2( pilfer( t1 ) );       // pilfer-construct from t1

        // At this point, t1 may only be destroyed

        // At this point, t1 may only be destroyed

    }

    }

    @endcode

    @endcode

    @see @ref pilfered, @ref is_pilfer_constructible,

    @see @ref pilfered, @ref is_pilfer_constructible,

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

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

        Valueless Variants Considered Harmful</a>

        Valueless Variants Considered Harmful</a>

*/

*/

template<class T>

template<class T>

auto

auto

    typename std::conditional<

    typename std::conditional<

        std::is_nothrow_constructible<

        std::is_nothrow_constructible<

            typename std::remove_reference<T>::type,

            typename std::remove_reference<T>::type,

            pilfered<typename

            pilfered<typename

                std::remove_reference<T>::type> >::value &&

                std::remove_reference<T>::type> >::value &&

        ! std::is_nothrow_constructible<

        ! std::is_nothrow_constructible<

            typename std::remove_reference<T>::type,

            typename std::remove_reference<T>::type,

            detail_pilfer::not_pilfered<typename

            detail_pilfer::not_pilfered<typename

                std::remove_reference<T>::type> >::value,

                std::remove_reference<T>::type> >::value,

        pilfered<typename std::remove_reference<T>::type>,

        pilfered<typename std::remove_reference<T>::type>,

        typename std::remove_reference<T>::type&&

        typename std::remove_reference<T>::type&&

            >::type

            >::type

{

{

    using U =

    using U =

        typename std::remove_reference<T>::type;

        typename std::remove_reference<T>::type;

    BOOST_CORE_STATIC_ASSERT( is_pilfer_constructible<U>::value );

    BOOST_CORE_STATIC_ASSERT( is_pilfer_constructible<U>::value );

    return typename std::conditional<

    return typename std::conditional<

        std::is_nothrow_constructible<

        std::is_nothrow_constructible<

            U, pilfered<U> >::value &&

            U, pilfered<U> >::value &&

        ! std::is_nothrow_constructible<

        ! std::is_nothrow_constructible<

            U, detail_pilfer::not_pilfered<U> >::value,

            U, detail_pilfer::not_pilfered<U> >::value,

        pilfered<U>, U&&

        pilfered<U>, U&&

}

}

/*

/*

template<class T>

template<class T>

void

void

relocate(T* dest, T& src) noexcept

relocate(T* dest, T& src) noexcept

{

{

    BOOST_CORE_STATIC_ASSERT( is_pilfer_constructible<T>::value );

    BOOST_CORE_STATIC_ASSERT( is_pilfer_constructible<T>::value );

    ::new(dest) T(pilfer(src));

    ::new(dest) T(pilfer(src));

    src.~T();

    src.~T();

}

}

*/

*/

} // json

} // json

} // boost

} // boost

#endif

#endif