expected.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <tenno/functional.hpp>
#include <tenno/utility.hpp> // tenno::move
 
namespace tenno
{
 
template <typename E> class unexpected
{
public:
  const E unex;
  constexpr unexpected() : unex(E())
  {
  }
  constexpr unexpected(const E unex_in) : unex(unex_in)
  {
  }
};
 
template <typename T, typename E> class expected
{
public:
  bool has_val;
  const T val;
  const unexpected<E> unex;
 
  constexpr expected(const T val_in) : has_val(true), val(val_in), unex(E())
  {
  }
 
  constexpr expected(const unexpected<E> unex_val)
      : has_val(false), val(T()), unex(unex_val)
  {
  }
 
  constexpr explicit operator bool() const noexcept
  {
    return has_val;
  }
 
  constexpr bool operator==(const expected<T, E> &other) const noexcept
  {
    if (has_val != other.has_val)
    {
      return false;
    }
    if (has_val)
    {
      return val == other.val;
    }
    return unex.unex == other.unex.unex;
  }
 
  constexpr bool operator!=(const expected<T, E> &other) const noexcept
  {
    return !(*this == other);
  }
 
  constexpr auto operator=(const expected<T, E> &other) noexcept
    -> expected<T, E> &
  {
    has_val = other.has_val;
    val = other.val;
    unex = other.unex;
    return *this;
  }
 
  constexpr bool has_value() const noexcept
  {
    return has_val;
  }
 
  constexpr T value() const noexcept
  {
    return val;
  }
 
  constexpr E error() const noexcept
  {
    return unex.unex;
  }
 
  constexpr T value_or(const T default_val) const noexcept
  {
    if (has_val)
    {
      return val;
    }
    return default_val;
  }
 
  constexpr E error_or(const E default_err) const noexcept
  {
    if (!has_val)
    {
      return unex.unex;
    }
    return default_err;
  }
 
  // TODO:
  // - and_then
  // - transform
  // - or_else
  // - transform_error
};
 
} // namespace tenno