MtFmt: inc/mm_result.hpp 源文件

浏览该文件的文档.
// SPDX-License-Identifier: LGPL-3.0
#if !defined(_INCLUDE_MM_RESULT_HPP_)
#define _INCLUDE_MM_RESULT_HPP_ 1
#include "mm_result.h"
#include "mm_type.hpp"
namespace mtfmt
{
// class decl
template <typename T, typename E> class result;
 
namespace details
{
template <typename... Targ> struct result_storager_type
{
    static constexpr std::size_t size =
        max_value<sizeof(Targ)...>::value;
 
    static constexpr std::size_t align =
        max_value<alignof(Targ)...>::value;
 
    using storager_t = typename std::aligned_storage<size, align>::type;
};
 
template <typename T, typename E> class result_non_trivial_base
{
    using dtor_t = typename std::add_pointer<void(void*)>::type;
    using storager_t = typename result_storager_type<T, E>::storager_t;
 
    storager_t storager;
 
    dtor_t dtor;
 
    static void dtor_succ_type(void* ptr) noexcept
    {
        return (*reinterpret_cast<T*>(ptr)).~T();
    }
 
    static void dtor_err_type(void* ptr) noexcept
    {
        return (*reinterpret_cast<E*>(ptr)).~E();
    }
 
public:
    using value_type = T;
    using error_type = E;
    using reference_value_type = T&;
    using reference_error_type = E&;
    using const_reference_value_type = const T&;
    using const_reference_error_type = const E&;
 
    result_non_trivial_base(const_reference_value_type succ_val)
        : dtor(dtor_succ_type), type_tag(TypeTag::SuccTag)
    {
        unsafe_set_succ_value(succ_val);
    }
 
    result_non_trivial_base(const_reference_error_type err_val)
        : dtor(dtor_err_type), type_tag(TypeTag::ErrorTag)
    {
        unsafe_set_err_value(err_val);
    }
 
    result_non_trivial_base(const result_non_trivial_base& rhs)
        : type_tag(rhs.type_tag)
    {
        if (type_tag == TypeTag::SuccTag) {
            const T& value = *reinterpret_cast<const T*>(&storager);
            unsafe_set_succ_value(value);
            // 更新析构
            dtor = dtor_succ_type;
        }
        else {
            mstr_assert(type_tag == TypeTag::ErrorTag);
            const E& value = *reinterpret_cast<const E*>(&storager);
            unsafe_set_err_value(value);
            // 更新析构
            dtor = dtor_err_type;
        }
    }
 
    result_non_trivial_base& operator=(
        const result_non_trivial_base& rhs
    )
    {
        this->~result_non_trivial_base();
        if (rhs.type_tag == TypeTag::SuccTag) {
            const T& value = *reinterpret_cast<const T*>(&rhs.storager);
            unsafe_set_succ_value(value);
            // 更新析构
            dtor = dtor_succ_type;
        }
        else {
            mstr_assert(rhs.type_tag == TypeTag::ErrorTag);
            const E& value = *reinterpret_cast<const E*>(&rhs.storager);
            unsafe_set_err_value(value);
            // 更新析构
            dtor = dtor_err_type;
        }
        return *this;
    }
 
    ~result_non_trivial_base()
    {
        mstr_assert(dtor != nullptr);
        dtor(reinterpret_cast<void*>(&storager));
        dtor = nullptr;
    }
 
protected:
    enum class TypeTag
    {
        SuccTag = 0,
        ErrorTag = 1
    };
 
    TypeTag type_tag;
 
    enable_if_t<
        std::is_copy_constructible<T>::value,
        const_reference_value_type>
        unsafe_get_succ_value() const noexcept
    {
        mstr_assert(type_tag == TypeTag::SuccTag);
        return *reinterpret_cast<const T*>(&storager);
    }
 
    enable_if_t<
        std::is_copy_constructible<E>::value,
        const_reference_error_type>
        unsafe_get_err_value() const noexcept
    {
        mstr_assert(type_tag == TypeTag::ErrorTag);
        return *reinterpret_cast<const E*>(&storager);
    }
 
    enable_if_t<
        std::is_copy_constructible<T>::value,
        reference_value_type>
        unsafe_get_succ_value_mut() noexcept
    {
        mstr_assert(type_tag == TypeTag::SuccTag);
        return *reinterpret_cast<T*>(&storager);
    }
 
    enable_if_t<
        std::is_copy_constructible<E>::value,
        reference_error_type>
        unsafe_get_err_value_mut() noexcept
    {
        mstr_assert(type_tag == TypeTag::ErrorTag);
        return *reinterpret_cast<E*>(&storager);
    }
 
private:
    enable_if_t<std::is_copy_constructible<T>::value, void>
        unsafe_set_succ_value(const T& value) noexcept
    {
        type_tag = TypeTag::SuccTag;
        void* ptr = reinterpret_cast<void*>(&storager);
        // 用placement new把对象放到 storager 里面
        new (ptr) T(value);
    }
 
    enable_if_t<std::is_copy_constructible<E>::value, void>
        unsafe_set_err_value(const E& value) noexcept
    {
        type_tag = TypeTag::ErrorTag;
        void* ptr = reinterpret_cast<void*>(&storager);
        new (ptr) E(value);
    }
};
 
template <typename T, typename E> class result_trivial_base
{
    union {
        T t_val;
        E e_val;
    };
 
public:
    using value_type = T;
    using error_type = E;
    using reference_value_type = T&;
    using reference_error_type = E&;
    using const_reference_value_type = const T&;
    using const_reference_error_type = const E&;
 
    constexpr result_trivial_base(T succ_val)
        : t_val(succ_val), type_tag(TypeTag::SuccTag)
    {
    }
 
    constexpr result_trivial_base(E err_val)
        : e_val(err_val), type_tag(TypeTag::ErrorTag)
    {
    }
 
    //
    // ctor为default, assign为default
    // trivial destructor不会执行任何东东
    // 所以都可以default啦 !!!
    //
 
    result_trivial_base(result_trivial_base&&) = default;
    result_trivial_base(const result_trivial_base&) = default;
 
    result_trivial_base& operator=(result_trivial_base&&) = default;
    result_trivial_base& operator=(const result_trivial_base&) =
        default;
 
    ~result_trivial_base() = default;
 
protected:
    enum class TypeTag
    {
        SuccTag = 0,
        ErrorTag = 1
    };
 
    TypeTag type_tag;
 
    const_reference_value_type unsafe_get_succ_value() const noexcept
    {
        mstr_assert(type_tag == TypeTag::SuccTag);
        return t_val;
    }
 
    const_reference_error_type unsafe_get_err_value() const noexcept
    {
        mstr_assert(type_tag == TypeTag::ErrorTag);
        return e_val;
    }
 
    reference_value_type unsafe_get_succ_value_mut() noexcept
    {
        mstr_assert(type_tag == TypeTag::SuccTag);
        return t_val;
    }
 
    reference_error_type unsafe_get_err_value_mut() noexcept
    {
        mstr_assert(type_tag == TypeTag::ErrorTag);
        return e_val;
    }
};
 
template <typename T> struct is_result
{
    static constexpr bool value =
        details::is_instance_of<result, T>::value;
};
 
template <typename T> struct is_trivial_or_trivial_result
{
    static constexpr bool value = std::is_trivial<T>::value;
};
 
template <typename... T>
struct is_trivial_or_trivial_result<result<T...>>
{
    static constexpr bool value =
        disjunction<is_trivial_or_trivial_result<T>::value...>::value;
};
 
template <typename T, typename E> struct is_trivial_result
{
    static constexpr bool value =
        is_trivial_or_trivial_result<T>::value &&
        is_trivial_or_trivial_result<E>::value;
};
 
template <typename T, typename E>
using result_base_t = typename std::conditional<
    is_trivial_result<T, E>::value,
    result_trivial_base<T, E>,
    result_non_trivial_base<T, E>>::type;
 
} // namespace details
 
using unit_t = details::unit_t;
 
using error_code_t = mstr_result_t;
 
class mtfmt_error : std::exception
{
public:
    explicit mtfmt_error(error_code_t) : std::exception()
    {
    }
};
 
template <typename T, typename E>
class result final : public details::result_base_t<T, E>
{
public:
    using base_t = details::result_base_t<T, E>;
    using value_type = typename base_t::value_type;
    using error_type = typename base_t::error_type;
    using reference_value_type = typename base_t::reference_value_type;
    using reference_error_type = typename base_t::reference_error_type;
    using const_reference_value_type =
        typename base_t::const_reference_value_type;
    using const_reference_error_type =
        typename base_t::const_reference_error_type;
    using base_t::base_t;
 
    bool is_succ() const noexcept
    {
        return base_t::type_tag == base_t::TypeTag::SuccTag;
    }
 
    bool is_err() const noexcept
    {
        return !is_succ();
    }
 
    const_reference_value_type unsafe_get_succ_value() const noexcept
    {
        return base_t::unsafe_get_succ_value();
    }
 
    const_reference_error_type unsafe_get_err_value() const noexcept
    {
        return base_t::unsafe_get_err_value();
    }
 
    reference_value_type unsafe_get_succ_value_mut() noexcept
    {
        return base_t::unsafe_get_succ_value_mut();
    }
 
    reference_error_type unsafe_get_err_value_mut() noexcept
    {
        return base_t::unsafe_get_err_value_mut();
    }
 
    result<E, T> conjugate() const noexcept
    {
        if (is_succ()) {
            return unsafe_get_succ_value();
        }
        else {
            return unsafe_get_err_value();
        }
    }
 
    template <typename T1 = T>
    details::enable_if_t<
        details::is_result<T1>::value,
        result<typename T1::value_type, E>>
        flatten() const noexcept
    {
        static_assert(std::is_same<typename T1::error_type, E>::value);
        if (is_succ()) {
            const auto& ref_succ = unsafe_get_succ_value();
            if (ref_succ.is_succ()) {
                return ref_succ.unsafe_get_succ_value();
            }
            else {
                return ref_succ.unsafe_get_err_value();
            }
        }
        else {
            return unsafe_get_err_value();
        }
    }
 
    template <typename T1 = T>
    details::enable_if_t<!details::is_result<T1>::value, result<T1, E>>
        flatten() const noexcept
    {
        return *this;
    }
 
    template <
        typename F,
        typename R = details::function_return_type_t<F>>
    details::enable_if_t<
        details::holds_prototype<F, R, T>::value,
        result<R, E>>
        map(F map_to) const
    {
        if (is_succ()) {
            return map_to(base_t::unsafe_get_succ_value());
        }
        else {
            return base_t::unsafe_get_err_value();
        }
    }
 
    template <
        typename F,
        typename R = details::function_return_type_t<F>>
    details::enable_if_t<
        details::holds_prototype<F, R, E>::value,
        result<T, R>>
        map_err(F map_to) const
    {
        if (is_succ()) {
            return base_t::unsafe_get_succ_value();
        }
        else {
            return map_to(base_t::unsafe_get_err_value());
        }
    }
 
    template <
        typename F,
        typename R1 = details::function_return_type_t<F>,
        typename R = details::enable_if_t<
            details::is_result<R1>::value,
            typename R1::value_type>>
    details::enable_if_t<
        details::holds_prototype<F, result<R, E>, T>::value,
        result<R, E>>
        and_then(F then_do) const
    {
        if (is_succ()) {
            return then_do(base_t::unsafe_get_succ_value());
        }
        else {
            return base_t::unsafe_get_err_value();
        }
    }
 
    template <
        typename F,
        typename R1 = details::function_return_type_t<F>,
        typename R = details::enable_if_t<
            details::is_result<R1>::value,
            typename R1::error_type>>
    details::enable_if_t<
        details::holds_prototype<F, result<T, R>, E>::value,
        result<T, R>>
        or_else(F else_do) const
    {
        if (is_succ()) {
            return base_t::unsafe_get_succ_value();
        }
        else {
            return else_do(base_t::unsafe_get_err_value());
        }
    }
 
    const_reference_value_type or_value(
        const_reference_value_type or_val
    ) const noexcept
    {
        if (is_succ()) {
            return base_t::unsafe_get_succ_value();
        }
        else {
            return or_val;
        }
    }
 
    template <
        typename F,
        typename R1 = details::function_return_type_t<F>,
        typename R = details::
            enable_if_t<std::is_base_of<std::exception, R1>::value, R1>>
    details::enable_if_t<
        details::holds_prototype<F, R, E>::value,
        const_reference_value_type>
        or_exception(F cont) const
    {
        if (is_succ()) {
            return base_t::unsafe_get_succ_value();
        }
        else {
#if _MSTR_USE_CPP_EXCEPTION
            throw cont(base_t::unsafe_get_err_value());
#else
            (void)cont;
            mstr_cause_exception(base_t::unsafe_get_err_value());
#endif // _MSTR_USE_CPP_EXCEPTION
        }
    }
};
} // namespace mtfmt
#endif // _INCLUDE_MM_RESULT_HPP_