reference/cxx/HyperException_8hpp_source.html

#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> m_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