reference_wrapper.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_UTILITY_REFERENCE_WRAPPER_HPP__
#define NEFORCE_CORE_UTILITY_REFERENCE_WRAPPER_HPP__

 
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__
 
NEFORCE_BEGIN_INNER__
 
template <typename T>
void __ref_wrapper_construct_aux(type_identity_t<T&>) noexcept;
template <typename T>
void __ref_wrapper_construct_aux(type_identity_t<T&&>) = delete;
 
 
template <typename T, typename U, typename Dummy = void>
struct ref_wrapper_constructable_from : false_type {};
 
template <typename T, typename U>
struct ref_wrapper_constructable_from<T, U,
                                      void_t<decltype(inner::__ref_wrapper_construct_aux<T>(_NEFORCE declval<U>()))>>
: true_type {};
 
 
template <typename F, typename... Args>
struct __invoke_result_aux;

NEFORCE_END_INNER__
 
template <typename F, typename... Args>
struct is_nothrow_invocable;
 
template <typename Callable, typename... Args>
NEFORCE_CONSTEXPR14 typename inner::__invoke_result_aux<Callable, Args...>::type
invoke(Callable&& f, Args&&... args) noexcept(is_nothrow_invocable<Callable, Args...>::value);


template <typename T>
class reference_wrapper {
public:
    static_assert(is_object<T>::value || is_function<T>::value,
                  "reference_wrapper requires an object or function type.");
 
    using type = T; 
 
private:
    T* ptr_{}; 
 
public:
    template <typename U, enable_if_t<conjunction<negation<is_same<remove_cvref_t<U>, reference_wrapper>>,
                                                  inner::ref_wrapper_constructable_from<T, U>>::value,
                                      int> = 0>
    NEFORCE_CONSTEXPR14
    reference_wrapper(U&& x) noexcept(noexcept(inner::__ref_wrapper_construct_aux<T>(_NEFORCE declval<U>()))) {
        T& ref = static_cast<U&&>(x);
        ptr_ = _NEFORCE addressof(ref);
    }

    NEFORCE_CONSTEXPR14 operator T&() const noexcept { return *ptr_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR14 T& get() const noexcept { return *ptr_; }

    template <typename... Args>
    NEFORCE_CONSTEXPR14 typename inner::__invoke_result_aux<T&, Args...>::type operator()(Args&&... args) const
            noexcept(is_nothrow_invocable<T&, Args...>::value) {
        return _NEFORCE invoke(this->get(), _NEFORCE forward<Args>(args)...);
    }
};
 
#ifdef NEFORCE_STANDARD_17
template <typename T>
reference_wrapper(T&) -> reference_wrapper<T>;
#endif
 

template <typename T>
NEFORCE_NODISCARD constexpr reference_wrapper<T> ref(T& val) noexcept {
    return reference_wrapper<T>(val);
}

template <typename T>
void ref(const T&&) = delete;

template <typename T>
NEFORCE_NODISCARD constexpr reference_wrapper<T> ref(reference_wrapper<T> wrapper) noexcept {
    return wrapper;
}

template <typename T>
NEFORCE_NODISCARD constexpr reference_wrapper<const T> cref(const T& val) noexcept {
    return reference_wrapper<const T>(val);
}

template <typename T>
void cref(const T&&) = delete;

template <typename T>
NEFORCE_NODISCARD constexpr reference_wrapper<const T> cref(reference_wrapper<T> wrapper) noexcept {
    return wrapper;
}
 

template <typename T>
struct unwrap_reference {
    using type = T;
};

template <typename T>
struct unwrap_reference<reference_wrapper<T>> {
    using type = T&;
};

template <typename T>
using unwrap_reference_t = typename unwrap_reference<T>::type;
 

template <typename T>
struct unwrap_ref_decay {
    using type = unwrap_reference_t<decay_t<T>>;
};

template <typename T>
using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
 // ReferenceWrapper
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_UTILITY_REFERENCE_WRAPPER_HPP__