Result.h

Go to the documentation of this file.

#pragma once
#include <scl/utils/Either.h>
#include <scl/utils/Placeholder.h>
#include <scl/exceptions/InvalidResultAccess.h>
#include <functional>

namespace scl{
    namespace utils{
        namespace details{
            struct result_value final{};
            struct result_error final{};
        }

        template <class Value, class Error = Placeholder>
        class Result{
            public:
                using value_type = Value;
                using error_type = Error;
                using impl_type = Either<value_type, error_type>;

            protected:
                impl_type alt;

                Result() = delete;

                template <class T>
                Result(details::result_value, T&& value) : alt{impl_type::Left(std::forward<T>(value))} {
                }

                template <class E>
                Result(details::result_error, E&& err) : alt{impl_type::Right(std::forward<E>(err))} {
                }

            public:
                template <class T>
                static Result Ok(T&& value){
                    return Result{
                        details::result_value{},
                        std::forward<T>(value)
                    };
                }

                template <class T>
                static Result ok(T&& value){
                    return Ok(std::forward<T>(value));
                }

                template <class... Args>
                static Result emplaceOk(Args&&... args){
                    return Ok(value_type{
                        std::forward<Args>(args)...
                    });
                }

                template <class E>
                static Result Err(E&& err){
                    return Result{
                        details::result_error{},
                        std::forward<E>(err)
                    };
                }

                template <class E>
                static Result err(E&& error){
                    return Err(std::forward<E>(error));
                }

                template <class... Args>
                static Result emplaceErr(Args&&... args){
                    return Err(error_type{
                        std::forward<Args>(args)...
                    });
                }

            public:
                bool isOk() const{
                    return this->alt.hasLeft();
                }

                bool isErr() const{
                    return !this->isOk();
                }

                const value_type& value() const{
                    try {
                        return this->alt.getLeft();
                    }catch(scl::exceptions::InvalidEitherAccess& e){
                        throw scl::exceptions::InvalidResultAccess::okWhenErr();
                    }
                }

                const value_type& get() const{
                    return this->value();
                }

                const error_type& error() const{
                    try{
                        return this->alt.getRight();
                    }catch(scl::exceptions::InvalidEitherAccess& e){
                        throw scl::exceptions::InvalidResultAccess::errWhenOk();
                    }
                }

                operator bool() const{
                    return this->isOk();
                }

                operator const value_type&() const{
                    return this->value();
                }

                const value_type& operator*() const{
                    return this->get();
                }

                realConst(value_type*) operator->() const{
                    return &(this->get());
                }

            public:
                Optional<value_type> toOptional() const{
                    if(this->isOk())
                        return this->value();
                    return none;
                }

                Optional<value_type> asOptional() const{
                    return this->toOptional();
                }

                template <class T = value_type>
                Result<T, error_type> map(std::function<T(const value_type&)> mapper) const{
                    return this->isOk()
                    ? Result<T, error_type>::Ok(mapper(this->value()))
                    : Result<T, error_type>::Err(this->error());
                }

                template <class T = value_type>
                Result<T, error_type> then(std::function<T(const value_type&)> mapper) const{
                    return this->map(mapper);
                }

                template <class E = error_type>
                Result<value_type, E> mapError(std::function<E(const error_type&)> mapper) const{
                    return this->isOk()
                    ? Result<value_type, E>::Ok(this->value())
                    : Result<value_type, E>::Err(mapper(this->error()));
                }

                template <class T = value_type, class E = error_type>
                Result<T, E> mapBoth(std::function<T(const value_type&)> valueMapper, std::function<E(const error_type&)> errorMapper) const{
                    //return this->map(valueMapper).mapError(errorMapper);
                    return this->isOk()
                    ? Result<T, E>::Ok(valueMapper(this->value()))
                    : Result<T, E>::Err(errorMapper(this->error()));
                }

                template <class T = value_type, class E = error_type>
                Result<T, E> flatMap(std::function<Result<T, E>(const value_type&)> mapper) const{
                    return this->isOk()
                    ? mapper(this->value())
                    : Result<T, E>::emplaceErr(this->error());
                }

                template <class T = value_type, class E = error_type>
                Result<T, E> andThen(std::function<Result<T, E>(const value_type&)> mapper) const{
                    return this->flatMap(mapper);
                }

                template <class T = value_type, class E = error_type>
                Result<T, E> flatMapError(std::function<Result<T, E>(const error_type&)> mapper) const{
                    return this->isOk()
                    ? Result<T, E>::emplaceOk(this->value())
                    : mapper(this->error());
                }

            public:
                const value_type& okOr(const value_type& value) const{
                    return this->isOk()
                    ? this->value()
                    : value;
                }

                const value_type& okOr(std::function<const value_type&()> factory) const{
                    return this->isOk()
                    ? this->value()
                    : factory();
                }

                const error_type& errOr(const error_type& error) const{
                    return this->isOk()
                    ? error
                    : this->error();
                }

                const error_type& errOr(std::function<const error_type&()> factory) const{
                    return this->isOk()
                           ? factory()
                           : this->error();
                }

                template <class E>
                const value_type& okOrThrow(E ex) const{
                    if(!this->isOk())
                        throw ex;
                    return this->value();
                }
        };

        template <class T>
        Result<T, std::exception_ptr> wrapInResult(std::function<T()> f){
            try{
                auto value = f();
                return Result<T, std::exception_ptr>::emplaceOk(value);
            }catch(...){
                return Result<T, std::exception_ptr>::Err(
                    std::current_exception()
                );
            }
        }
    }
}