ResultValue.h

#pragma once
 
#include <fsdk/Types/Result.h>
 
#include <cassert>
#include <type_traits>
#include <utility>
 
namespace fsdk {
    template <typename R, typename V, class Enable = void>
    struct ResultValue : Result<R> {};
 
    template <typename R, typename V>
    struct ResultValue<R, V, typename std::enable_if<std::is_copy_constructible<V>::value>::type> : Result<R> {
        typedef R EnumType;
 
        typedef V ValueType;
 
        ResultValue(R result) noexcept
            : Result<R>(result)
            , m_value{} {
        }
 
        ResultValue(R result, const V& value) noexcept
            : Result<R>(result)
            , m_value(value) {
        }
 
        ResultValue(R result, V&& value) noexcept
            : Result<R>(result)
            , m_value(std::move(value)) {
        }
 
        const V& getValue() const noexcept {
            assert(this->isOk() && "Acessing value of erroneous result.");
            return m_value;
        }
 
        V&& takeValue() noexcept {
            return std::move(m_value);
        }
 
        const V* operator->() const noexcept {
            return &getValue();
        }
 
    protected:
        V m_value; 
    };
 
    template <typename R, typename V>
    struct ResultValue<R, V, typename std::enable_if<std::is_copy_constructible<V>::value == false>::type> :
        Result<R> {
        typedef R EnumType;
 
        typedef V ValueType;
 
        ResultValue(R result) noexcept
            : Result<R>(result)
            , m_value{} {
        }
 
        ResultValue(R result, V&& value) noexcept
            : Result<R>(result)
            , m_value(std::move(value)) {
        }
 
        const V& getValue() const noexcept {
            assert(this->isOk() && "Acessing value of erroneous result.");
            return m_value;
        }
 
        V&& takeValue() noexcept {
            return std::move(m_value);
        }
 
        const V* operator->() const noexcept {
            return &getValue();
        }
 
    protected:
        V m_value; 
    };
 
    template <typename R, typename V>
    inline ResultValue<R, typename std::remove_const<typename std::remove_reference<V>::type>::type>
    makeResultValue(R result, V&& value) noexcept {
        return ResultValue<R, typename std::remove_const<typename std::remove_reference<V>::type>::type>(
            result,
            std::forward<V>(value));
    }
} // namespace fsdk