erroror.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_ERROROR_HPP
#define CPPWAMP_ERROROR_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <cassert>
#include <functional>
#include <system_error>
#include <utility>
#include "api.hpp"
#include "config.hpp"
#include "error.hpp"
#include "traits.hpp"
 
namespace wamp
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename E>
class Unexpected
{
public:
    using error_type = E; 
 
    Unexpected() = delete;
 
    explicit Unexpected(error_type error) noexcept : error_(std::move(error)) {}
 
    error_type& value() & noexcept { return error_; }
 
    error_type&& value() && noexcept { return std::move(error_); }
 
    const error_type& value() const& noexcept { return error_; }
 
    const error_type&& value() const&& noexcept { return std::move(error_); }
 
    void swap(Unexpected& other) noexcept(std::is_nothrow_swappable<E>::value)
    {
        using std::swap;
        swap(error_, other.error_);
    }
 
private:
    error_type error_;
};
 
template <typename E1, typename E2>
CPPWAMP_API bool operator==(const Unexpected<E1>& x, const Unexpected<E2>& y)
{
    return x.value() == y.value();
}
 
template <typename E1, typename E2>
CPPWAMP_API bool operator!=(const Unexpected<E1>& x, const Unexpected<E2>& y)
{
    return x.value() != y.value();
}
 
template <typename E>
CPPWAMP_API void swap(Unexpected<E>& x, Unexpected<E>& y)
    noexcept(noexcept(x.swap(y)))
{
    x.swap(y);
}
 
template <typename E>
constexpr Unexpected<ValueTypeOf<E>> makeUnexpected(E&& error)
{
    return Unexpected<ValueTypeOf<E>>{std::forward<E>(error)};
}
 
 
//------------------------------------------------------------------------------
using UnexpectedError = Unexpected<std::error_code>;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename TErrorEnum>
CPPWAMP_API UnexpectedError makeUnexpectedError(TErrorEnum errc)
{
    return UnexpectedError(make_error_code(errc));
}
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T>
class CPPWAMP_API ErrorOr
{
public:
    using value_type = T;               
    using error_type = std::error_code; 
 
    ErrorOr() = default;
 
    ErrorOr(const ErrorOr&) = default;
 
    ErrorOr(ErrorOr&&) = default;
 
    ErrorOr(value_type value)
        : value_(std::move(value)),
          hasError_(false)
    {}
 
    template <typename G>
    ErrorOr(Unexpected<G> unex)
        : error_(std::move(unex).value()),
          hasError_(true)
    {}
 
    template <typename... Args>
    value_type& emplace(Args&&... args)
    {
        value_ = value_type(std::forward<Args>(args)...);
        error_ = error_type();
        hasError_ = false;
        return value_;
    }
 
    ErrorOr& operator=(const ErrorOr&) = default;
 
    ErrorOr& operator=(ErrorOr&&) = default;
 
    ErrorOr& operator=(value_type value)
    {
        value_ = std::move(value);
        error_ = error_type();
        hasError_ = false;
        return *this;
    }
 
    template <typename G>
    ErrorOr& operator=(Unexpected<G> unex)
    {
        error_ = error_type(std::move(unex).value());
        value_ = value_type();
        hasError_ = true;
        return *this;
    }
 
    void swap(ErrorOr& rhs)
        noexcept(std::is_nothrow_swappable<value_type>::value)
    {
        using std::swap;
        swap(value_, rhs.value_);
        swap(error_, rhs.error_);
        swap(hasError_, rhs.hasError_);
    }
 
    value_type* operator->()
    {
        assert(has_value());
        return std::addressof(value_);
    }
 
    const value_type* operator->() const
    {
        assert(has_value());
        return std::addressof(value_);
    }
 
    value_type& operator*() &
    {
        assert(has_value());
        return value_;
    }
 
    value_type&& operator*() &&
    {
        assert(has_value());
        return std::move(value_);
    }
 
    const value_type& operator*() const&
    {
        assert(has_value());
        return value_;
    }
 
    const value_type&& operator*() const&&
    {
        assert(has_value());
        return std::move(value_);
    }
 
    explicit operator bool() const noexcept {return has_value();}
 
    bool has_value() const noexcept {return !hasError_;}
 
    value_type& value() &
    {
        checkError();
        return value_;
    }
 
    value_type&& value() &&
    {
        checkError();
        return std::move(value_);
    }
 
    const value_type& value() const&
    {
        checkError();
        return value_;
    }
 
    const value_type&& value() const&&
    {
        checkError();
        return std::move(value_);
    }
 
    error_type& error()
    {
        assert(!has_value());
        return error_;
    }
 
    const error_type& error() const
    {
        assert(!has_value());
        return error_;
    }
 
    template <typename U>
    value_type value_or(U&& v) const&
    {
        if (has_value())
            return value_;
        else
            return std::forward<U>(v);
    }
 
    template <typename U>
    value_type value_or(U&& v) &&
    {
        if (has_value())
            return std::move(value_);
        else
            return std::forward<U>(v);
    }
 
    using ValueType = value_type;
 
 
    CPPWAMP_DEPRECATED ErrorOr(std::error_code ec)
        : ErrorOr(makeUnexpected(ec))
    {}
 
    CPPWAMP_DEPRECATED ErrorOr(std::error_code ec, std::string)
        : ErrorOr(makeUnexpected(ec))
    {}
 
    CPPWAMP_DEPRECATED ValueType& get() {return value();}
 
    CPPWAMP_DEPRECATED const ValueType& get() const {return value();}
 
    CPPWAMP_DEPRECATED std::error_code errorCode() const
    {
        return hasError_ ? error() : error_type{};
    }
 
    CPPWAMP_DEPRECATED const std::string& errorInfo() const
    {
        static const std::string empty;
        return empty;
    }
 
    CPPWAMP_DEPRECATED ErrorOr& setValue(T value)
    {
        value_ = std::move(value);
        error_ = error_type();
        hasError_ = false;
        return *this;
    }
 
    CPPWAMP_DEPRECATED ErrorOr& setError(std::error_code ec)
    {
        error_ = ec;
        value_ = value_type();
        hasError_ = true;
        return *this;
    }
 
    CPPWAMP_DEPRECATED ErrorOr& setError(std::error_code ec, std::string)
    {
        setError(ec);
    }
 
private:
    CPPWAMP_HIDDEN void checkError() const
    {
        if (hasError_)
            throw error::Failure(error_);
    }
 
    value_type value_;
    error_type error_;
    bool hasError_ = false;
};
 
template <typename T>
CPPWAMP_API void swap(ErrorOr<T>& x, ErrorOr<T>& y)
    noexcept(noexcept(x.swap(y)))
{
    x.swap(y);
}
 
template <typename T1, typename T2>
CPPWAMP_API bool operator==(const ErrorOr<T1>& x, const ErrorOr<T2>& y)
{
    return (x.has_value() == y.has_value())
               ? (x.has_value() ? *x == *y : x.error() == y.error())
               : false;
}
 
template <typename T1, typename T2>
CPPWAMP_API bool operator!=(const ErrorOr<T1>& x, const ErrorOr<T2>& y)
{
    return (x.has_value() == y.has_value())
               ? (x.has_value() ? *x != *y : x.error() != y.error())
               : true;
}
 
template <typename T1, typename T2>
CPPWAMP_API bool operator==(const ErrorOr<T1>& x, const T2& v)
{
    return x.has_value() ? *x == v : false;
}
 
template <typename T1, typename T2>
CPPWAMP_API bool operator==(const T2& v, const ErrorOr<T1>& x)
{
    return x.has_value() ? *x == v : false;
}
 
template <typename T1, typename T2>
CPPWAMP_API bool operator!=(const ErrorOr<T1>& x, const T2& v)
{
    return x.has_value() ? *x != v : true;
}
 
template <typename T1, typename T2>
CPPWAMP_API bool operator!=(const T2& v, const ErrorOr<T1>& x)
{
    return x.has_value() ? *x != v : true;
}
 
template <typename T, typename E>
CPPWAMP_API bool operator==(const ErrorOr<T>& x, const Unexpected<E>& e)
{
    return x.has_value() ? false : x.error() == e.value();
}
 
template <typename T, typename E>
CPPWAMP_API bool operator==(const Unexpected<E>& e, const ErrorOr<T>& x)
{
    return x.has_value() ? false : x.error() == e.value();
}
 
template <typename T, typename E>
CPPWAMP_API bool operator!=(const ErrorOr<T>& x, const Unexpected<E>& e)
{
    return x.has_value() ? true : x.error() != e.value();
}
 
template <typename T, typename E>
CPPWAMP_API bool operator!=(const Unexpected<E>& e, const ErrorOr<T>& x)
{
    return x.has_value() ? true : x.error() != e.value();
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename T> using AsyncHandler = std::function<void (ErrorOr<T>)>;
 
} // namespace wamp
 
#endif // CPPWAMP_ERROROR_HPP