PartialResult.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://gitlab.com/charger7534/sawyer.git.
 
 
 
 
#ifndef Sawyer_PartialResult_H
#define Sawyer_PartialResult_H
 
#include <Sawyer/Result.h>
 
#include <boost/lexical_cast.hpp>
#include <boost/variant.hpp>
#include <exception>
#include <string>
#include <type_traits>
 
namespace Sawyer {
 
template<class T, class E>
class PartialResult {
public:
    using OkValue = T;
    using ErrorValue = E;
    using OkType = Ok<T>;
    using ErrorType = Error<E>;
 
private:
    Ok<T> ok_;
    Optional<Error<E>> error_;
 
#ifdef SAWYER_HAVE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) const {
        s <<BOOST_SERIALIZATION_NVP(ok_);
        s <<BOOST_SERIALIZATION_NVP(error_);
    }
#endif
 
#ifdef SAWYER_HAVE_CEREAL
private:
    friend class cereal::access;
 
    template<class Archive>
    void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &archive) const {
        archive(CEREAL_NVP(ok_));
        archive(CEREAL_NVP(error_));
    }
#endif
 
public:
    template<class U = T>
    /*implicit*/ PartialResult(const Ok<U> &ok)
        : ok_(OkType(*ok)) {}
 
    template<class U = T, class F = E>
    PartialResult(const U &ok, const F &error)
        : ok_(OkType(ok)), error_(ErrorType(error)) {}
 
    template<class U = T, class F = E>
    PartialResult(const PartialResult<U, F> &other)
        : ok_(OkType(other.unwrap())) {
        if (other.isError())
            error_ = ErrorType(other.unwrapError());
    }
 
    template<class U = T>
    PartialResult& operator=(const Ok<U> &ok) {
        ok_ = OkType(*ok);
        return *this;
    }
 
    template<class U = T, class F = E>
    PartialResult& operator=(const PartialResult<U, F> &other) {
        ok_ = OkType(*other.ok_);
        if (other.error_) {
            error_ = ErrorType(*other.error_);
        } else {
            error_ = Sawyer::Nothing();
        }
    }
 
    template<class U = T>
    bool operator==(const Ok<U> &ok) const {
        return unwrap() == *ok;
    }
 
    template<class U = T>
    bool operator!=(const Ok<U> &ok) const {
        return !(*this == ok);
    }
 
    template<class F = E>
    bool operator==(const Error<F> &error) const {
        return isError() && *this->error() == *error;
    }
 
    template<class F = E>
    bool operator!=(const Error<F> &error) const {
        return !(*this == error);
    }
 
    template<class U, class F>
    bool operator==(const PartialResult<U, F> &other) const {
        return (*ok() == *other.ok() &&
                isError() == other.isError() &&
                (!isError() || *error() == *other.error()));
    }
 
    template<class U, class F>
    bool operator!=(const PartialResult<U, F> &other) const {
        return !(*this == other);
    }
 
    bool isOk() const {
        return !isError();
    }
    explicit operator bool() const {
        return isOk();
    }
    bool isError() const {
        return !!error_;
    }
 
    const Sawyer::Optional<T> ok() const {
        if (isOk()) {
            return *ok_;
        } else {
            return Sawyer::Nothing();
        }
    }
 
    const Sawyer::Optional<E> error() const {
        if (error_) {
            return **error_;
        } else {
            return Sawyer::Nothing();
        }
    }
 
    const T& expect(const std::string &mesg) const {
        if (isOk()) {
            return *ok_;
        } else {
            throw std::runtime_error(mesg);
        }
    }
 
    const T& unwrap() const {
        return *ok_;
    }
    const T& operator*() const {
        return unwrap();
    }
    const T* operator->() const {
        return &unwrap();
    }
 
    const T orElse(const T &dflt) const {
        return isOk() ? unwrap() : dflt;
    }
 
    template<class Fn>
    typename std::enable_if<is_invocable<Fn, const PartialResult>::value, const PartialResult>::type
    orElse(Fn fn) const {
        if (isOk()) {
            return *this;
        } else {
            return fn(*this);
        }
    }
 
    template<class F>
    const PartialResult<T, F> orElse(const PartialResult<T, F> &other) const {
        if (isOk()) {
            return ok_;
        } else {
            return other;
        }
    }
 
    const T& orDefault() const {
        static T dflt = T();
        return isOk() ? unwrap() : dflt;
    }
 
    template<class Exception = E>
    const T& orThrow() const {
        if (isOk()) {
            return unwrap();
        } else {
            throw Exception(*error());
        }
    }
 
    template<class Exception = E>
    const T& orThrow(const Exception &e) const {
        if (isOk()) {
            return unwrap();
        } else {
            throw e;
        }
    }
 
    template<class Fn>
    typename std::enable_if<is_invocable<Fn, OkValue>::value, const PartialResult>::type
    andThen(Fn fn) const {
        if (isOk()) {
            return fn(*ok());
        } else {
            return *this;
        }
    }
 
    template<class U = T, class F = E>
    const PartialResult<U, F> andThen(const PartialResult<U, F> &other) const {
        if (isOk()) {
            return other;
        } else {
            return *this;
        }
    }
 
    const E& expectError(const std::string &mesg) const {
        if (error_) {
            return **error_;
        } else {
            throw std::runtime_error(mesg);
        }
    }
 
    const E& unwrapError() const {
        return expectError("result is not an error");
    }
 
    template<class U>
    bool contains(const U &value) const {
        return unwrap() == value;
    }
 
    template<class F>
    bool containsError(const F &error) const {
        return error_ ? unwrapError() == error : false;
    }
 
    template<class U>
    const PartialResult& assignTo(U &out) const {
        if (isOk())
            out = unwrap();
        return *this;
    }
 
    template<class U>
    PartialResult& assignTo(U &out) const {
        if (isOk())
            out = unwrap();
        return *this;
    }
    template <class F>
    auto
    fmap(F&& f) -> PartialResult<decltype(f(unwrap())), E> {
        using NewValue = decltype(f(unwrap()));
        using Retval = PartialResult<NewValue, E>;
        if (isOk()) {
            return Retval(Ok<NewValue>(f(unwrap())));
        } else {
            return Retval(f(unwrap()), unwrapError());
        }
    }
};
 
template<class T, class E>
PartialResult<T, E> makePartialResult(const T &ok, const E &error) {
    return PartialResult<T, E>(ok, error);
}
 
} // namespace
#endif