result.h

#ifndef RESULT_H
#define RESULT_H
 
#include "./error_code.h"
#include "./optional.h"
 
namespace ara
{
    namespace core
    {
        template <typename T, typename E = ErrorCode>
        class Result final
        {
        private:
            Optional<T> mValue;
            Optional<E> mError;
 
        public:
            using value_type = T;
            using error_type = E;
 
            Result() = delete;
 
            Result(const T &t) noexcept(
                std::is_nothrow_copy_constructible<T>::value) : mValue{t}
            {
            }
 
            Result(T &&t) noexcept(
                std::is_nothrow_move_constructible<T>::value) : mValue{std::move(t)}
            {
            }
 
            explicit Result(const E &e) noexcept(
                std::is_nothrow_copy_constructible<E>::value) : mError{e}
            {
            }
 
            explicit Result(E &&e) noexcept(
                std::is_nothrow_move_constructible<E>::value) : mError{std::move(e)}
            {
            }
 
            Result(const Result &other) noexcept(
                std::is_nothrow_copy_assignable<T>::value &&
                    std::is_nothrow_copy_assignable<E>::value)
            {
                // Copy the value if it exists, otherwise copy the error
                if (other.HasValue())
                {
                    mValue = other.mValue;
                }
                else
                {
                    mError = other.mError;
                }
            }
 
            Result(Result &&other) noexcept(
                std::is_nothrow_move_assignable<T>::value &&
                    std::is_nothrow_move_assignable<E>::value)
            {
                // Move the value if it exists, otherwise move the error
                if (other.HasValue())
                {
                    mValue = std::move(other.mValue);
                }
                else
                {
                    mError = std::move(other.mError);
                }
            }
 
            ~Result() noexcept = default;
 
            static Result FromValue(const T &t) noexcept(
                std::is_nothrow_copy_constructible<T>::value);
 
            static Result FromValue(T &&t) noexcept(
                std::is_nothrow_move_constructible<T>::value);
 
            static Result FromError(const E &e) noexcept(
                std::is_nothrow_copy_constructible<E>::value);
 
            static Result FromError(E &&e) noexcept(
                std::is_nothrow_move_constructible<E>::value);
 
            Result &operator=(Result const &other) noexcept(
                std::is_nothrow_copy_assignable<T>::value &&
                    std::is_nothrow_copy_assignable<E>::value)
            {
                // Copy the value if it exists and reset the error, otherwise copy the error and reset the value
                if (other.HasValue())
                {
                    mValue = other.mValue;
                    mError.Reset();
                }
                else
                {
                    mError = other.mError;
                    mValue.Reset();
                }
 
                return *this;
            }
 
            Result &operator=(Result &&other) noexcept(
                std::is_nothrow_move_assignable<T>::value &&
                    std::is_nothrow_move_assignable<E>::value)
            {
                // Move the value if it exists and reset the error, otherwise move the error and reset the value
                if (other.HasValue())
                {
                    mValue = std::move(other.mValue);
                    mError.Reset();
                }
                else
                {
                    mError = std::move(other.mError);
                    mValue.Reset();
                }
 
                return *this;
            }
 
            template <typename... Args>
            void EmplaceValue(Args &&...args)
            {
                mValue = T{std::move(args...)};
                mError.Reset();
            }
 
            template <typename... Args>
            void EmplaceError(Args &&...args)
            {
                mError = E{std::move(args...)};
                mValue.Reset();
            }
 
            void Swap(Result &other) noexcept(
                std::is_nothrow_move_assignable<T>::value &&
                    std::is_nothrow_move_assignable<E>::value)
            {
                if (HasValue() && other.HasValue())
                {
                    std::swap(mValue, other.mValue);
                }
                else if (HasValue() && !other.HasValue())
                {
                    mError = std::move(other.mError);
                    other.mValue = std::move(mValue);
                }
                else if (!HasValue() && other.HasValue())
                {
                    mValue = std::move(other.mValue);
                    other.mError = std::move(mError);
                }
                else // Both instances contain error
                {
                    std::swap(mError, other.mError);
                }
            }
 
            bool HasValue() const noexcept
            {
                return mValue.HasValue();
            }
 
            explicit operator bool() const noexcept
            {
                return HasValue();
            }
 
            const T &operator*() const &
            {
                return mValue.Value();
            }
 
            T &&operator*() &&
            {
                return std::move(mValue).Value();
            }
 
            const T *operator->() const
            {
                return &mValue.Value();
            }
 
            const T &Value() const &
            {
                return mValue.Value();
            }
 
            T &&Value() &&
            {
                return std::move(mValue).Value();
            }
 
            const E &Error() const &
            {
                return mError.Value();
            }
 
            E &&Error() &&
            {
                return std::move(mError).Value();
            }
 
            Optional<T> Ok() const &
            {
                return mValue;
            }
 
            Optional<T> Ok() &&
            {
                return std::move(mValue);
            }
 
            Optional<E> Err() const &
            {
                return mError;
            }
 
            Optional<E> Err() &&
            {
                return std::move(mError);
            }
 
            template <typename U>
            T ValueOr(U &&defaultValue) const &
            {
                return mValue.ValueOr(defaultValue);
            }
 
            template <typename U>
            T ValueOr(U &&defaultValue) &&
            {
                return std::move(mValue).ValueOr(defaultValue);
            }
 
            template <typename G>
            E ErrorOr(G &&defaultError) const &
            {
                return mError.ValueOr(defaultError);
            }
 
            template <typename G>
            E ErrorOr(G &&defaultError) &&
            {
                return std::move(mError).ValueOr(defaultError);
            }
 
            template <typename G>
            bool CheckError(G &&error) const
            {
                if (HasValue())
                {
                    // No error exists for comparison
                    return false;
                }
                else
                {
                    E _error = static_cast<E>(error);
                    return mError.Value() == _error;
                }
            }
 
            const T &ValueOrThrow() const &noexcept(false)
            {
                return mValue.Value();
            }
 
            T &&ValueOrThrow() &&noexcept(false)
            {
                return std::move(mValue).Value();
            }
 
            template <typename F>
            T Resolve(F &&f) const
            {
                return HasValue() ? Value() : f(Error());
            }
 
            template <typename F>
            auto Bind(F &&f) const -> Result<decltype(f(Value())), E>
            {
                if (HasValue())
                {
                    Result<decltype(f(Value())), E> _result{f(Value())};
                    return _result;
                }
                else
                {
                    Result<decltype(f(Value())), E> _result{Error()};
                    return _result;
                }
            }
        };
 
        template <typename T, typename E>
        Result<T, E> Result<T, E>::FromValue(const T &t) noexcept(
            std::is_nothrow_copy_constructible<T>::value)
        {
            Result _result{t};
            return _result;
        }
 
        template <typename T, typename E>
        Result<T, E> Result<T, E>::FromValue(T &&t) noexcept(
            std::is_nothrow_move_constructible<T>::value)
        {
            Result _result{std::move(t)};
            return _result;
        }
 
        template <typename T, typename E>
        Result<T, E> Result<T, E>::FromError(const E &e) noexcept(
            std::is_nothrow_copy_constructible<E>::value)
        {
            Result _result{e};
            return _result;
        }
 
        template <typename T, typename E>
        Result<T, E> Result<T, E>::FromError(E &&e) noexcept(
            std::is_nothrow_move_constructible<E>::value)
        {
            Result _result{std::move(e)};
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator==(const Result<T, E> &lhs, const Result<T, E> &rhs)
        {
            bool _result;
 
            if (lhs.HasValue() && rhs.HasValue())
            {
                _result = lhs.Value() == rhs.Value();
            }
            else if (!lhs.HasValue() && !rhs.HasValue())
            {
                _result = lhs.Error() == rhs.Error();
            }
            else
            {
                _result = false;
            }
 
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator!=(const Result<T, E> &lhs, const Result<T, E> &rhs)
        {
            bool _result;
 
            if (lhs.HasValue() && rhs.HasValue())
            {
                _result = lhs.Value() != rhs.Value();
            }
            else if (!lhs.HasValue() && !rhs.HasValue())
            {
                _result = lhs.Error() != rhs.Error();
            }
            else
            {
                _result = true;
            }
 
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator==(const Result<T, E> &lhs, const T &rhs)
        {
            bool _result = lhs.HasValue() ? lhs.Value() == rhs : false;
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator==(const T &lhs, const Result<T, E> &rhs)
        {
            bool _result = rhs.HasValue() ? lhs == rhs.Value() : false;
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator!=(const Result<T, E> &lhs, const T &rhs)
        {
            bool _result = lhs.HasValue() ? lhs.Value() != rhs : true;
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator!=(const T &lhs, const Result<T, E> &rhs)
        {
            bool _result = rhs.HasValue() ? lhs != rhs.Value() : true;
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator==(const Result<T, E> &lhs, const E &rhs)
        {
            bool _result = lhs.HasValue() ? false : lhs.Error() == rhs;
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator==(const E &lhs, const Result<T, E> &rhs)
        {
            bool _result = rhs.HasValue() ? false : lhs == rhs.Error();
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator!=(const Result<T, E> &lhs, const E &rhs)
        {
            bool _result = lhs.HasValue() ? true : lhs.Error() != rhs;
            return _result;
        }
 
        template <typename T, typename E>
        inline bool operator!=(const E &lhs, const Result<T, E> &rhs)
        {
            bool _result = rhs.HasValue() ? true : lhs != rhs.Error();
            return _result;
        }
 
        template <typename E>
        class Result<void, E> final
        {
        private:
            Optional<E> mError;
 
            bool hasError() const noexcept
            {
                return mError.HasValue();
            }
 
        public:
            using value_type = void;
            using error_type = E;
 
            Result() noexcept = default;
 
            explicit Result(const E &e) noexcept(
                std::is_nothrow_copy_constructible<E>::value) : mError{e}
            {
            }
 
            explicit Result(E &&e) noexcept(
                std::is_nothrow_move_constructible<E>::value) : mError{std::move(e)}
            {
            }
 
            Result(const Result &other) noexcept(
                std::is_nothrow_copy_assignable<E>::value)
            {
                if (other.hasError())
                {
                    mError = other.mError;
                }
            }
 
            Result(Result &&other) noexcept(
                std::is_nothrow_move_assignable<E>::value)
            {
                if (other.hasError())
                {
                    mError = std::move(other.mError);
                }
            }
 
            ~Result() noexcept = default;
 
            static Result FromValue() noexcept;
 
            static Result FromError(const E &e) noexcept(
                std::is_nothrow_copy_constructible<E>::value);
 
            static Result FromError(E &&e) noexcept(
                std::is_nothrow_move_constructible<E>::value);
 
            template <typename... Args>
            static Result FromError(Args &&...args);
 
            Result &operator=(Result const &other) noexcept(
                std::is_nothrow_copy_assignable<E>::value)
            {
                if (other.hasError())
                {
                    mError = other.mError;
                }
                else
                {
                    mError.Reset();
                }
 
                return *this;
            }
 
            Result &operator=(Result &&other) noexcept(
                std::is_nothrow_move_assignable<E>::value)
            {
                if (other.mHasError)
                {
                    mError = std::move(other.mError);
                }
                else
                {
                    mError.Reset();
                }
 
                return *this;
            }
 
            template <typename... Args>
            void EmplaceError(Args &&...args)
            {
                mError = E{args...};
            }
 
            void Swap(Result &other) noexcept(
                std::is_nothrow_move_assignable<E>::value)
            {
                if (hasError() && other.hasError())
                {
                    std::swap(mError, other.mError);
                }
                else if (hasError() && !other.hasError())
                {
                    other.mError = std::move(mError);
                }
                else if (!hasError() && other.hasError())
                {
                    mError = std::move(other.mError);
                }
            }
 
            constexpr bool HasValue() const noexcept
            {
                return !hasError();
            }
 
            constexpr explicit operator bool() const noexcept
            {
                return HasValue();
            }
 
            constexpr void operator*() const noexcept
            {
                // The function does nothing and it is implemented to help with generic programming.
            }
 
            constexpr void operator->() const noexcept
            {
                // The function does nothing and it is implemented to help with generic programming.
            }
 
            constexpr void Value() const noexcept
            {
                // The function does nothing and it is implemented to help with generic programming.
            }
 
            const E &Error() const &
            {
                return mError.Value();
            }
 
            E &&Error() &&
            {
                return std::move(mError).Value();
            }
 
            Optional<E> Err() const &
            {
                return mError;
            }
 
            Optional<E> Err() &&
            {
                return std::move(mError);
            }
 
            template <typename U>
            void ValueOr(U &&defaultValue) const noexcept
            {
                // The function does nothing and it is implemented to help with generic programming.
            }
 
            template <typename G>
            E ErrorOr(G &&defaultError) const &
            {
                return mError.ValueOr(defaultError);
            }
 
            template <typename G>
            E ErrorOr(G &&defaultError) &&
            {
                return std::move(mError).ValueOr(defaultError);
            }
 
            template <typename G>
            bool CheckError(G &&error) const
            {
                if (hasError())
                {
                    E _error = static_cast<E>(error);
                    return mError.Value() == _error;
                }
                else
                {
                    // No error exists for comparison
                    return false;
                }
            }
 
            void ValueOrThrow() const noexcept(false)
            {
                throw std::runtime_error("Result contains no value.");
            }
 
            template <typename F>
            void Resolve(F &&f) const
            {
                if (hasError())
                {
                    f(Error());
                }
            }
 
            template <typename F>
            auto Bind(F &&f) const -> Result<decltype(f()), E>
            {
                if (hasError())
                {
                    Result<decltype(f()), E> _result{Error()};
                    return _result;
                }
                else
                {
                    Result<decltype(f()), E> _result{f()};
                    return _result;
                }
            }
        };
 
        template <typename E>
        Result<void, E> Result<void, E>::FromValue() noexcept
        {
            Result _result;
            return _result;
        }
 
        template <typename E>
        Result<void, E> Result<void, E>::FromError(const E &e) noexcept(
            std::is_nothrow_copy_constructible<E>::value)
        {
            Result _result{e};
            return _result;
        }
 
        template <typename E>
        Result<void, E> Result<void, E>::FromError(E &&e) noexcept(
            std::is_nothrow_move_constructible<E>::value)
        {
            Result _result{std::move(e)};
            return _result;
        }
 
        template <typename E>
        template <typename... Args>
        Result<void, E> Result<void, E>::FromError(Args &&...args)
        {
            E _error{std::move(args...)};
            Result _result{_error};
 
            return _result;
        }
 
        template <typename E>
        inline bool operator==(const Result<void, E> &lhs, const Result<void, E> &rhs)
        {
            bool _result;
 
            if (lhs.HasValue() && rhs.HasValue())
            {
                _result = true;
            }
            else if (!lhs.HasValue() && !rhs.HasValue())
            {
                _result = lhs.Error() == rhs.Error();
            }
            else
            {
                _result = false;
            }
 
            return _result;
        }
 
        template <typename E>
        inline bool operator!=(const Result<void, E> &lhs, const Result<void, E> &rhs)
        {
            bool _result;
 
            if (lhs.HasValue() && rhs.HasValue())
            {
                _result = false;
            }
            else if (!lhs.HasValue() && !rhs.HasValue())
            {
                _result = lhs.Error() != rhs.Error();
            }
            else
            {
                _result = true;
            }
 
            return _result;
        }
    }
}
 
#endif