HyperException.hpp

Go to the documentation of this file.

 
#ifndef TABLEAU_HYPER_HYPEREXCEPTION_HPP
#define TABLEAU_HYPER_HYPEREXCEPTION_HPP
 
#include <hyperapi/impl/infra.hpp>
#include <hyperapi/optional.hpp>
#include <hyperapi/hyperapi.h>
 
#include <cassert>
#include <memory>
#include <string>
#include <system_error>
 
namespace hyperapi {
 
class ContextId final {
   const uint32_t value_;
 
   public:
   constexpr explicit ContextId(uint32_t value) noexcept
      : value_(value) {
   }
   constexpr uint32_t getValue() const noexcept { return value_; }
};
 
namespace internal {
HyperException makeHyperException(const std::string&, const std::string&, ContextId);
}
 
class HyperException final : public std::exception {
   public:
   HyperException& operator=(const HyperException& other) noexcept;
   HyperException(const HyperException& other) noexcept;
   HyperException& operator=(HyperException&& other) = default;
   HyperException(HyperException&& other) = default;
 
   const char* getMainMessage() const noexcept { return getStringField(HYPER_ERROR_FIELD_MESSAGE); }
 
   const char* getHint() const noexcept { return getStringField(HYPER_ERROR_FIELD_HINT_MESSAGE); }
 
   HYPER_DEPRECATED("Use getMainMessage() instead. This function will be removed in the future.")
   const char*
   getMessage() const noexcept {
      return getMainMessage();
   }
 
   HYPER_DEPRECATED("Use getHint() instead. This function will be removed in the future.")
   const char*
   getHintMessage() const noexcept {
      return getHint();
   }
 
   HYPER_DEPRECATED("Use getCause().has_value() instead. This function will be removed in the future.")
   bool hasCause() const noexcept { return (getCauseHandle() != nullptr); }
 
   optional<HyperException> getCause() const noexcept;
 
   ContextId getContextId() const noexcept { return ContextId(getUIntField(HYPER_ERROR_FIELD_CONTEXT_ID)); }
 
   std::string toString() const;
 
   const char* what() const noexcept override;
 
   private:
   explicit HyperException(hyper_error_t* error);
 
   explicit HyperException(hyper_error_t* error, std::shared_ptr<const hyper_error_t> top_level_error);
 
   const char* getStringField(hyper_error_field_key key) const noexcept;
 
   int getIntField(hyper_error_field_key key) const noexcept;
 
   uint32_t getUIntField(hyper_error_field_key key) const noexcept;
 
   hyper_error_t* getCauseHandle() const noexcept;
 
   std::shared_ptr<const hyper_error_t> error_;
 
   mutable std::string stringRepresentation_;
 
   friend const char* internal::getSqlState(const hyperapi::HyperException&);
   friend const char* internal::getDetail(const hyperapi::HyperException&);
   friend int internal::getErrorCode(const hyperapi::HyperException&);
   friend int internal::getErrorCategory(const hyperapi::HyperException&);
   friend hyper_error_source_t internal::getErrorSource(const hyperapi::HyperException&);
   friend int internal::getErrorGrpcStatusCode(const hyperapi::HyperException&);
   friend HyperException internal::makeHyperException(const std::string&, const std::string&, ContextId);
   friend HyperException internal::makeHyperException(hyper_error_t*);
   friend class HyperExceptionTest;
};
}
 
#include <hyperapi/impl/HyperException.impl.hpp>
 
#endif