unwrap.h

#pragma once
 
#include <ozo/core/nullable.h>
#include <ozo/core/concept.h>
#include <ozo/detail/functional.h>
 
#include <boost/hana/core/when.hpp>
 
namespace ozo {
 
namespace hana = boost::hana;
 
template <typename T, typename When = hana::when<true>>
struct unwrap_impl : detail::functional::forward {};
 
template <typename T>
constexpr decltype(auto) unwrap(T&& v) noexcept(
        noexcept(unwrap_impl<std::decay_t<T>>::apply(std::forward<T>(v)))) {
    return unwrap_impl<std::decay_t<T>>::apply(std::forward<T>(v));
}
 
template <typename T>
struct unwrap_impl<std::reference_wrapper<T>> {
    template <typename Ref>
    constexpr static decltype(auto) apply(Ref&& v) noexcept {
        return v.get();
    }
};
 
template <typename T>
struct get_unwrapped_type {
#ifdef OZO_DOCUMENTATION
    using type = <unwrapped type>; 
#else
    using type = std::decay_t<decltype(ozo::unwrap(std::declval<T>()))>;
#endif
};
 
template <typename T>
using unwrap_type = typename get_unwrapped_type<T>::type;
 
} // namespace ozo