exception.h

#pragma once
 
#include <exception>
#include <string>
#include <utility>
 
namespace ucxx {

class Error : public std::exception {
 private:
  std::string _msg{};
 
 public:
  explicit Error(const std::string& msg) : _msg{std::move(msg)} {}

  const char* what() const noexcept override { return this->_msg.c_str(); }
};

class NoMessageError : public Error {
 public:
  explicit NoMessageError(const std::string& msg) : Error(msg) {}
};

class NoResourceError : public Error {
 public:
  explicit NoResourceError(const std::string& msg) : Error(msg) {}
};

class IOError : public Error {
 public:
  explicit IOError(const std::string& msg) : Error(msg) {}
};

class NoMemoryError : public Error {
 public:
  explicit NoMemoryError(const std::string& msg) : Error(msg) {}
};

class InvalidParamError : public Error {
 public:
  explicit InvalidParamError(const std::string& msg) : Error(msg) {}
};

class UnreachableError : public Error {
 public:
  explicit UnreachableError(const std::string& msg) : Error(msg) {}
};

class InvalidAddrError : public Error {
 public:
  explicit InvalidAddrError(const std::string& msg) : Error(msg) {}
};

class NotImplementedError : public Error {
 public:
  explicit NotImplementedError(const std::string& msg) : Error(msg) {}
};

class MessageTruncatedError : public Error {
 public:
  explicit MessageTruncatedError(const std::string& msg) : Error(msg) {}
};

class NoProgressError : public Error {
 public:
  explicit NoProgressError(const std::string& msg) : Error(msg) {}
};

class BufferTooSmallError : public Error {
 public:
  explicit BufferTooSmallError(const std::string& msg) : Error(msg) {}
};

class NoElemError : public Error {
 public:
  explicit NoElemError(const std::string& msg) : Error(msg) {}
};

class SomeConnectsFailedError : public Error {
 public:
  explicit SomeConnectsFailedError(const std::string& msg) : Error(msg) {}
};

class NoDeviceError : public Error {
 public:
  explicit NoDeviceError(const std::string& msg) : Error(msg) {}
};

class BusyError : public Error {
 public:
  explicit BusyError(const std::string& msg) : Error(msg) {}
};

class CanceledError : public Error {
 public:
  explicit CanceledError(const std::string& msg) : Error(msg) {}
};

class ShmemSegmentError : public Error {
 public:
  explicit ShmemSegmentError(const std::string& msg) : Error(msg) {}
};

class AlreadyExistsError : public Error {
 public:
  explicit AlreadyExistsError(const std::string& msg) : Error(msg) {}
};

class OutOfRangeError : public Error {
 public:
  explicit OutOfRangeError(const std::string& msg) : Error(msg) {}
};

class TimedOutError : public Error {
 public:
  explicit TimedOutError(const std::string& msg) : Error(msg) {}
};

class ExceedsLimitError : public Error {
 public:
  explicit ExceedsLimitError(const std::string& msg) : Error(msg) {}
};

class UnsupportedError : public Error {
 public:
  explicit UnsupportedError(const std::string& msg) : Error(msg) {}
};

class RejectedError : public Error {
 public:
  explicit RejectedError(const std::string& msg) : Error(msg) {}
};

class NotConnectedError : public Error {
 public:
  explicit NotConnectedError(const std::string& msg) : Error(msg) {}
};

class ConnectionResetError : public Error {
 public:
  explicit ConnectionResetError(const std::string& msg) : Error(msg) {}
};

class FirstLinkFailureError : public Error {
 public:
  explicit FirstLinkFailureError(const std::string& msg) : Error(msg) {}
};

class LastLinkFailureError : public Error {
 public:
  explicit LastLinkFailureError(const std::string& msg) : Error(msg) {}
};

class FirstEndpointFailureError : public Error {
 public:
  explicit FirstEndpointFailureError(const std::string& msg) : Error(msg) {}
};

class EndpointTimeoutError : public Error {
 public:
  explicit EndpointTimeoutError(const std::string& msg) : Error(msg) {}
};

class LastEndpointFailureError : public Error {
 public:
  explicit LastEndpointFailureError(const std::string& msg) : Error(msg) {}
};
 
}  // namespace ucxx