Result.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Result.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2019 CERN for the benefit of the Acts project
//
// 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/.

#pragma once

#include <optional>
#include <system_error>
#include <type_traits>
#include <utility>
#include <variant>

namespace Acts {

template <typename T, typename E = std::error_code>
class Result {
  Result(std::variant<T, E>&& var) : m_var(var) {}

 public:
  Result() = delete;

  Result(const Result<T, E>& other) = delete;

  Result<T, E>& operator=(const Result<T, E>& other) = delete;

  Result(Result<T, E>&& other) : m_var(std::move(other.m_var)){};

  Result<T, E>& operator=(Result<T, E>&& other) {
    m_var = std::move(other.m_var);
    return *this;
  }

  template <
      typename T2, typename _E = E, typename _T = T,
      typename = std::enable_if_t<
          (!std::is_same_v<_T, _E> && !std::is_constructible_v<_T, _E> &&
           !std::is_convertible_v<_T, _E> && !std::is_constructible_v<_E, _T> &&
           !std::is_convertible_v<_E, _T> &&
           !(std::is_convertible_v<T2, _T> && std::is_convertible_v<T2, _E>))>>
  Result(T2 value) noexcept
      : m_var(std::conditional_t<std::is_convertible_v<T2, _T>, T, E>{
            std::move(value)}) {}

  template <
      typename T2, typename _E = E, typename _T = T,
      typename = std::enable_if_t<
          (!std::is_same_v<_T, _E> && !std::is_constructible_v<_T, _E> &&
           !std::is_convertible_v<_T, _E> && !std::is_constructible_v<_E, _T> &&
           !std::is_convertible_v<_E, _T> &&
           !(std::is_convertible_v<T2, _T> && std::is_convertible_v<T2, _E>))>>
  Result<T, E>& operator=(T2 value) noexcept {
    m_var = std::move(std::conditional_t<std::is_convertible_v<T2, _T>, T, E>{
        std::move(value)});
    return *this;
  }

  static Result<T, E> success(T value) {
    return Result<T, E>(
        std::variant<T, E>{std::in_place_index<0>, std::move(value)});
  }

  static Result<T, E> failure(E error) {
    return Result<T, E>(
        std::variant<T, E>{std::in_place_index<1>, std::move(error)});
  }

  bool ok() const noexcept { return m_var.index() == 0; }

  T& operator*() noexcept { return std::get<T>(m_var); }

  E& error() & noexcept { return std::get<E>(m_var); }

  E error() && noexcept { return std::move(std::get<E>(m_var)); }

  T& value() & {
    if (m_var.index() != 0) {
      if constexpr (std::is_same_v<E, std::error_code>) {
        std::stringstream ss;
        const auto& e = std::get<E>(m_var);
        ss << "Value called on error value: " << e.category().name() << ": "
           << e.message() << " [" << e.value() << "]";
        throw std::runtime_error(ss.str());
      } else {
        throw std::runtime_error("Value called on error value");
      }
    }

    return std::get<T>(m_var);
  }

  T value() && {
    if (m_var.index() != 0) {
      if constexpr (std::is_same_v<E, std::error_code>) {
        std::stringstream ss;
        const auto& e = std::get<E>(m_var);
        ss << "Value called on error value: " << e.category().name() << ": "
           << e.message() << " [" << e.value() << "]";
        throw std::runtime_error(ss.str());
      } else {
        throw std::runtime_error("Value called on error value");
      }
    }

    return std::move(std::get<T>(m_var));
  }

 private:
  std::variant<T, E> m_var;
};

template <typename E>
class Result<void, E> {
 public:
  Result() = default;

  Result(const Result<void, E>& other) = default;

  Result<void, E>& operator=(const Result<void, E>& other) = default;

  Result(Result<void, E>&& other) : m_opt(std::move(other.m_opt)){};

  Result<void, E>& operator=(Result<void, E>&& other) noexcept {
    m_opt = std::move(other.m_opt);
    return *this;
  }

  template <typename E2>
  Result(E2 error) noexcept : m_opt(std::move(error)) {}

  template <typename E2>
  Result<void, E>& operator=(E2 error) {
    m_opt = std::move(error);
    return *this;
  }

  static Result<void, E> success() { return Result<void, E>(); }

  static Result<void, E> failure(E error) {
    return Result<void, E>(std::move(error));
  }

  bool ok() const noexcept { return !m_opt; }

  E& error() & noexcept { return *m_opt; }

  E error() && noexcept { return std::move(*m_opt); }

 private:
  std::optional<E> m_opt;
};

}  // namespace Acts