reference_wrapper.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_FUNCTIONAL_REFERENCE_WRAPPER_HPP
#define TETL_FUNCTIONAL_REFERENCE_WRAPPER_HPP
 
#include <etl/_functional/invoke.hpp>
#include <etl/_memory/addressof.hpp>
#include <etl/_type_traits/declval.hpp>
#include <etl/_type_traits/enable_if.hpp>
#include <etl/_type_traits/invoke_result.hpp>
#include <etl/_type_traits/is_same.hpp>
#include <etl/_type_traits/remove_cvref.hpp>
#include <etl/_utility/forward.hpp>
 
namespace etl {
 
namespace detail {
template <typename T>
constexpr auto FUN(T& t) noexcept -> T&
{
    return t; // NOLINT(bugprone-return-const-ref-from-parameter)
}
 
template <typename T>
void FUN(T&&) = delete;
 
} // namespace detail

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

    template <
        typename U,
        typename
        = decltype(detail::FUN<T>(declval<U>()), enable_if_t<!is_same_v<reference_wrapper, remove_cvref_t<U>>>())>
    constexpr reference_wrapper(U&& u) noexcept(noexcept(detail::FUN<T>(etl::forward<U>(u))))
        : _ptr(addressof(detail::FUN<T>(etl::forward<U>(u))))
    {
    }

    constexpr reference_wrapper(reference_wrapper const& x) noexcept = default;

    constexpr auto operator=(reference_wrapper const& x) noexcept -> reference_wrapper& = default;

    [[nodiscard]] constexpr operator type&() const noexcept { return *_ptr; }

    [[nodiscard]] constexpr auto get() const noexcept -> type& { return *_ptr; }

    template <typename... Args>
    constexpr auto operator()(Args&&... args) const noexcept(noexcept(invoke(get(), etl::forward<Args>(args)...)))
        -> invoke_result_t<T&, Args...>
    {
        return invoke(get(), etl::forward<Args>(args)...);
    }
 
private:
    type* _ptr;
};
 
// One deduction guide is provided for reference_wrapper to support
// deduction of the sole class template parameter.
template <typename T>
reference_wrapper(T&) -> reference_wrapper<T>;

template <typename T>
[[nodiscard]] constexpr auto ref(T& t) noexcept -> reference_wrapper<T>
{
    return reference_wrapper<T>(t);
}

template <typename T>
[[nodiscard]] constexpr auto ref(reference_wrapper<T> t) noexcept -> reference_wrapper<T>
{
    return ref(t.get());
}

template <typename T>
[[nodiscard]] constexpr auto cref(T const& t) noexcept -> reference_wrapper<T const>
{
    return reference_wrapper<T const>(t);
}
 
template <typename T>
[[nodiscard]] constexpr auto cref(reference_wrapper<T> t) noexcept -> reference_wrapper<T const>
{
    return cref(t.get());
}
 
template <typename T>
void cref(T const&&) = delete;
 
} // namespace etl
 
#endif // TETL_FUNCTIONAL_REFERENCE_WRAPPER_HPP