//
// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
//
// 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)
//
// Official repository: https://github.com/boostorg/json
//

#ifndef BOOST_JSON_PILFER_HPP
#define BOOST_JSON_PILFER_HPP

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

/*
    Implements "pilfering" from P0308R0

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

namespace boost {
namespace json {

/** Tag wrapper to specify pilfer-construction.

    This wrapper is used to specify a pilfer constructor
    overload.

    @par Example

    A pilfer constructor accepts a single argument
    of type @ref pilfered and throws nothing:

    @code
    struct T
    {
        T( pilfered<T> ) noexcept;
    };
    @endcode

    @note

    The constructor should not be marked explicit.

    @see @ref pilfer, @ref is_pilfer_constructible,
    <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html">
        Valueless Variants Considered Harmful</a>
*/
template<class T>
class pilfered
{
    T& t_;

public:
    /** Constructor

        Construct the wrapper from `t`.

        @param t The pilferable object. Ownership
        is not transferred.
    */
    explicit
    constexpr
    pilfered(T&& t) noexcept
        : t_(t)
    {
    }

    /** Return a reference to the pilferable object.

        This returns a reference to the wrapped object.
    */
    constexpr T&
    get() const noexcept
    {
        return t_;
    }

    /** Return a pointer to the pilferable object.

        This returns a pointer to the wrapped object.
    */
    constexpr T*
    operator->() const noexcept
    {
        //return std::addressof(t_);
        return reinterpret_cast<T*>(
            const_cast<char *>(
                &reinterpret_cast<
                    const volatile char &>(t_)));
    }
};

#ifndef BOOST_JSON_DOCS
// VFALCO Renamed this to work around an msvc bug
namespace detail_pilfer {
template<class>
struct not_pilfered
{
};
} // detail_pilfer
#endif

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

    If `T` can be pilfer constructed, this metafunction is
    equal to `std::true_type`. Otherwise it is equal to
    `std::false_type`.

    @see @ref pilfer, @ref pilfered,
    <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html">
        Valueless Variants Considered Harmful</a>
*/
template<class T>
struct is_pilfer_constructible
#ifndef BOOST_JSON_DOCS
    : std::integral_constant<bool,
        std::is_nothrow_move_constructible<T>::value ||
        (
            std::is_nothrow_constructible<
                T, pilfered<T> >::value &&
            ! std::is_nothrow_constructible<
                T, detail_pilfer::not_pilfered<T> >::value
        )>
#endif
{
};

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

    A <em>pilfer</em> operation is the construction
    of a new object of type `T` from an existing
    object `t`. After the construction, the only
    valid operation on the pilfered-from object is
    destruction. This permits optimizations beyond
    those available for a move-construction, as the
    pilfered-from object is not required to be in
    a "usable" state.
\n
    This is used similarly to `std::move`.

    @par Example

    A pilfer constructor accepts a single argument
    of type @ref pilfered and throws nothing:

    @code
    struct T
    {
        T( pilfered<T> ) noexcept;
    };
    @endcode

    Pilfer construction is performed using @ref pilfer :

    @code
    {
        T t1;                       // default construction
        T t2( pilfer( t1 ) );       // pilfer-construct from t1

        // At this point, t1 may only be destroyed
    }
    @endcode

    @see @ref pilfered, @ref is_pilfer_constructible,
    <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html">
        Valueless Variants Considered Harmful</a>
*/
template<class T>
auto
pilfer(T&& t) noexcept ->
    typename std::conditional<
        std::is_nothrow_constructible<
            typename std::remove_reference<T>::type,
            pilfered<typename
                std::remove_reference<T>::type> >::value &&
        ! std::is_nothrow_constructible<
            typename std::remove_reference<T>::type,
            detail_pilfer::not_pilfered<typename
                std::remove_reference<T>::type> >::value,
        pilfered<typename std::remove_reference<T>::type>,
        typename std::remove_reference<T>::type&&
            >::type
{
    using U =
        typename std::remove_reference<T>::type;
    static_assert(
        is_pilfer_constructible<U>::value, "");
    return typename std::conditional<
        std::is_nothrow_constructible<
            U, pilfered<U> >::value &&
        ! std::is_nothrow_constructible<
            U, detail_pilfer::not_pilfered<U> >::value,
        pilfered<U>, U&&
            >::type(std::move(t));
}

/*
template<class T>
void
relocate(T* dest, T& src) noexcept
{
    static_assert(
        is_pilfer_constructible<T>::value, "");
    ::new(dest) T(pilfer(src));
    src.~T();
}
*/

} // json
} // boost


#endif