errors.hpp

Go to the documentation of this file.

// (C) Copyright 2025 - 2026, SECO Mind Srl
//
// SPDX-License-Identifier: Apache-2.0
 
#ifndef ASTARTE_DEVICE_SDK_ERRORS_H
#define ASTARTE_DEVICE_SDK_ERRORS_H

 
#if defined(ASTARTE_USE_TL_EXPECTED)
#include <tl/expected.hpp>
#else
#include <expected>
#endif
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <variant>
 
#include "astarte_device_sdk/formatter.hpp"
 
namespace astarte::device {
 
#if defined(ASTARTE_USE_TL_EXPECTED)
namespace astarte_tl = ::tl;
#else
namespace astarte_tl = ::std;
#endif
 
class DataSerializationError;
class FileOpenError;
class InvalidInputError;
class InternalError;
class OperationRefusedError;
class GrpcLibError;
class MsgHubError;
class InterfaceValidationError;
class InvalidInterfaceVersionError;
class InvalidInterfaceTypeError;
class InvalidInterfaceOwnershipeError;
class InvalidInterfaceAggregationError;
class InvalidReliabilityError;
class InvalidAstarteTypeError;
class InvalidRetentionError;
class InvalidDatabaseRetentionPolicyError;
#if !defined(ASTARTE_TRANSPORT_GRPC)
namespace mqtt {
class JsonParsingError;
class DeviceRegistrationError;
class PairingApiError;
class MqttError;
class InvalidUrlError;
class RetrieveBrokerUrlError;
class ReadCredentialError;
class WriteCredentialError;
class PairingConfigError;
class CryptoError;
class UuidError;
class HttpError;
class MqttConnectionError;
}  // namespace mqtt
#endif

using Error =
    std::variant<DataSerializationError, InternalError, FileOpenError, InvalidInputError,
                 InterfaceValidationError, InvalidInterfaceVersionError, InvalidInterfaceTypeError,
                 InvalidInterfaceOwnershipeError, InvalidInterfaceAggregationError,
                 InvalidAstarteTypeError, InvalidReliabilityError, InvalidRetentionError,
                 InvalidDatabaseRetentionPolicyError,
#if !defined(ASTARTE_TRANSPORT_GRPC)
                 OperationRefusedError, GrpcLibError, MsgHubError, mqtt::JsonParsingError,
                 mqtt::DeviceRegistrationError, mqtt::PairingApiError, mqtt::MqttError,
                 mqtt::InvalidUrlError, mqtt::RetrieveBrokerUrlError, mqtt::ReadCredentialError,
                 mqtt::WriteCredentialError, mqtt::PairingConfigError, mqtt::CryptoError,
                 mqtt::UuidError, mqtt::HttpError, mqtt::MqttConnectionError>;
#else
                 OperationRefusedError, GrpcLibError, MsgHubError>;
#endif

class ErrorBase {
 public:
  virtual ~ErrorBase() = default;

  ErrorBase(const ErrorBase&) = default;

  auto operator=(const ErrorBase&) -> ErrorBase& = default;

  ErrorBase(ErrorBase&&) = delete;

  auto operator=(ErrorBase&&) -> ErrorBase& = default;

  [[nodiscard]] auto message() const -> const std::string&;

  [[nodiscard]] auto type() const -> const std::string&;

  [[nodiscard]] auto nested_error() const -> const std::shared_ptr<ErrorBase>&;
 
 protected:
  explicit ErrorBase(std::string_view type, std::string_view message);

  explicit ErrorBase(std::string_view type, std::string_view message, const ErrorBase& other);
 
 private:
  std::string type_;
  std::string message_;
  std::shared_ptr<ErrorBase> other_;
};

class DataSerializationError : public ErrorBase {
 public:
  explicit DataSerializationError(std::string_view message);

  explicit DataSerializationError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "DataSerializationError";
};

class InternalError : public ErrorBase {
 public:
  explicit InternalError(std::string_view message);

  explicit InternalError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InternalError";
};

class FileOpenError : public ErrorBase {
 public:
  explicit FileOpenError(std::string_view filename);

  explicit FileOpenError(std::string_view filename, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "FileOpenError";
};

class InvalidInputError : public ErrorBase {
 public:
  explicit InvalidInputError(std::string_view message);

  explicit InvalidInputError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidInputError";
};

class OperationRefusedError : public ErrorBase {
 public:
  explicit OperationRefusedError(std::string_view message);

  explicit OperationRefusedError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "OperationRefusedError";
};

class GrpcLibError : public ErrorBase {
 public:
  explicit GrpcLibError(std::string_view message);

  explicit GrpcLibError(std::string_view message, const Error& other);

  explicit GrpcLibError(std::uint64_t code, std::string_view message);

  explicit GrpcLibError(std::uint64_t code, std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "GrpcLibError";
};

class MsgHubError : public ErrorBase {
 public:
  explicit MsgHubError(std::string_view message);

  explicit MsgHubError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "MsgHubError";
};
 
// -----------------------------------------------------------------------------
// Interface validation errors
// -----------------------------------------------------------------------------

class InterfaceValidationError : public ErrorBase {
 public:
  explicit InterfaceValidationError(std::string_view message);

  explicit InterfaceValidationError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InterfaceValidationError";
};

class InvalidInterfaceVersionError : public ErrorBase {
 public:
  explicit InvalidInterfaceVersionError(std::string_view message);

  explicit InvalidInterfaceVersionError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidInterfaceVersionError";
};

class InvalidInterfaceTypeError : public ErrorBase {
 public:
  explicit InvalidInterfaceTypeError(std::string_view message);

  explicit InvalidInterfaceTypeError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidInterfaceTypeError";
};

class InvalidInterfaceOwnershipeError : public ErrorBase {
 public:
  explicit InvalidInterfaceOwnershipeError(std::string_view message);

  explicit InvalidInterfaceOwnershipeError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidInterfaceOwnershipeError";
};

class InvalidInterfaceAggregationError : public ErrorBase {
 public:
  explicit InvalidInterfaceAggregationError(std::string_view message);

  explicit InvalidInterfaceAggregationError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidInterfaceAggregationError";
};

class InvalidAstarteTypeError : public ErrorBase {
 public:
  explicit InvalidAstarteTypeError(std::string_view message);

  explicit InvalidAstarteTypeError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidAstarteTypeError";
};

class InvalidReliabilityError : public ErrorBase {
 public:
  explicit InvalidReliabilityError(std::string_view message);

  explicit InvalidReliabilityError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidReliabilityError";
};

class InvalidRetentionError : public ErrorBase {
 public:
  explicit InvalidRetentionError(std::string_view message);

  explicit InvalidRetentionError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidRetentionError";
};

class InvalidDatabaseRetentionPolicyError : public ErrorBase {
 public:
  explicit InvalidDatabaseRetentionPolicyError(std::string_view message);

  explicit InvalidDatabaseRetentionPolicyError(std::string_view message, const Error& other);
 
 private:
  static constexpr std::string_view k_type_ = "InvalidDatabaseRetentionPolicyError";
};
 
}  // namespace astarte::device
 
#if !defined(ASTARTE_TRANSPORT_GRPC)
// We accept this circular inclusion as it's required for the forward declarations above to work
// even when an user includes only this header.
// NOLINTNEXTLINE(misc-header-include-cycle)
#include "astarte_device_sdk/mqtt/errors.hpp"
#endif

template <>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct astarte_fmt::formatter<astarte::device::Error> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) const {
    return ctx.begin();
  }

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

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

  template <typename FormatContext>
  auto format(const astarte::device::ErrorBase& err, FormatContext& ctx) const {
    auto out = astarte_fmt::format_to(ctx.out(), "{}: {}", err.type(), err.message());
 
    std::string indent;
    const astarte::device::ErrorBase* 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;
  }
};
 
#endif  // ASTARTE_DEVICE_SDK_ERRORS_H