result.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <ostream>
#include <string>
#include <utility>
#include <variant>
 
#include <hilti/rt/exception.h>
#include <hilti/rt/types/optional.h>
 
namespace hilti::rt {
 
namespace result {
 
class Error {
public:
    Error(std::string_view description = "<no description>", std::string_view context = "")
        : _description(description), _context(context) {}
 
    std::string_view description() const { return _description; }
    std::string_view context() const { return _context; }
 
    operator std::string() const { return _description; }
    operator std::string_view() const { return _description; }
 
private:
    std::string _description;
    std::string _context;
};
 
inline std::ostream& operator<<(std::ostream& out, const Error& error) {
    out << error.description();
    return out;
}
 
inline bool operator==(const Error& a, const Error& b) { return a.description() == b.description(); }
inline bool operator!=(const Error& a, const Error& b) { return ! (a == b); }
 
class NoResult : public RuntimeError {
public:
    NoResult(Error err) : RuntimeError(err.description()), _error(std::move(err)) {}
 
private:
    Error _error;
};
 
class NoError : public RuntimeError {
public:
    NoError() : RuntimeError("<no error>") {}
};
 
} // namespace result
 
struct Nothing {};
 
inline bool operator==(const Nothing&, const Nothing&) { return true; }
inline bool operator!=(const Nothing&, const Nothing&) { return false; }
 
namespace detail::adl {
inline std::string to_string(const Nothing& /*n*/, adl::tag /*unused*/) { return "<nothing>"; };
} // namespace detail::adl
 
template<typename T>
class Result {
public:
    Result() : _value(std::in_place_type_t<result::Error>(), result::Error("<result not initialized>")) {}
 
    Result(const T& t) : _value(std::in_place_type_t<T>(), t) {}
    Result(T&& t) : _value(std::in_place_type_t<T>(), std::move(t)) {}
    Result(const result::Error& e) : _value(std::in_place_type_t<result::Error>(), e) {}
    Result(result::Error&& e) : _value(std::in_place_type_t<result::Error>(), std::move(e)) {}
 
    Result(const Result& o) = default;
    Result(Result&& o) = default; // NOLINT (hicpp-noexcept-move)
    ~Result() = default;
 
    const T& value() const& { return std::get<T>(_value); }
 
    T& value() & { return std::get<T>(_value); }
 
    T value() && { return std::get<T>(std::move(_value)); }
 
    template<typename E = result::NoResult>
    const T& valueOrThrow() const& {
        if ( ! hasValue() )
            throw E(error());
 
        return value();
    }
 
    template<typename E = result::NoResult>
    T& valueOrThrow() & {
        if ( ! hasValue() )
            throw E(error());
 
        return value();
    }
 
    template<typename E = result::NoResult>
    T valueOrThrow() && {
        if ( ! hasValue() )
            throw E(error());
 
        return value();
    }
 
    const result::Error& error() const& { return std::get<result::Error>(_value); }
 
    result::Error error() && { return std::get<result::Error>(std::move(_value)); }
 
    const result::Error& errorOrThrow() const {
        if ( hasValue() )
            throw result::NoError();
 
        return error();
    }
 
    bool hasValue() const { return std::holds_alternative<T>(_value); }
 
    const T& operator*() const& { return value(); }
    T& operator*() & { return value(); }
    T operator*() && { return value(); }
    const T* operator->() const& { return std::get_if<T>(&_value); }
    T* operator->() & { return std::get_if<T>(&_value); }
    T* operator->() && = delete;
 
    explicit operator bool() const { return hasValue(); }
 
    Result& operator=(const Result& other) = default;
    Result& operator=(Result&& other) = default; // NOLINT (hicpp-noexcept-move)
 
    friend bool operator==(const Result& a, const Result& b) {
        if ( a.hasValue() != b.hasValue() )
            return false;
 
        if ( a.hasValue() )
            return a.value() == b.value();
        else
            return a.error() == b.error();
    }
 
    friend bool operator!=(const Result& a, const Result& b) { return ! (a == b); }
 
private:
    std::variant<T, result::Error> _value;
};
 
template<typename T>
Result<T> make_result(T&& t) {
    return Result<T>(std::forward<T>(t));
}
 
} // namespace hilti::rt