Outcome.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/wrappers/Optional.h"
 
NAMESPACE_SPH_BEGIN
 
struct SuccessTag {};
 
struct FailTag {};
 
template <typename TError>
struct OutcomeTraits {
 
    INLINE static TError defaultError();
 
    INLINE static TError concatenate(const TError& e1, const TError& e2);
};
 
template <>
struct OutcomeTraits<std::string> {
    INLINE static std::string defaultError() {
        return "ERROR";
    }
 
    INLINE static std::string concatenate(const std::string& e1, const std::string& e2) {
        return e1 + " AND " + e2;
    }
};
 
template <typename TError>
class BasicOutcome {
private:
    Optional<TError> e;
 
public:
    INLINE BasicOutcome(SuccessTag) {}
 
    INLINE BasicOutcome(FailTag)
        : e(OutcomeTraits<TError>::defaultError()) {}
 
    INLINE explicit BasicOutcome(const bool value) {
        if (!value) {
            e.emplace(OutcomeTraits<TError>::defaultError());
        }
    }
 
    template <typename T, typename = std::enable_if_t<std::is_constructible<TError, T>::value>>
    INLINE explicit BasicOutcome(T&& error)
        : e(std::forward<T>(error)) {}
 
    INLINE bool success() const {
        return !e;
    }
 
    INLINE explicit operator bool() const {
        return success();
    }
 
    INLINE bool operator!() const {
        return !success();
    }
 
    INLINE const TError& error() const {
        SPH_ASSERT(!success());
        return e.value();
    }
 
    bool operator==(const BasicOutcome& other) const {
        return (!e && !other.e) || (e == other.e);
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const BasicOutcome& outcome) {
        if (outcome) {
            stream << "success";
        } else {
            stream << outcome.error();
        }
        return stream;
    }
 
    friend BasicOutcome operator||(const BasicOutcome& o1, const BasicOutcome& o2) {
        if (!o1 && !o2) {
            return BasicOutcome(OutcomeTraits<TError>::concatenate(o1.error(), o2.error()));
        }
        return SuccessTag{};
    }
 
    friend BasicOutcome operator&&(const BasicOutcome& o1, const BasicOutcome& o2) {
        if (!o1 && !o2) {
            return BasicOutcome(OutcomeTraits<TError>::concatenate(o1.error(), o2.error()));
        } else if (!o1) {
            return BasicOutcome(o1.error());
        } else if (!o2) {
            return BasicOutcome(o2.error());
        } else {
            return SuccessTag{};
        }
    }
};
 
using Outcome = BasicOutcome<std::string>;
 
const SuccessTag SUCCESS;
 
namespace Detail {
INLINE void printArgs(std::stringstream&) {}
 
template <typename T0, typename... TArgs>
INLINE void printArgs(std::stringstream& ss, T0&& t0, TArgs&&... args) {
    ss << t0;
    printArgs(ss, std::forward<TArgs>(args)...);
}
} // namespace Detail
 
template <typename... TArgs>
INLINE Outcome makeFailed(TArgs&&... args) {
    std::stringstream ss;
    Detail::printArgs(ss, std::forward<TArgs>(args)...);
    SPH_ASSERT(!ss.str().empty());
    return Outcome(ss.str());
}
 
template <typename... TArgs>
INLINE Outcome makeOutcome(const bool condition, TArgs&&... args) {
    if (condition) {
        return SUCCESS;
    } else {
        std::stringstream ss;
        Detail::printArgs(ss, std::forward<TArgs>(args)...);
        SPH_ASSERT(!ss.str().empty());
        return Outcome(ss.str());
    }
}
 
NAMESPACE_SPH_END