File Coverage

src/panda/expected.h

Criterion	Covered	Total	%
statement	0	3	0.0
branch	0	2	0.0
condition			n/a
subroutine			n/a
pod			n/a
total	0	5	0.0

#pragma once
#include
#include

namespace panda {

template
struct unexpected {
  static_assert(!std::is_same::value, "E must not be void");

  unexpected () = delete;
  constexpr explicit unexpected (const E& e) : _val(e)            {}
  constexpr explicit unexpected (E&& e)      : _val(std::move(e)) {}

  constexpr const E&  value () const &  { return _val; }
  constexpr const E&& value () const && { return std::move(_val); }

  E&  value () &  { return _val; }
  E&& value () && { return std::move(_val); }

private:
    E _val;
};

template
inline unexpected::type> make_unexpected (E &&e) {
  return unexpected::type>(std::forward(e));
}

template
struct bad_expected_access : std::exception {
  explicit bad_expected_access (E e) : _val(std::move(e)) {}

  virtual const char* what () const noexcept override { return "Bad expected access"; }

  const E&  error () const &  { return _val; }
  const E&& error () const && { return std::move(_val); }

  E&  error () &  { return _val; }
  E&& error () && { return std::move(_val); }

private:
  E _val;
};

/// A tag to tell expected to construct the unexpected value
struct unexpect_t { unexpect_t() = default; };
static constexpr unexpect_t unexpect {};


template
struct expected {
    using value_type = T;
    using error_type = E;
    using unexpected_type = unexpected;

    template ::value>::type>
    expected () {
        _has_val = true;
        ::new (&_val) T();
    }

    expected (const expected& ex) {
        if (ex._has_val) construct_val(ex._val);
        else             construct_err(ex._err);
    }

    expected (expected&& ex) {
        if (ex._has_val) construct_val(std::move(ex._val));
        else             construct_err(std::move(ex._err));
    }

    template
    explicit expected (const expected& ex) {
        if (ex._has_val) construct_val(ex._val);
        else             construct_err(ex._err);
    }

    template
    explicit expected (expected&& ex) {
        if (ex._has_val) construct_val(std::move(ex._val));
        else             construct_err(std::move(ex._err));
    }

    template ::value>::type>
    expected (T2&& v) {
        construct_val(std::forward(v));
    }

    template
    expected (const unexpected& uex) {
        construct_err(uex.value());
    }

    template
    expected (unexpected&& uex) {
        construct_err(std::move(uex.value()));
    }

    ~expected () {
        if (_has_val) _val.~T();
        else          _err.~E();
    }

    expected& operator= (const expected& ex) {
        if (ex._has_val) set_val(ex._val);
        else             set_err(ex._err);
        return *this;
    }

    expected& operator= (expected&& ex) {
        if (ex._has_val) set_val(std::move(ex._val));
        else             set_err(std::move(ex._err));
        return *this;
    }

    template
    expected& operator= (T2&& v) {
        set_val(std::forward(v));
    }

    template
    expected& operator= (const unexpected& uex) {
        set_err(uex.value());
    }

    template
    expected& operator= (unexpected&& uex) {
        set_err(std::move(uex.value()));
    }

    constexpr bool     has_value     () const noexcept { return _has_val; }
    constexpr explicit operator bool () const noexcept { return _has_val; }

    const T&  value () const &  { if (!_has_val) throw bad_expected_access(_err); return _val; }
          T&  value ()       &  { if (!_has_val) throw bad_expected_access(_err); return _val; }
    const T&& value () const && { if (!_has_val) throw bad_expected_access(_err); return std::move(_val); }
          T&& value ()       && { if (!_has_val) throw bad_expected_access(_err); return std::move(_val); }

    template  constexpr T value_or (T2&& v) const & { return bool(*this) ? this->_val : static_cast(std::forward(v)); }
    template  constexpr T value_or (T2&& v)      && { return bool(*this) ? std::move(this->_val) : static_cast(std::forward(v)); }

    const E&  error () const &  { return _err; }
          E&  error ()       &  { return _err; }
    const E&& error () const && { return std::move(_err); }
          E&& error ()       && { return std::move(_err); }

    const T* operator-> () const { return &_val; }
          T* operator-> ()       { return &_val; }

    const T&  operator* () const &  { return _val; }
          T&  operator* ()       &  { return _val; }
    const T&& operator* () const && { return std::move(_val); }
          T&& operator* ()       && { return std::move(_val); }

    template
    void emplace (Args&&... args) {
        if (_has_val) _val = T(std::forward(args)...);
        else {
            auto tmp = std::move(_err);
            _err.~E();
            try {
                ::new (&_val) T(std::forward(args)...);
                _has_val = true;
            } catch (...) {
                new (&_err) E(std::move(tmp));
                throw;
            }
        }
    }

    template
    auto and_then (F&& f) const & -> decltype(f(std::declval())) {
        if (!_has_val) return unexpected_type(_err);
        return f(_val);
    }

    template
    auto and_then (F&& f) const && -> decltype(f(std::declval())) {
        if (!_has_val) return unexpected_type(std::move(_err));
        return f(std::move(_val));
    }

    template
    auto or_else (F&& f) const & -> decltype(f(std::declval())) {
        if (_has_val) return *this;
        return f(_err);
    }

    template
    auto or_else (F&& f) const && -> decltype(f(std::declval())) {
        if (_has_val) return std::move(*this);
        return f(std::move(_err));
    }

    template
    auto map (F&& f) const & -> expected())), E> {
        if (!_has_val) return unexpected_type(_err);
        return f(_val);
    }

    template
    auto map (F&& f) const && -> expected())), E> {
        if (!_has_val) return unexpected_type(std::move(_err));
        return f(std::move(_val));
    }

    template
    auto map_error (F&& f) const & -> expected()))> {
        if (_has_val) return _val;
        return make_unexpected(f(_err));
    }

    template
    auto map_error (F&& f) const && -> expected()))> {
        if (_has_val) return std::move(_val);
        return make_unexpected(f(std::move(_err)));
    }

    template
    void swap (expected& ex) {
        if (_has_val) {
            if (ex._has_val) std::swap(_val, ex._val);
            else {
                auto tmp = std::move(ex._err);
                ex._err.~E();
                ex._has_val = true;
                new (&ex._val) T(std::move(_val));

                _val.~T();
                _has_val = false;
                new (&_err) E(std::move(tmp));
            }
        }
        else {
            if (ex._has_val) ex.swap(*this);
            else std::swap(_err, ex._err);
        }
    }

private:
    template  friend struct expected;

    template
    void construct_val (T2&& v) {
        _has_val = true;
        ::new (&_val) T(std::forward(v));
    }

    template
    void construct_err (E2&& e) {
        _has_val = false;
        ::new (&_err) E(std::forward(e));
    }

    template
    void set_val (T2&& v) {
        if (_has_val) _val = std::forward(v);
        else {
            _err.~E();
            _has_val = true;
            ::new (&_val) T(std::forward(v));
        }
    }

    template
    void set_err (E2&& e) {
        if (_has_val) {
            _val.~T();
            _has_val = false;
            ::new (&_err) E(std::forward(e));
        }
        else _err = std::forward(e);
    }

    union {
        T _val;
        E _err;
    };
    bool _has_val;
};


template
struct expected {
    using value_type = void;
    using error_type = E;
    using unexpected_type = unexpected;

    expected () { _has_val = true; }

    expected (const expected& ex) {
        if (ex._has_val) _has_val = true;
        else             construct_err(ex._err);
    }

    expected (expected&& ex) {
        if (ex._has_val) _has_val = true;
        else             construct_err(std::move(ex._err));
    }

    template
    explicit expected (const expected& ex) {
        if (ex._has_val) _has_val = true;
        else             construct_err(ex._err);
    }

    template
    explicit expected (expected&& ex) {
        if (ex._has_val) _has_val = true;
        else             construct_err(std::move(ex._err));
    }

    template
    expected (const unexpected& uex) {
        construct_err(uex.value());
    }

    template
    expected (unexpected&& uex) {
        construct_err(std::move(uex.value()));
    }

    ~expected () {
        if (!_has_val) _err.~E();
    }

    expected& operator= (const expected& ex) {
        if (ex._has_val) set_val();
        else             set_err(ex._err);
        return *this;
    }

    expected& operator= (expected&& ex) {
        if (ex._has_val) set_val();
        else             set_err(std::move(ex._err));
        return *this;
    }

    template
    expected& operator= (const unexpected& uex) {
        set_err(uex.value());
    }

    template
    expected& operator= (unexpected&& uex) {
        set_err(std::move(uex.value()));
    }

    constexpr bool     has_value     () const noexcept { return _has_val; }
    constexpr explicit operator bool () const noexcept { return _has_val; }

    const E&  error () const &  { return _err; }
          E&  error ()       &  { return _err; }
    const E&& error () const && { return std::move(_err); }
          E&& error ()       && { return std::move(_err); }

    template
    auto and_then (F&& f) const & -> decltype(f()) {
        if (!_has_val) return unexpected_type(_err);
        return f();
    }

    template
    auto and_then (F&& f) const && -> decltype(f()) {
        if (!_has_val) return unexpected_type(std::move(_err));
        return f();
    }

    template
    auto or_else (F&& f) const & -> decltype(f(std::declval())) {
        if (_has_val) return *this;
        return f(_err);
    }

    template
    auto or_else (F&& f) const && -> decltype(f(std::declval())) {
        if (_has_val) return std::move(*this);
        return f(std::move(_err));
    }

    template
    auto map (F&& f) const & -> expected {
        if (!_has_val) return unexpected_type(_err);
        return f();
    }

    template
    auto map (F&& f) const && -> expected {
        if (!_has_val) return unexpected_type(std::move(_err));
        return f();
    }

    template
    auto map_error (F&& f) const & -> expected()))> {
        if (_has_val) return {};
        return make_unexpected(f(_err));
    }

    template
    auto map_error (F&& f) const && -> expected()))> {
        if (_has_val) return {};
        return make_unexpected(f(std::move(_err)));
    }

    template
    void swap (expected& ex) {
        if (_has_val) {
            if (!ex._has_val) {
                new (&_err) E(std::move(ex._err));
                ex._err.~E();
                std::swap(_has_val, ex._has_val);
            }
        }
        else {
            if (ex._has_val) ex.swap(*this);
            else std::swap(_err, ex._err);
        }
    }

private:
    template  friend struct expected;

    template
    void construct_err (E2&& e) {
        _has_val = false;
        ::new (&_err) E(std::forward(e));
    }

    void set_val () {
        if (_has_val) return;
        _err.~E();
        _has_val = true;
    }

    template
    void set_err (E2&& e) {
        if (_has_val) {
            _has_val = false;
            ::new (&_err) E(std::forward(e));
        }
        else _err = std::forward(e);
    }

    union {
        E _err;
    };
    bool _has_val;
};

template
bool operator== (const expected& lhs, const expected& rhs) {
    if (lhs.has_value() != rhs.has_value()) return false;
    return lhs.has_value() ? *lhs == *rhs : lhs.error() == rhs.error();
}

template
bool operator== (const expected& lhs, const expected& rhs) {
    if (lhs.has_value() != rhs.has_value()) return false;
    return lhs.has_value() ? true : lhs.error() == rhs.error();
}

template
bool operator!= (const expected& lhs, const expected& rhs) { return !operator==(lhs, rhs); }

template
typename std::enable_if::value, bool>::type
operator== (const expected& x, const T2& v) { return x.has_value() ? *x == v : false; }

template
bool operator== (const T2& v, const expected& x) { return x == v; }

template
bool operator!= (const expected& x, const T2& v) { return !(x == v); }

template
bool operator!= (const T2& v, const expected& x) { return !(x == v); }

template
bool operator== (const expected& x, const unexpected& e) { return x.has_value() ? false : x.error() == e.value(); }
template
bool operator== (const unexpected& e, const expected& x) { return x == e; }
template
bool operator!= (const expected& x, const unexpected& e) { return !(x == e); }
template
bool operator!= (const unexpected& e, const expected& x) { return !(x == e); }

template
void swap (expected& lhs, expected& rhs) { lhs.swap(rhs); }


}