ResultValue.h

#pragma once

#include "Result.h"

#include <type_traits>
#include <utility>
#include <cassert>

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)
        {}

        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)
        {}

        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));
    }
}