exception.h

 
#pragma once
 
#include <exception>
#include <string>
 
namespace ucxx {
 
class Error : public std::exception {
 private:
  std::string _msg{};
 
 public:
  explicit Error(const std::string& msg) : _msg{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