result.hpp

// Copyright (c) 2022, Tyler Weaver
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright
//      notice, this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright
//      notice, this list of conditions and the following disclaimer in the
//      documentation and/or other materials provided with the distribution.
//
//    * Neither the name of the copyright holder nor the names of its
//      contributors may be used to endorse or promote products derived from
//      this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
 
#pragma once
 
#include <cxxabi.h>
#include <fmt/format.h>
 
#include <iostream>
#include <map>
#include <optional>
#include <string>
#include <string_view>
 
#include "fp/_external/expected.hpp"
#include "fp/no_discard.hpp"
 
namespace fp {
 
enum class ErrorCode : int {
  UNKNOWN,
  CANCELLED,
  INVALID_ARGUMENT,
  TIMEOUT,
  NOT_FOUND,
  ALREADY_EXISTS,
  PERMISSION_DENIED,
  RESOURCE_EXHAUSTED,
  FAILED_PRECONDITION,
  ABORTED,
  OUT_OF_RANGE,
  UNIMPLEMENTED,
  INTERNAL,
  UNAVAILABLE,
  DATA_LOSS,
  UNAUTHENTICATED,
  EXCEPTION,
};
 
struct [[nodiscard]] Error {
  ErrorCode code = ErrorCode::UNKNOWN;
  std::string what = "";
 
  inline bool operator==(const Error& other) const noexcept {
    return code == other.code && what == other.what;
  }
  inline bool operator!=(const Error& other) const noexcept {
    return code != other.code || what != other.what;
  }
};
 
constexpr auto Unknown = [](const std::string& what = "") {
  return Error{ErrorCode::UNKNOWN, what};
};
constexpr auto Cancelled = [](const std::string& what = "") {
  return Error{ErrorCode::CANCELLED, what};
};
constexpr auto InvalidArgument = [](const std::string& what = "") {
  return Error{ErrorCode::INVALID_ARGUMENT, what};
};
constexpr auto Timeout = [](const std::string& what = "") {
  return Error{ErrorCode::TIMEOUT, what};
};
constexpr auto NotFound = [](const std::string& what = "") {
  return Error{ErrorCode::NOT_FOUND, what};
};
constexpr auto AlreadyExists = [](const std::string& what = "") {
  return Error{ErrorCode::ALREADY_EXISTS, what};
};
constexpr auto PermissionDenied = [](const std::string& what = "") {
  return Error{ErrorCode::PERMISSION_DENIED, what};
};
constexpr auto ResourceExhausted = [](const std::string& what = "") {
  return Error{ErrorCode::RESOURCE_EXHAUSTED, what};
};
constexpr auto FailedPrecondition = [](const std::string& what = "") {
  return Error{ErrorCode::FAILED_PRECONDITION, what};
};
constexpr auto Aborted = [](const std::string& what = "") {
  return Error{ErrorCode::ABORTED, what};
};
constexpr auto OutOfRange = [](const std::string& what = "") {
  return Error{ErrorCode::OUT_OF_RANGE, what};
};
constexpr auto Unimplemented = [](const std::string& what = "") {
  return Error{ErrorCode::UNIMPLEMENTED, what};
};
constexpr auto Internal = [](const std::string& what = "") {
  return Error{ErrorCode::INTERNAL, what};
};
constexpr auto Unavailable = [](const std::string& what = "") {
  return Error{ErrorCode::UNAVAILABLE, what};
};
constexpr auto DataLoss = [](const std::string& what = "") {
  return Error{ErrorCode::DATA_LOSS, what};
};
constexpr auto Unauthenticated = [](const std::string& what = "") {
  return Error{ErrorCode::UNAUTHENTICATED, what};
};
constexpr auto Exception = [](const std::string& what = "") {
  return Error{ErrorCode::EXCEPTION, what};
};
 
[[nodiscard]] constexpr std::string_view toStringView(const ErrorCode& code) {
  switch (code) {
    case ErrorCode::CANCELLED:
      return "Cancelled";
    case ErrorCode::UNKNOWN:
      return "Unknown";
    case ErrorCode::INVALID_ARGUMENT:
      return "InvalidArgument";
    case ErrorCode::TIMEOUT:
      return "Timeout";
    case ErrorCode::NOT_FOUND:
      return "NotFound";
    case ErrorCode::ALREADY_EXISTS:
      return "AlreadyExists";
    case ErrorCode::PERMISSION_DENIED:
      return "PermissionDenied";
    case ErrorCode::RESOURCE_EXHAUSTED:
      return "ResourceExhausted";
    case ErrorCode::FAILED_PRECONDITION:
      return "FailedPrecondition";
    case ErrorCode::ABORTED:
      return "Aborted";
    case ErrorCode::OUT_OF_RANGE:
      return "OutOfRange";
    case ErrorCode::UNIMPLEMENTED:
      return "Unimplemented";
    case ErrorCode::INTERNAL:
      return "Internal";
    case ErrorCode::UNAVAILABLE:
      return "Unavailable";
    case ErrorCode::DATA_LOSS:
      return "DataLoss";
    case ErrorCode::UNAUTHENTICATED:
      return "Unauthenticated";
    case ErrorCode::EXCEPTION:
      return "Exception";
    default:
      __builtin_unreachable();
  }
}
 
template <typename T, typename E = Error>
using Result = tl::expected<T, E>;
 
template <typename T, typename E = Error>
constexpr Result<T, E> make_result(T value) {
  return Result<T, E>{value};
}
 
template <typename T, typename E>
constexpr bool has_error(const tl::expected<T, E>& exp) {
  return !exp;
}
 
template <typename E, typename... Args>
constexpr std::optional<E> maybe_error(tl::expected<Args, E>... args) {
  auto maybe = std::optional<E>{std::nullopt};
  (
      [&](auto& exp) {
        if (maybe.has_value()) return;
        if (has_error(exp)) maybe = exp.error();
      }(args),
      ...);
  return maybe;
}
 
template <typename F, typename Ret = typename std::result_of<F()>::type,
          typename Exp = Result<Ret>>
Exp try_to_result(F f) {
  try {
    return make_result(f());
  } catch (const std::exception& ex) {
    return tl::make_unexpected(Exception(fmt::format(
        "[{}: {}]", abi::__cxa_current_exception_type()->name(), ex.what())));
  }
}
 
}  // namespace fp
 
template <>
struct fmt::formatter<fp::Error> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) {
    return ctx.begin();
  }
 
  template <typename FormatContext>
  auto format(const fp::Error& error, FormatContext& ctx) {
    return format_to(ctx.out(), "[Error: [{}] {}]", toStringView(error.code),
                     error.what);
  }
};
 
template <typename T>
struct fmt::formatter<fp::Result<T>> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) {
    return ctx.begin();
  }
 
  template <typename FormatContext>
  auto format(const fp::Result<T>& result, FormatContext& ctx) {
    if (result.has_value()) {
      return format_to(ctx.out(), "[Result<T>: value={}]", result.value());
    } else {
      return format_to(ctx.out(), "[Result<T>: {}]", result.error());
    }
  }
};