errors.hpp

// (C) Copyright 2025, SECO Mind Srl
//
// SPDX-License-Identifier: Apache-2.0
 
#ifndef ASTARTE_DEVICE_SDK_ERRORS_H
#define ASTARTE_DEVICE_SDK_ERRORS_H
 
#include <memory>
#include <optional>
#include <string>
#include <variant>
 
#if defined(ASTARTE_USE_TL_EXPECTED)
#include "tl/expected.hpp"
#else
#include <expected>
#endif
 
#include "astarte_device_sdk/formatter.hpp"
 
namespace AstarteDeviceSdk {
 
#if defined(ASTARTE_USE_TL_EXPECTED)
namespace astarte_tl = ::tl;
#else
namespace astarte_tl = ::std;
#endif
 
class AstarteFileOpenError;
class AstarteInvalidInputError;
class AstarteInternalError;
class AstarteOperationRefusedError;
class AstarteGrpcLibError;
class AstarteMsgHubError;

using AstarteError =
    std::variant<AstarteInternalError, AstarteFileOpenError, AstarteInvalidInputError,
                 AstarteOperationRefusedError, AstarteGrpcLibError, AstarteMsgHubError>;

class AstarteErrorBase {
 public:
  virtual ~AstarteErrorBase();
  auto message() const -> const std::string&;
  auto type() const -> const std::string&;
  auto nested_error() const -> const std::shared_ptr<AstarteErrorBase>&;
 
 protected:
  explicit AstarteErrorBase(std::string_view type, std::string_view message);
  explicit AstarteErrorBase(std::string_view type, std::string_view message,
                            const AstarteErrorBase& other);
 
 private:
  std::string type_;
  std::string message_;
  std::shared_ptr<AstarteErrorBase> other_;
};

class AstarteInternalError : public AstarteErrorBase {
 public:
  explicit AstarteInternalError(std::string_view message);
  explicit AstarteInternalError(std::string_view message, const AstarteError& other);
 
 private:
  static constexpr std::string_view k_type_ = "AstarteInternalError";
};

class AstarteFileOpenError : public AstarteErrorBase {
 public:
  explicit AstarteFileOpenError(std::string_view filename);
  explicit AstarteFileOpenError(std::string_view filename, const AstarteError& other);
 
 private:
  static constexpr std::string_view k_type_ = "AstarteFileOpenError";
};

class AstarteInvalidInputError : public AstarteErrorBase {
 public:
  explicit AstarteInvalidInputError(std::string_view message);
  explicit AstarteInvalidInputError(std::string_view message, const AstarteError& other);
 
 private:
  static constexpr std::string_view k_type_ = "AstarteInvalidInputError";
};

class AstarteOperationRefusedError : public AstarteErrorBase {
 public:
  explicit AstarteOperationRefusedError(std::string_view message);
  explicit AstarteOperationRefusedError(std::string_view message, const AstarteError& other);
 
 private:
  static constexpr std::string_view k_type_ = "AstarteOperationRefusedError";
};

class AstarteGrpcLibError : public AstarteErrorBase {
 public:
  explicit AstarteGrpcLibError(std::string_view message);
  explicit AstarteGrpcLibError(std::string_view message, const AstarteError& other);
  explicit AstarteGrpcLibError(std::uint64_t code, std::string_view message);
  explicit AstarteGrpcLibError(std::uint64_t code, std::string_view message,
                               const AstarteError& other);
 
 private:
  static constexpr std::string_view k_type_ = "AstarteGrpcLibError";
};

class AstarteMsgHubError : public AstarteErrorBase {
 public:
  explicit AstarteMsgHubError(std::string_view message);
  explicit AstarteMsgHubError(std::string_view message, const AstarteError& other);
 
 private:
  static constexpr std::string_view k_type_ = "AstarteMsgHubError";
};
 
}  // namespace AstarteDeviceSdk


template <>
struct astarte_fmt::formatter<AstarteDeviceSdk::AstarteErrorBase> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) const {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const AstarteDeviceSdk::AstarteErrorBase& err, FormatContext& ctx) const {
    auto out = astarte_fmt::format_to(ctx.out(), "{}: {}", err.type(), err.message());
 
    std::string indent = "";
    const AstarteDeviceSdk::AstarteErrorBase* current = &err;
    while (const auto& nested = current->nested_error()) {
      indent += "  ";
      out = astarte_fmt::format_to(out, "\n{}-> {}: {}", indent, nested->type(), nested->message());
      current = nested.get();
    }
 
    return out;
  }
};

template <>
struct astarte_fmt::formatter<AstarteDeviceSdk::AstarteError> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) const {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const AstarteDeviceSdk::AstarteError& err_variant, FormatContext& ctx) const {
    return std::visit(
        [&ctx](const auto& err) {
          const auto& base_err = static_cast<const AstarteDeviceSdk::AstarteErrorBase&>(err);
          return astarte_fmt::format_to(ctx.out(), "{}", base_err);
        },
        err_variant);
  }
};

 
#endif  // ASTARTE_DEVICE_SDK_ERRORS_H