result.h

Go to the documentation of this file.

// === result.h ========================================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_BASE_RESULT_H
#define SEN_CORE_BASE_RESULT_H
 
// sen
#include "sen/core/base/class_helpers.h"  // NOLINT(misc-include-cleaner)
 
// std
#include <string_view>
#include <tuple>
#include <type_traits>
#include <variant>
 
namespace sen
{

 
namespace impl
{

template <typename T>
struct Ok final
{
  using ValueT = T;
 
  explicit Ok(T theVal) noexcept(std::is_nothrow_move_constructible_v<T>): val(std::move(theVal)) {}
 
  ~Ok() noexcept = default;
  SEN_COPY_CONSTRUCT(Ok) = default;  // NOLINT(misc-include-cleaner)
  SEN_MOVE_CONSTRUCT(Ok) = default;  // NOLINT(misc-include-cleaner)
  SEN_COPY_ASSIGN(Ok) = default;     // NOLINT(misc-include-cleaner)
  SEN_MOVE_ASSIGN(Ok) = default;     // NOLINT(misc-include-cleaner)
 
  T val;  // NOLINT(misc-non-private-member-variables-in-classes)
};

template <>
struct Ok<void> final
{
};

template <typename E>
struct Err final
{
  using ValueT = E;
 
  explicit Err(E theVal) noexcept(std::is_nothrow_move_constructible_v<E>): val(std::move(theVal)) {}
 
  ~Err() noexcept = default;
  SEN_COPY_CONSTRUCT(Err) = default;
  SEN_MOVE_CONSTRUCT(Err) = default;
  SEN_COPY_ASSIGN(Err) = default;
  SEN_MOVE_ASSIGN(Err) = default;
 
  E val;  // NOLINT(misc-non-private-member-variables-in-classes)
};

template <>
struct Err<void> final
{
};

template <typename U>
using NonVoidT = std::enable_if_t<!std::is_void_v<U>, U>;

void resultExpect(bool value, std::string_view errorMsg = {}) noexcept;
 
}  // namespace impl

template <typename T, typename E>
class [[nodiscard]] Result final
{
  static_assert(!::std::is_void_v<E>, "void error type is not allowed");
 
public:  // types
  using ValueType = T;
  using ErrorType = E;
 
public:  // construction
  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  Result(impl::Ok<T>&& ok) noexcept: value_(std::in_place_type<T>, std::move(ok.val)) {}

  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  Result(impl::Err<E>&& err) noexcept: value_(std::in_place_type<E>, std::move(err.val)) {}
 
public:  // special members
  SEN_MOVE_CONSTRUCT(Result) = default;
  SEN_COPY_CONSTRUCT(Result) = default;
  SEN_MOVE_ASSIGN(Result) = default;
  SEN_COPY_ASSIGN(Result) = default;
  ~Result() = default;
 
public:  // conversion support
  template <typename U,
            typename G,
            std::enable_if_t<std::conjunction_v<std::is_constructible<T, const U&>, std::is_constructible<E, const G&>>,
                             bool> = true>
  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  Result(const Result<U, G>& other)
    : value_(
        [](const Result<U, G>& other)
        {
          if (other.isOk())
          {
            return decltype(value_)(std::in_place_type<T>, other.getValue());
          }
 
          return decltype(value_)(std::in_place_type<E>, other.getError());
        }(other))
  {
  }

  template <typename U,
            typename G,
            std::enable_if_t<std::conjunction_v<std::is_constructible<T, U>, std::is_constructible<E, G>>, bool> = true>
  // NOLINTNEXTLINE(hicpp-explicit-conversions)
  Result(Result<U, G>&& other)
    : value_(
        [](Result<U, G>&& other)
        {
          if (other.isOk())
          {
            return decltype(value_)(std::in_place_type<T>, std::move(other).getValue());
          }
 
          return decltype(value_)(std::in_place_type<E>, std::move(other).getError());
        }(std::move(other)))
  {
  }
 
public:  // comparison
  bool operator==(const Result& other) const { return value_ == other.value_; }
  bool operator!=(const Result& other) const { return !(*this == other); }
 
public:  // access
  [[nodiscard]] bool isOk() const noexcept { return std::holds_alternative<T>(value_); }

  [[nodiscard]] bool isError() const noexcept { return std::holds_alternative<E>(value_); }

  explicit operator bool() const noexcept { return isOk(); }

  template <typename U = T>
  [[nodiscard]] const impl::NonVoidT<U>& getValueOr(const U& defaultVal) const noexcept;

  template <typename U = T>
  [[nodiscard]] const impl::NonVoidT<U>& getValue() const&
  {
    impl::resultExpect(isOk());
    return std::get<T>(value_);
  }

  template <typename U = T>
  [[nodiscard]] impl::NonVoidT<U>&& getValue() &&
  {
    impl::resultExpect(isOk());
    return std::get<T>(std::move(value_));
  }

  [[nodiscard]] const E& getError() const
  {
    impl::resultExpect(isError());
    return std::get<E>(value_);
  }

  template <typename U = T>
  // resultExpect terminates the program when the state is wrong, so the std::get
  // below cannot actually throw.
  // NOLINTNEXTLINE(bugprone-exception-escape)
  [[nodiscard]] const impl::NonVoidT<U>& expect(std::string_view errorMsg = {}) const noexcept
  {
    impl::resultExpect(isOk(), errorMsg);
    return std::get<T>(value_);
  }
 
private:
  std::variant<E, T> value_;
};

using BoolResult = Result<void, std::monostate>;
 
//--------------------------------------------------------------------------------------------------------------
// Helpers
//--------------------------------------------------------------------------------------------------------------

template <typename T, typename CleanT = std::decay_t<T>>
impl::Ok<CleanT> Ok(T&& val) noexcept;  // NOLINT(readability-identifier-naming)

template <typename E, typename CleanE = std::decay_t<E>>
impl::Err<CleanE> Err(E&& val) noexcept;  // NOLINT(readability-identifier-naming)

impl::Ok<void> Ok() noexcept;  // NOLINT(readability-identifier-naming)

impl::Err<void> Err() noexcept;  // NOLINT(readability-identifier-naming)

 
//----------------------------------------------------------------------------------------------------------------------
// Inline implementation
//----------------------------------------------------------------------------------------------------------------------
 
template <typename T, typename E>
template <typename U>
inline const impl::NonVoidT<U>& Result<T, E>::getValueOr(const U& defaultVal) const noexcept
{
  if (const auto* maybeVal = std::get_if<T>(&value_))
  {
    return *maybeVal;
  }
 
  return defaultVal;
}

template <typename E>
class Result<void, E> final
{
  static_assert(!::std::is_void_v<E>, "void error type is not allowed");
 
public:
  using ValueType = void;
  using ErrorType = E;
 
public:
  Result(impl::Ok<void>&& arg) noexcept: ok_(true)  // NOLINT(hicpp-explicit-conversions)
  {
    std::ignore = arg;
  }
 
  template <typename T>
  Result(Result<T, E>&& other) noexcept  // NOLINT(hicpp-explicit-conversions)
    : ok_(other.isOk())
  {
  }
 
  Result(impl::Err<E>&& err) noexcept  // NOLINT(hicpp-explicit-conversions)
    : ok_(false), error_(std::move(err.val))
  {
  }
 
public:  // defaults
  Result(Result&& other) noexcept = default;
  Result(const Result& other) noexcept = default;
  ~Result() noexcept = default;
  Result& operator=(const Result& other) noexcept = default;
  Result& operator=(Result&& other) noexcept = default;
 
public:  // comparison
  bool operator==(const Result& other) const noexcept { return ok_ == other.ok_ && error_ == other.error_; }
 
  bool operator!=(const Result& other) const noexcept { return !(*this == other); }
 
public:  // access
  [[nodiscard]] bool isOk() const noexcept { return ok_; }
 
  [[nodiscard]] bool isError() const noexcept { return !isOk(); }
 
  explicit operator bool() const noexcept { return isOk(); }
 
  [[nodiscard]] const E& getError() const noexcept
  {
    impl::resultExpect(isError());
 
    return error_;
  }
 
private:
  bool ok_;
  E error_ = {};
};

template <>
class Result<void, std::monostate> final
{
public:
  using ValueType = void;
  using ErrorType = std::monostate;
 
public:
  Result(impl::Ok<void>&& arg) noexcept: ok_(true)  // NOLINT(hicpp-explicit-conversions)
  {
    std::ignore = arg;
  }
 
  Result(impl::Err<void>&& arg) noexcept: ok_(false)  // NOLINT(hicpp-explicit-conversions)
  {
    std::ignore = arg;
  }
 
public:  // defaults
  Result(Result&& other) noexcept = default;
  Result(const Result& other) noexcept = default;
  ~Result() noexcept = default;
  Result& operator=(const Result& other) noexcept = default;
  Result& operator=(Result&& other) noexcept = default;
 
public:  // comparison
  bool operator==(const Result& other) const noexcept { return ok_ == other.ok_; }
 
  bool operator!=(const Result& other) const noexcept { return !(*this == other); }
 
public:  // access
  [[nodiscard]] bool isOk() const noexcept { return ok_; }
 
  [[nodiscard]] bool isError() const noexcept { return !isOk(); }
 
  explicit operator bool() const noexcept { return isOk(); }
 
private:
  bool ok_;
};
 
template <typename T, typename CleanT>
inline impl::Ok<CleanT> Ok(T&& val) noexcept  // NOLINT(readability-identifier-naming)
{
  return impl::Ok<CleanT>(std::forward<T>(val));
}
 
template <typename E, typename CleanE>
inline impl::Err<CleanE> Err(E&& val) noexcept  // NOLINT(readability-identifier-naming)
{
  return impl::Err<CleanE>(std::forward<E>(val));
}
 
[[nodiscard]] inline impl::Ok<void> Ok() noexcept  // NOLINT(readability-identifier-naming)
{
  return {};
}
 
[[nodiscard]] inline impl::Err<void> Err() noexcept  // NOLINT(readability-identifier-naming)
{
  return {};
}
 
}  // namespace sen
 
#endif  // SEN_CORE_BASE_RESULT_H