result.hpp

Go to the documentation of this file.

 
#ifndef ZPP_INCLUDE_ZPP_RESULT_HPP
#define ZPP_INCLUDE_ZPP_RESULT_HPP
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <zpp/error_code.hpp>
 
#include <utility>
 
namespace zpp {
 
template<typename T_Error>
class error_result {
  static_assert(!std::is_void_v<T_Error>);
  static_assert(std::is_copy_constructible_v<T_Error>);
  static_assert(std::is_move_constructible_v<T_Error>);
  static_assert(std::is_copy_assignable_v<T_Error>);
  static_assert(std::is_move_assignable_v<T_Error>);
public:
  error_result() noexcept = delete;
 
  error_result(error_result&&) noexcept = default;
  error_result(const error_result&) noexcept = default;
  error_result& operator=(error_result&&) noexcept = default;
  error_result& operator=(const error_result&) noexcept = default;
 
  explicit error_result(const T_Error& rhs) noexcept
    : m_error(rhs)
  {
  }
 
  explicit error_result(T_Error&& rhs) noexcept
    : m_error(std::move(rhs))
  {
  }
 
  T_Error& error() noexcept {
    return m_error;
  }
 
  const T_Error& error() const noexcept {
    return m_error;
  }
private:
  T_Error m_error;
};
 
template<typename T_Ok, typename T_Error>
class result {
  static_assert(!std::is_void_v<T_Ok>);
  static_assert(std::is_copy_constructible_v<T_Ok>);
  static_assert(std::is_move_constructible_v<T_Ok>);
  static_assert(std::is_copy_assignable_v<T_Ok>);
  static_assert(std::is_move_assignable_v<T_Ok>);
 
  static_assert(!std::is_void_v<T_Error>);
  static_assert(std::is_copy_constructible_v<T_Error>);
  static_assert(std::is_move_constructible_v<T_Error>);
  static_assert(std::is_copy_assignable_v<T_Error>);
  static_assert(std::is_move_assignable_v<T_Error>);
public:
  result() noexcept
    : m_is_ok(false)
  {
    new(&m_error_value) T_Error();
  }
 
  result(const T_Ok& rhs) noexcept
    : m_is_ok(true)
  {
    new(&m_ok_value) T_Ok(rhs);
  }
 
  result(T_Ok&& rhs) noexcept
    : m_is_ok(true)
  {
    new(&m_ok_value) T_Ok(std::move(rhs));
  }
 
  result(const error_result<T_Error>& rhs) noexcept
    : m_is_ok(false)
  {
    new(&m_error_value) T_Error(rhs.error());
  }
 
 
  result(error_result<T_Error>&& rhs) noexcept
    : m_is_ok(false)
  {
    new(&m_error_value) T_Error(std::move(rhs.error()));
  }
 
  result(const result& rhs) noexcept
    : m_is_ok(rhs.m_is_ok)
  {
    if (m_is_ok) {
      new(&m_ok_value) T_Ok(rhs.m_ok_value);
    } else {
      new(&m_error_value) T_Error(rhs.m_error_value);
    }
  }
 
  result(result&& rhs) noexcept
    : m_is_ok(rhs.m_is_ok)
  {
    if (m_is_ok) {
      new(&m_ok_value) T_Ok(std::move(rhs.m_ok_value));
    } else {
      new(&m_error_value) T_Error(std::move(rhs.m_error_value));
    }
  }
 
  ~result() noexcept {
    if (m_is_ok) {
      m_ok_value.~T_Ok();
    } else {
      m_error_value.~T_Error();
    }
  }
 
  void assign_value(const T_Ok& v) noexcept {
    if (m_is_ok) {
      m_ok_value.~T_Ok();
    } else {
      m_error_value.~T_Error();
    }
 
    m_is_ok = true;
    new(&m_ok_value) T_Ok(v);
  }
 
  void assign_value(T_Ok&& v) noexcept {
    if (m_is_ok) {
      m_ok_value.~T_Ok();
    } else {
      m_error_value.~T_Error();
    }
 
    m_is_ok = true;
    new(&m_ok_value) T_Ok(std::move(v));
  }
 
  void assign_error(const T_Error& e) noexcept {
    if (m_is_ok) {
      m_ok_value.~T_Ok();
    } else {
      m_error_value.~T_Error();
    }
 
    m_is_ok = false;
    new(&m_error_value) T_Error(e);
  }
 
  void assign_error(T_Error&& e) noexcept {
    if (m_is_ok) {
      m_ok_value.~T_Ok();
    } else {
      m_error_value.~T_Error();
    }
 
    m_is_ok = false;
    new(&m_error_value) T_Error(std::move(e));
  }
 
 
  result& operator=(const result& rhs) noexcept
  {
    if (rhs.m_is_ok) {
      assign_value(rhs.m_ok_value);
    } else {
      assign_error(rhs.m_error_value);
    }
 
    return *this;
  }
 
  result& operator=(result&& rhs) noexcept
  {
    if (rhs.m_is_ok) {
      assign_value(std::move(rhs.m_ok_value));
    } else {
      assign_error(std::move(rhs.m_error_value));
    }
 
    return *this;
  }
 
 
  result& operator=(const T_Ok& rhs) noexcept
  {
    assign_value(rhs);
    return *this;
  }
 
  result& operator=(T_Ok&& rhs) noexcept
  {
    assign_value(std::move(rhs));
    return *this;
  }
 
  result& operator=(const error_result<T_Error>& rhs) noexcept
  {
    assign_error(rhs.error());
    return *this;
  }
 
  result& operator=(error_result<T_Error>&& rhs) noexcept
  {
    assign_error(std::move(rhs.error()));
    return *this;
  }
 
 
  T_Ok& value() noexcept {
    if (!m_is_ok) {
      // unhandeld error
    }
 
    return m_ok_value;
  }
 
  const T_Ok& value() const noexcept {
    if (!m_is_ok) {
      // unhandeld error
    }
 
    return m_ok_value;
  }
 
 
  T_Error& error() noexcept {
    if (m_is_ok) {
      // unhandeld error
    }
 
    return m_error_value;
  }
 
  const T_Error& error() const noexcept {
    if (m_is_ok) {
      // unhandeld error
    }
 
    return m_error_value;
  }
 
  T_Ok& operator*() noexcept {
    return value();
  }
 
  const T_Ok& operator*() const noexcept {
    return value();
  }
 
  T_Ok* operator->() noexcept {
    if (!m_is_ok) {
      // unhandeld error
    }
 
    return &m_ok_value;
  }
 
  const T_Ok* operator->() const noexcept {
    if (!m_is_ok) {
      // unhandeld error
    }
 
    return &m_ok_value;
  }
 
  constexpr bool has_value() const noexcept {
    return m_is_ok;
  }
 
  constexpr explicit operator bool() const noexcept {
    return m_is_ok;
  }
private:
  bool m_is_ok{false};
  union {
    T_Error m_error_value;
    T_Ok    m_ok_value;
  };
};
 
template<typename T_Error>
class result<void, T_Error> {
  static_assert(!std::is_void_v<T_Error>);
  static_assert(std::is_copy_constructible_v<T_Error>);
  static_assert(std::is_move_constructible_v<T_Error>);
  static_assert(std::is_copy_assignable_v<T_Error>);
  static_assert(std::is_move_assignable_v<T_Error>);
public:
  result() noexcept = default;
 
  result(const error_result<T_Error>& rhs) noexcept
    : m_is_ok(false)
    , m_error_value( rhs.error() )
  {
  }
 
  result(error_result<T_Error>&& rhs) noexcept
    : m_is_ok(false)
    , m_error_value( std::move(rhs.error()) )
  {
  }
 
  result(const result& rhs) noexcept = default;
 
  result(result&& rhs) noexcept = default;
 
  ~result() noexcept = default;
 
  result& operator=(const result& rhs) noexcept = default;
 
  result& operator=(result&& rhs) noexcept = default;
 
 
  void assign_value() noexcept {
    m_is_ok = true;
  }
 
  void assign_error(const T_Error& e) noexcept {
    m_is_ok = false;
    m_error_value = T_Error(e);
  }
 
  void assign_error(T_Error&& e) noexcept {
    m_is_ok = false;
    m_error_value = T_Error(std::move(e));
  }
 
  result& operator=(const error_result<T_Error>& rhs) noexcept
  {
    assign_error(rhs.error());
    return *this;
  }
 
  result& operator=(error_result<T_Error>&& rhs) noexcept
  {
    assign_error(std::move(rhs.error()));
    return *this;
  }
 
  void value() noexcept {
    if (!m_is_ok) {
      // unhandeld error
    }
  }
 
  void value() const noexcept {
    if (!m_is_ok) {
      // unhandeld error
    }
  }
 
  T_Error& error() noexcept {
    if (m_is_ok) {
      // unhandeld error
    }
 
    return m_error_value;
  }
 
  const T_Error& error() const noexcept {
    if (m_is_ok) {
      // unhandeld error
    }
 
    return m_error_value;
  }
 
  constexpr bool has_value() const noexcept {
    return m_is_ok;
  }
 
  constexpr explicit operator bool() const noexcept {
    return m_is_ok;
  }
private:
  bool m_is_ok{false};
  T_Error m_error_value;
};
 
 
template<typename T_Ok, typename T_Error>
constexpr bool operator==(const result<T_Ok, T_Error>& lhs, bool rhs) noexcept {
  return bool(lhs) == bool(rhs);
}
 
template<typename T_Ok, typename T_Error>
constexpr bool operator==(bool lhs, const result<T_Ok, T_Error>& rhs) noexcept {
  return bool(lhs) == bool(rhs);
}
 
template<typename T_Ok, typename T_Error>
constexpr bool operator!=(const result<T_Ok, T_Error>& lhs, bool rhs) noexcept {
  return bool(lhs) != bool(rhs);
}
 
template<typename T_Ok, typename T_Error>
constexpr bool operator!=(bool lhs, const result<T_Ok, T_Error>& rhs) noexcept {
  return bool(lhs) != bool(rhs);
}
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_RESULT_HPP