Expected.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/wrappers/Variant.h"
 
NAMESPACE_SPH_BEGIN
 
 
struct UnexpectedTag {};
const UnexpectedTag UNEXPECTED;
 
template <typename Type, typename Error = std::string>
class Expected {
private:
    struct UnexpectedWrapper {
        Error error;
    };
 
    // first type is dummy to use the default constructor of variant
    Variant<NothingType, Type, UnexpectedWrapper> data;
 
public:
    Expected() {
        data.template emplace<Type>();
    }
 
    template <typename T, typename = std::enable_if_t<std::is_constructible<Type, T>::value>>
    Expected(T&& value) {
        data.template emplace<Type>(std::forward<T>(value));
    }
 
    template <typename TError, typename = std::enable_if_t<std::is_constructible<Error, TError>::value>>
    Expected(UnexpectedTag, TError&& error) {
        data.template emplace<UnexpectedWrapper>(UnexpectedWrapper{ std::forward<TError>(error) });
    }
 
    explicit operator bool() const {
        return isExpected();
    }
 
    bool operator!() const {
        return !isExpected();
    }
 
    Type& value() {
        SPH_ASSERT(isExpected());
        return data.template get<Type>();
    }
 
    const Type& value() const {
        SPH_ASSERT(isExpected());
        return data.template get<Type>();
    }
 
    Type valueOr(const Type& other) const {
        if (isExpected()) {
            return this->value();
        } else {
            return other;
        }
    }
 
    const Error& error() const {
        SPH_ASSERT(!isExpected());
        return data.template get<UnexpectedWrapper>().error;
    }
 
    Type* operator->() {
        SPH_ASSERT(isExpected());
        return &value();
    }
 
    const Type* operator->() const {
        SPH_ASSERT(isExpected());
        return &value();
    }
 
private:
    bool isExpected() const {
        return data.getTypeIdx() == 1;
    }
};
 
template <typename T, typename = decltype(std::declval<std::ostream&>() << std::declval<T>())>
inline std::ostream& operator<<(std::ostream& stream, const Expected<T>& expected) {
    if (expected) {
        stream << expected.value();
    } else {
        stream << expected.error();
    }
    return stream;
}
 
template <typename Type>
Expected<Type> makeUnexpected(const std::string& error) {
    return Expected<Type>(UNEXPECTED, error);
}
 
NAMESPACE_SPH_END