error.h

Go to the documentation of this file.

#pragma once
 
#include "millicast-sdk/exports.h"
 
#include <system_error>
 
namespace millicast {
class MILLICAST_API Error : public std::error_condition {
 public:
  Error() = default;
  Error(Error&&) noexcept = default;
  Error(const Error&) = default;
  Error& operator=(Error&&) noexcept = default;
  Error& operator=(const Error&) = default;
  Error(int val, const std::error_category& cat) noexcept;
  Error(int val,
        const std::error_category& cat,
        const std::string& error_reason);
  Error(const std::exception_ptr& exception) noexcept;
 
  template <
      typename EnumT,
      typename X =
          std::enable_if_t<std::is_error_condition_enum<EnumT>::value, void>>
  Error(EnumT value) : Error(make_error_condition(value)) {}
 
  template <
      typename EnumT,
      typename X =
          std::enable_if_t<std::is_error_condition_enum<EnumT>::value, void>>
  Error(EnumT value, const std::string& reason)
      : Error(make_error_condition(value, reason)) {}
 
  template <
      typename EnumT,
      typename X =
          std::enable_if_t<std::is_error_condition_enum<EnumT>::value, void>>
  bool operator==(EnumT val) const {
    return make_error_condition(val) == *this;
  }
 
  [[nodiscard]] const std::string& message() const { return _message; }
 
 private:
  std::string _message{};
};
 
template <typename T>
struct MILLICAST_TEMPLATE_API ErrorCategoryBase : public std::error_category {
  static const T& instance() {
    static T inst;
    return inst;
  }
};
 
class MILLICAST_API AsyncOperationCancelled final
    : public ErrorCategoryBase<AsyncOperationCancelled> {
 public:
  enum Value {
    MULTIPLE_RESOLVE = 1,  
    ABORTED,    
    ABANDONED,  
    ACTOR_SHUTDOWN,  
    TIMEOUT,         
  };
 
  [[nodiscard]] const char* name() const noexcept override;
  [[nodiscard]] std::string message(int ev) const override;
};
 
class MILLICAST_API GenericError : public ErrorCategoryBase<GenericError> {
 public:
  enum Value {
    EXCEPTION_THROWN = 1,  
    INVALID_JSON,          
    INVALID_JSON_SCHEMA,  
    TRANSACTION_ERROR,    
    NO_CREDENTIALS,       
    INVALID_OPTIONS,      
    INVALID_STATE,        
    REST_API_ERROR,       
    WEBSOCKET_HS_FAILED,  
    PEERCONNECTION_CREATE,             
    PEERCONNECTION_CREATE_OFFER,       
    PEERCONNECTION_LOCAL_DESC,         
    PEERCONNECTION_REMOTE_DESC,        
    PEERCONNECTION_ADD_TRACKS_FAILED,  
    PEERCONNECTION_NOT_ESTABLISHED,    
    PEERCONNECTION_SET_TRANSFORM_FAILED,  
    NULL_LISTENER,  
    INVALID_MEDIA_PERMISSIONS 
  };
 
  [[nodiscard]] const char* name() const noexcept override;
  [[nodiscard]] std::string message(int ev) const override;
};
 
class MILLICAST_API HttpError : public ErrorCategoryBase<HttpError> {
 public:
  enum Value {
    UNAUTHORIZED = 401,
    REQUEST_ABORTED = -1,
    REQUEST_ABORTED_APPLE = 0,
    JNI_INVALID_ARGUMENT = -101,
    JNI_OUT_OF_RANGE = -102,
    EMPTY_RESPONSE = -103,
    UNKNOWN = -104,
  };
 
  [[nodiscard]] const char* name() const noexcept override;
  [[nodiscard]] std::string message(int ev) const override;
};
 
class MILLICAST_API Exception : public std::runtime_error {
 public:
  Exception(const Error& err);
  Exception(Error&& err);
 
  [[nodiscard]] const Error& get_error() const;
 
 private:
  Error _err;
};
 
template <typename EnumT>
std::enable_if_t<std::is_error_condition_enum<EnumT>::value, Error>
make_error_condition(EnumT value) {
  return make_error_condition(value, "");
}
 
Error MILLICAST_API make_error_condition(AsyncOperationCancelled::Value value,
                                         const std::string& message);
 
Error MILLICAST_API make_error_condition(GenericError::Value value,
                                         const std::string& message);
 
Error MILLICAST_API make_error_condition(HttpError::Value value,
                                         const std::string& message);
 
}  // namespace millicast
 
namespace std {
template <>
struct is_error_condition_enum<millicast::AsyncOperationCancelled::Value>
    : public std::true_type {};
template <>
struct is_error_condition_enum<millicast::GenericError::Value>
    : public std::true_type {};
}  // namespace std