result

// vi:set ft=cpp: -*- Mode: C++ -*-
 
#pragma once
 
#include <assert.h>
#include <stdlib.h>
 
#include "type_traits"
#include "utils"
 
namespace cxx {

class Error
{
  int _err;
 
public:
  constexpr explicit Error(int err) noexcept : _err(err) {}
  constexpr Error(Error const &) noexcept = default;
  constexpr Error(Error &&) noexcept = default;
 
  constexpr int error() const noexcept
  { return _err; }
};

template <typename T>
class Result
{
  // Wrapper providing a placement-new operator. Avoids depending on a global
  // placement-new overload (which is not available without <new>).
  struct Holder
  {
    T value;
 
    void *operator new (size_t, void *p) noexcept { return p; }
    void operator delete (void *) {}
 
    template<typename... Args>
    Holder(Args&&... args)
    noexcept(noexcept(T(cxx::forward<Args>(args)...)))
    : value(cxx::forward<Args>(args)...) {}
  };
 
  union
  {
    Holder _res;
    int _err;
  };
  bool _has_result;
 
public:
  Result() = delete;
 
  Result(Error err) noexcept
  : _err(err.error()), _has_result(false)
  {}
 
  template<typename... Args>
  explicit Result(in_place_t, Args&&... args)
  noexcept(noexcept(T(cxx::forward<Args>(args)...)))
  : _res(cxx::forward<Args>(args)...), _has_result(true)
  {}
 
  Result(T &&val)
  noexcept(noexcept(T(cxx::move(val))))
  : _res(cxx::move(val)), _has_result(true)
  {}
 
  Result(Result const &o)
  noexcept(noexcept(T(o._res.value)))
  : _has_result(o._has_result)
  {
    if (_has_result)
      new (&_res) Holder(o._res.value);
    else
      _err = o._err;
  }
 
  Result(Result &&o)
  noexcept(noexcept(T(cxx::move(o._res.value))))
  : _has_result(o._has_result)
  {
    if (_has_result)
      new (&_res) Holder(cxx::move(o._res.value));
    else
      _err = o._err;
  }
 
  ~Result()
  {
    if (_has_result)
      _res.~Holder();
  }
 
  Result &operator=(Result const &o)
  noexcept(noexcept(T(o._res.value)))
  {
    if (_has_result)
      _res.~Holder();
 
    _has_result = o._has_result;
    if (_has_result)
      new (&_res) Holder(o._res.value);
    else
      _err = o._err;
 
    return *this;
  }
 
  Result &operator=(Result &&o)
  {
    if (_has_result)
      {
        if (o._has_result)
          _res.value = cxx::move(o._res.value);
        else
          {
            _res.~Holder();
            _has_result = false;
            _err = o._err;
          }
      }
    else
      {
        if (o._has_result)
          {
            new (&_res) Holder(cxx::move(o._res.value));
            _has_result = true;
          }
        else
          _err = o._err;
      }
 
    return *this;
  }
 
  Result &operator=(Error err) noexcept
  {
    if (_has_result)
      _res.~Holder();
 
    _has_result = false;
    _err = err.error();
 
    return *this;
  }
 
  Result &operator=(T &&val)
  {
    if (_has_result)
      _res.value = cxx::move(val);
    else
      {
        new (&_res) Holder(cxx::move(val));
        _has_result = true;
      }
 
    return *this;
  }
 
  explicit operator bool() const noexcept
  { return _has_result; }
 
  int error() const noexcept
  { return _has_result ? 0 : _err; }
 
  T const &result() const & noexcept
  {
    assert(_has_result);
    if (!_has_result) [[unlikely]]
      abort();
 
    return _res.value;
  }
 
  T&& result() && noexcept
  {
    assert(_has_result);
    if (!_has_result) [[unlikely]]
      abort();
 
    return cxx::move(_res.value);
  }
};
 
}