result.h

Go to the documentation of this file.

/* Diagnostic Client library
 * Copyright (C) 2024  Avijit Dey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef DIAG_CLIENT_LIB_LIB_PLATFORM_CORE_RESULT_H_
#define DIAG_CLIENT_LIB_LIB_PLATFORM_CORE_RESULT_H_
 
#include <optional>
#include <type_traits>
#include <utility>
#include <variant>
 
#include "core/include/error_code.h"
 
namespace core_type {
 
template<typename T, typename E = ErrorCode>
class Result final {
 public:
  using value_type = T;
 
  using error_type = E;
 
  static Result FromValue(T &t) noexcept { return Result{t}; }
 
  static Result FromValue(T &&t) noexcept { return Result{std::move(t)}; }
 
  template<typename... Args>
  static Result FromValue(Args &&...args) noexcept {
    return Result{std::forward<Args>(args)...};
  }
 
  static Result FromError(const E &e) noexcept { return Result{e}; }
 
  static Result FromError(E &&e) noexcept { return Result{std::move(e)}; }
 
  template<typename... Args>
  static Result FromError(Args &&...args) noexcept {
    return Result{std::forward<Args>(args)...};
  }
 
  constexpr explicit Result(const T &t) noexcept : storage_{t} {}
 
  constexpr explicit Result(T &&t) noexcept : storage_{std::move(t)} {}
 
  constexpr explicit Result(const E &e) noexcept : storage_{e} {}
 
  constexpr explicit Result(E &&e) noexcept : storage_{std::move(e)} {}
 
  Result(const Result &other) = default;
 
  Result &operator=(const Result &other) = default;
 
  Result(Result &&other) noexcept(
      std::is_nothrow_move_constructible<T>::value &&std::is_nothrow_move_constructible<E>::value) = default;
 
  Result &operator=(Result &&other) noexcept(
      std::is_nothrow_move_constructible<T>::value &&std::is_nothrow_move_assignable<T>::value
          &&std::is_nothrow_move_constructible<E>::value &&std::is_nothrow_move_assignable<E>::value) = default;
 
  ~Result() noexcept = default;
 
  template<typename... Args>
  void EmplaceValue(Args &&...args) noexcept {
    storage_.template emplace<value_type>(std::forward<Args>(args)...);
  }
 
  template<typename... Args>
  void EmplaceError(Args &&...args) noexcept {
    storage_.template emplace<error_type>(std::forward<Args>(args)...);
  }
 
  bool HasValue() const noexcept { return std::holds_alternative<value_type>(storage_); }
 
  explicit operator bool() const noexcept { return HasValue(); }
 
  const T &operator*() const &noexcept { return std::get<value_type>(storage_); }
 
  T &&operator*() &&noexcept { return std::move(std::get<value_type>(storage_)); }
 
  const T *operator->() const noexcept { return std::get_if<value_type>(storage_); }
 
  const T &Value() const &noexcept { return std::get<value_type>(storage_); }
 
  T &&Value() &&noexcept { return std::move(std::get<value_type>(storage_)); }
 
  const E &Error() const &noexcept { return std::get<error_type>(storage_); }
 
  E &&Error() &&noexcept { return std::move(std::get<error_type>(storage_)); }
 
  std::optional<T> Ok() const &noexcept {
    std::optional<T> opt_val{};
    if (HasValue()) { opt_val.emplace(Value()); }
    return opt_val;
  }
 
  std::optional<T> Ok() &&noexcept {
    std::optional<T> opt_val{};
    if (HasValue()) { opt_val.emplace(std::move(Value())); }
    return opt_val;
  }
 
  std::optional<E> Err() const &noexcept {
    std::optional<E> opt_err{};
    if (!HasValue()) { opt_err.emplace(Error()); }
    return opt_err;
  }
 
  std::optional<E> Err() &&noexcept {
    std::optional<E> opt_err{};
    if (!HasValue()) { opt_err.emplace(std::move(Error())); }
    return opt_err;
  }
 
  template<typename F, typename T2 = typename std::invoke_result_t<F, T>>
  Result<T2, E> AndThen(F &&fn) &&noexcept {
    return HasValue() ? Result<T2, E>{fn(std::move(*this).Value())} : Result<T2, E>{*this};
  }
 
  template<typename F, typename E2 = std::invoke_result_t<F, E>>
  Result<T, E2> MapError(F &&fn) {
    return HasValue() ? Result<T, E2>{std::move(*this).Value()} : Result<T, E2>{fn(std::move(*this).Error())};
  }
 
  template<typename F>
  Result OrElse(F &&fn) &&noexcept {
    return HasValue() ? Result{std::move(*this)} : Result{fn(std::move(*this).Error())};
  }
 
  template<typename U>
  T ValueOr(U &&defaultValue) const &noexcept {
    return HasValue() ? Result{*this} : static_cast<T>(defaultValue);
  }
 
  template<typename U>
  T ValueOr(U &&defaultValue) &&noexcept {
    return HasValue() ? Result{std::move(*this)} : static_cast<T>(defaultValue);
  }
 
  template<typename G>
  E ErrorOr(G &&defaultError) const &noexcept {
    return !HasValue() ? Result{*this} : static_cast<E>(defaultError);
  }
 
  template<typename G>
  E ErrorOr(G &&defaultError) &&noexcept {
    return !HasValue() ? Result{std::move(*this)} : static_cast<E>(defaultError);
  }
 
  template<typename F>
  T Resolve(F &&f) const {
    return HasValue() ? Result{*this} : f(Error());
  }
 
 private:
  std::variant<T, E> storage_;
};
 
template<typename E>
class Result<void, E> final {
 public:
  using value_type = void;
 
  using error_type = E;
 
  static Result FromValue() noexcept { return Result{}; }
 
  static Result FromError(const E &e) noexcept { return Result{e}; }
 
  static Result FromError(E &&e) noexcept { return Result{std::move(e)}; }
 
  template<typename... Args>
  static Result FromError(Args &&...args) noexcept {
    return Result{std::forward<Args>(args)...};
  }
 
  constexpr explicit Result() noexcept : storage_{empty_value{}} {}
 
  constexpr explicit Result(const E &e) noexcept : storage_{e} {}
 
  constexpr explicit Result(E &&e) noexcept : storage_{std::move(e)} {}
 
  Result(const Result &other) = default;
 
  Result &operator=(const Result &other) = default;
 
  Result(Result &&other) noexcept(std::is_nothrow_move_constructible<E>::value) = default;
 
  Result &operator=(Result &&other) noexcept(
      std::is_nothrow_move_constructible<E>::value &&std::is_nothrow_move_assignable<E>::value) = default;
 
  ~Result() noexcept { static_assert(std::is_trivially_destructible<E>::value); }
 
  void EmplaceValue() noexcept { storage_.EmplaceValue(empty_value{}); }
 
  template<typename... Args>
  void EmplaceError(Args &&...args) noexcept {
    storage_.EmplaceError(std::forward<Args>(args)...);
  }
 
  bool HasValue() const noexcept { return storage_.HasValue(); }
 
  explicit operator bool() const noexcept { return HasValue(); }
 
  const E &Error() const &noexcept { return storage_.Error(); }
 
  E &&Error() &&noexcept { return std::move(storage_.Error()); }
 
  std::optional<E> Err() const &noexcept {
    std::optional<E> opt_err{};
    if (!HasValue()) { opt_err.emplace(Error()); }
    return opt_err;
  }
 
  std::optional<E> Err() &&noexcept {
    std::optional<E> opt_err{};
    if (!HasValue()) { opt_err.emplace(std::move(Error())); }
    return opt_err;
  }
 
  template<typename F, typename E2 = std::invoke_result_t<F, E>>
  Result<void, E2> MapError(F &&fn) {
    return HasValue() ? Result<void, E2>{} : Result<void, E2>{fn(Error())};
  }
 
  template<typename F, typename E2 = std::invoke_result_t<F, E>>
  Result<void, E2> CheckError(F &&fn) {
    return HasValue() ? Result<void, E2>{} : Result<void, E2>{fn(Error())};
  }
 
  template<typename F>
  Result AndThen(F &&fn) &&noexcept {
    if (HasValue()) { fn(); }
    return Result{std::move(*this)};
  }
 
  template<typename F>
  Result OrElse(F &&fn) &&noexcept {
    return HasValue() ? Result{std::move(*this)} : Result{fn(Error())};
  }
 
  template<typename G>
  E ErrorOr(G &&defaultError) const &noexcept {
    return !HasValue() ? Result{*this} : static_cast<E>(defaultError);
  }
 
  template<typename G>
  E ErrorOr(G &&defaultError) &&noexcept {
    return !HasValue() ? Result{std::move(*this)} : static_cast<E>(defaultError);
  }
 
  template<typename F>
  void Resolve(F &&f) const {
    f(Error());
  }
 
 private:
  struct empty_value {};
 
  Result<empty_value, E> storage_;
};
 
}  // namespace core_type
 
#endif  // DIAG_CLIENT_LIB_LIB_PLATFORM_CORE_RESULT_H_