Errors.hpp

#ifndef _DITTO_ERRORS_
#define _DITTO_ERRORS_
 
#include <exception>
#include <string>
 
struct dittoffi_error;
typedef dittoffi_error dittoffi_error_t;
 
#define DEFINE_EXCEPTION_CLASS_WITH_DOCS(EXCEPTION_NAME, DOCSTRING, ...)       \
                                                                          \
  class EXCEPTION_NAME : public std::exception {                               \
    __VA_ARGS__                                                                \
    std::string message;                                                       \
    EXCEPTION_NAME();                                                          \
                                                                               \
  public:                                                                      \
    const char *what() const noexcept override { return message.c_str(); }     \
  };
 
// TODO(Ham): Remove this in favour of the one above, but only when all errors
// have been documented and we've figured out how Doxygen can pick them up to
// document them
#define DEFINE_EXCEPTION_CLASS(EXCEPTION_NAME, ...)                            \
  class EXCEPTION_NAME : public std::exception {                               \
    __VA_ARGS__                                                                \
    std::string message;                                                       \
    EXCEPTION_NAME();                                                          \
                                                                               \
  public:                                                                      \
    const char *what() const noexcept override { return message.c_str(); }     \
  };
 
namespace ditto {

 * You can see more information about an error by calling @ref what().
 */
class DittoError : public std::exception {
  std::string message;
 
public:
  DittoError();
  explicit DittoError(dittoffi_error_t *ffi_error);
  explicit DittoError(std::string msg);

  char const *what() const noexcept override;
};
 
// MARK: - More specific errors
 
// MARK: - Attachment fetch errors
 
DEFINE_EXCEPTION_CLASS(AttachmentNotFoundError,
                       friend class AttachmentFetcherCtx;)
DEFINE_EXCEPTION_CLASS(AttachmentTokenInvalidError,
                       friend class AttachmentFetcherCtx;)
DEFINE_EXCEPTION_CLASS(FailedToFetchAttachmentError,
                       friend class AttachmentFetcherCtx;)
 
// MARK: - Attachment creation errors
 
DEFINE_EXCEPTION_CLASS(AttachmentFilePermissionDeniedError, friend class Store;)
DEFINE_EXCEPTION_CLASS(AttachmentFileNotFoundError, friend class Store;)
DEFINE_EXCEPTION_CLASS(FailedToCreateAttachmentError, friend class Store;)
 
// MARK: - Validation errors
 
// TODO(Ham): Make it so that these classes get documented by Doxygen. They
// aren't getting picked up currently
DEFINE_EXCEPTION_CLASS_WITH_DOCS(
    ValidationNotAMapError,
    R"(The object is not a map where a map is expected.)",
    friend class Presence;)
DEFINE_EXCEPTION_CLASS_WITH_DOCS(
    ValidationSizeLimitExceededError,
    R"(The size limit for some piece of data has been exceeded.)",
    friend class Presence;)
DEFINE_EXCEPTION_CLASS_WITH_DOCS(
    ValidationNotJSONCompatibleError,
    R"(The object is or contain(s) types that aren't JSON compatible.)",
    friend class Presence;)
 
// MARK: - Transaction errors
 
DEFINE_EXCEPTION_CLASS_WITH_DOCS(
    TransactionReadOnlyError,
    R"(A mutating DQL query was executed in a read-only transaction.)",
    friend class Transaction;)
 
// MARK: - @ref Log.export_to_file errors

class IOAlreadyExistsError : public DittoError {
  friend class Log;
 
public:
  using DittoError::DittoError;
};

 * A file or directory could not be found.
 */
class IONotFoundError : public DittoError {
  friend class Log;
 
public:
  using DittoError::DittoError;
};

 * The operation failed due to insufficient permissions.
 */
class IOPermissionDeniedError : public DittoError {
  friend class Log;
 
public:
  using DittoError::DittoError;
};

 * details.
 */
class IOOperationFailedError : public DittoError {
  friend class Log;
 
public:
  using DittoError::DittoError;
};
 
} // namespace ditto
 
#endif