Result.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://github.com/matzke1/sawyer.




#ifndef Sawyer_Result_H
#define Sawyer_Result_H

#include <Sawyer/Optional.h>

#include <boost/lexical_cast.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/variant.hpp>
#include <exception>
#include <string>
#include <type_traits>

namespace Sawyer {

template <class F, class... Args>
struct is_invocable
{
    template <class U>
    static auto test(U* p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type());
    template <class U>
    static auto test(...) -> decltype(std::false_type());

    static constexpr bool value = decltype(test<F>(0))::value;
};


template<class T>
class Ok {
public:
    using Value = T;

private:
    Value ok_;

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(ok_);
    }

public:
    Ok() = delete;

    Ok(const Ok &other)
        : ok_(other.ok_) {}

    explicit Ok(const Value &ok)
        : ok_(ok) {}

    Ok& operator=(const Ok &other) {
        ok_ = other.ok_;
        return *this;
    }
    Ok& operator=(const Value &ok) {
        ok_ = ok;
        return *this;
    }
    const Value& operator*() const {
        return ok_;
    }

    const Value* operator->() const {
        return &ok_;
    }
};

// Specialization for Ok that stores string literals, as in Ok("foo"). These get treated as std::string instead.
template<size_t N>
class Ok<char[N]> {
public:
    using Value = std::string;

private:
    std::string ok_;

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(ok_);
    }

public:
    Ok() = delete;

    explicit Ok(const Value &s)
        : ok_(s) {}

    Ok& operator=(const Ok &other) {
        ok_ = other.ok_;
        return *this;
    }

    Ok& operator=(const Value &ok) {
        ok_ = ok;
        return *this;
    }

    const Value& operator*() const {
        return ok_;
    }

    const Value* operator->() const {
        return &ok_;
    }
};

template<class T>
Ok<T> makeOk(const T &value) {
    return Ok<T>(value);
}

// Specialization for string literals, as in makeOk("foo") so they get treated as std::string instead.
inline Ok<std::string> makeOk(const char *s) {
    return Ok<std::string>(std::string(s));
}
inline Ok<std::string> makeOk(char *s) {
    return Ok<std::string>(std::string(s));
}

template<class E>
class Error {
public:
    using Value = E;

private:
    Value error_;

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(error_);
    }

public:
    Error() = delete;

    Error(const Error &other)
        : error_(other.error_) {}

    explicit Error(const E &error)
        : error_(error) {}

    Error& operator=(const Error &other) {
        error_ = other.error_;
        return *this;
    }
    Error& operator=(const Value &error) {
        error_ = error;
        return *this;
    }
    const Value& operator*() const {
        return error_;
    }

    const Value* operator->() const {
        return &error_;
    }
};

// Specialization for Error that stores string literals as in Error("syntax error"). It stores them as std::string instead.
template<size_t N>
class Error<char[N]> {
public:
    using Value = std::string;

private:
    std::string error_;

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(error_);
    }

public:
    Error() = delete;

    explicit Error(const Error &other)
        : error_(other.error_) {}

    explicit Error(const Value &error)
        : error_(error) {}

    Error& operator=(const Error &other) {
        error_ = other.error_;
        return *this;
    }
    Error& operator=(const Value &error) {
        error_ = error;
        return *this;
    }
    const Value& operator*() const {
        return error_;
    }

    const Value* operator->() const {
        return &error_;
    }
};

template<class T>
Error<T> makeError(const T &value) {
    return Error<T>(value);
}

// Specialization for string literals, as in makeError("foo") so they get treated as std::string instead.
inline Error<std::string> makeError(const char *s) {
    return Error<std::string>(std::string(s));
}
inline Error<std::string> makeError(char *s) {
    return Error<std::string>(std::string(s));
}

template<class T, class E>
class Result {
public:
    using OkValue = T;
    using ErrorValue = E;
    using OkType = Ok<T>;
    using ErrorType = Error<E>;

private:
    boost::variant<Ok<T>, Error<E>> result_;

private:
    friend class boost::serialization::access;

    template<class S>
    void save(S &s, const unsigned /*version*/) const {
        s <<boost::serialization::make_nvp("isOk", isOk());
        if (isOk()) {
            s <<boost::serialization::make_nvp("ok", unwrap());
        } else {
            s <<boost::serialization::make_nvp("error", unwrapError());
        }
    }

    template<class S>
    void load(S &s, const unsigned /*version*/) {
        bool isOk;
        s >>boost::serialization::make_nvp("isOk", isOk);
        if (isOk) {
            T ok;
            s >>boost::serialization::make_nvp("ok", ok);
            result_ = OkType(ok);
        } else {
            E error;
            s >>boost::serialization::make_nvp("error", error);
            result_ = ErrorType(error);
        }
    }

    BOOST_SERIALIZATION_SPLIT_MEMBER();

public:
    template<class U = T>
    /*implicit*/ Result(const Ok<U> &ok)
        : result_(OkType(*ok)) {}

    template<class F = E>
    /*implicit*/ Result(const Error<F> &error)
        : result_(ErrorType(*error)) {}

    template<class U = T>
    Result& operator=(const Ok<U> &ok) {
        result_ = OkType(*ok);
        return *this;
    }

    template<class F = E>
    Result& operator=(const Error<F> &error) {
        result_ = ErrorType(*error);
        return *this;
    }

    template<class U = T>
    bool operator==(const Ok<U> &ok) const {
        return isOk() && *this->ok() == *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 Result<U, F> &other) const {
        return ((isOk() && other.isOk() && *ok() == *other.ok()) ||
                (isError() && other.isError() && *error() == *other.error()));
    }

    template<class U, class F>
    bool operator!=(const Result<U, F> &other) const {
        return !(*this == other);
    }

    bool isOk() const {
        return result_.which() == 0;
    }
    explicit operator bool() const {
        return isOk();
    }
    bool isError() const {
        return !isOk();
    }

    const Sawyer::Optional<T> ok() const {
        if (isOk()) {
            return *boost::get<OkType>(result_);
        } else {
            return Sawyer::Nothing();
        }
    }

    const Sawyer::Optional<E> error() const {
        if (isOk()) {
            return Sawyer::Nothing();
        } else {
            return *boost::get<ErrorType>(result_);
        }
    }

    const T& expect(const std::string &mesg) const {
        if (isOk()) {
            return *boost::get<OkType>(result_);
        } else {
            throw std::runtime_error(mesg);
        }
    }

    const T& unwrap() const {
        return expect("result is not okay");
    }
    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, ErrorValue>::value, const Result>::type
    orElse(Fn fn) const {
        if (isOk()) {
            return *this;
        } else {
            return fn(*error());
        }
    }

    template<class F>
    const Result<T, F> orElse(const Result<T, F> &other) const {
        if (isOk()) {
            return boost::get<OkType>(result_);
        } 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 Result>::type
    andThen(Fn fn) const {
        if (isOk()) {
            return fn(*ok());
        } else {
            return *this;
        }
    }

    template<class U>
    const Result<U, E> andThen(const Result<U, E> &other) const {
        if (isOk()) {
            return other;
        } else {
            return boost::get<ErrorType>(result_);
        }
    }

    const E& expectError(const std::string &mesg) const {
        if (isOk()) {
            throw std::runtime_error(mesg);
        } else {
            return *boost::get<ErrorType>(result_);
        }
    }

    const E& unwrapError() const {
        return expectError("result is not an error");
    }

    template<class U>
    bool contains(const U &value) const {
        return isOk() ? unwrap() == value : false;
    }

    template<class F>
    bool containsError(const F &error) const {
        return isOk() ? false : unwrapError() == error;
    }

#if 0 // [Robb Matzke 2022-08-17]

    Optional<Result<typename T::Value, E>>
    transpose() const {
        if (isOk()) {
            if (unwrap().isEmpty()) {
                return Sawyer::Nothing();
            } else {
                return OkType(*unwrap());
            }
        } else {
            return ErrorType(unwrapError());
        }
    }

    Result<typename OkValue::OkValue, E> flatten() const {
        if (isOk()) {
            if (unwrap().isOk()) {
                return OkValue::OkType(unwrap().unwrap());
            } else {
                return ErrorType(unwrap().unwrapError());
            }
        } else {
            return ErrorType(unwrapError());
        }
    }
#endif

    template<class U>
    bool assignTo(U &out) const {
        if (isOk()) {
            out = unwrap();
            return true;
        } else {
            return false;
        }
    }
};

} // namespace
#endif