swatdb_exceptions.h

Go to the documentation of this file.

/*
 * SwatDB
 *
 * @authors: See Contributors.doc for code contributors
 *
 * Copyright (c) 2020 Swarthmore College Computer Science Department
 * Swarthmore PA, Professors Tia Newhall, Ameet Soni
 */
 
#ifndef  _SWATDB_SWATDBEXCEOTIONS_H_
#define  _SWATDB_SWATDBEXCEOTIONS_H_
 
 
#include <string>
#include <exception>
 
#include <swatdb_types.h>
 
class SwatDBException : virtual public std::exception {
 
  public:
 
    explicit SwatDBException(const std::string& msg): message(msg){ }
 
    virtual ~SwatDBException() throw() {}
 
    virtual const char* what() const throw() {
      return message.c_str();
    }
 
  protected:
 
    std::string message;
};
 
 
class InvalidFileIdDiskMgr : public SwatDBException {
 
  public:
 
    explicit InvalidFileIdDiskMgr(FileId file_id);
 
    ~InvalidFileIdDiskMgr() throw() {}
 
    FileId getFileId() const throw();
 
  private:
 
    FileId file_id;
};
 
class InvalidPageNumDiskMgr : public SwatDBException {
 
  public:
 
    explicit InvalidPageNumDiskMgr(PageNum page_num);
 
    ~InvalidPageNumDiskMgr() throw() {}
 
    PageNum getPageNum() const throw();
 
  private:
 
    PageNum page_num;
 
};
 
class InsufficientSpaceDiskMgr : public SwatDBException {
 
 public:
 
   explicit InsufficientSpaceDiskMgr(FileId file_id);
 
   ~InsufficientSpaceDiskMgr() throw() {}
 
   FileId getFileId() const throw();
 
 private:
 
   FileId file_id;
};
 
 
class FileAlreadyExistDiskMgr : public SwatDBException {
 
 public:
 
   explicit FileAlreadyExistDiskMgr(const std::string& file);
 
   ~FileAlreadyExistDiskMgr() throw() {}
 
   std::string getFileName() const throw();
 
 private:
 
   std::string file_name;
};
 
class FileIdAlreadyExistDiskMgr : public SwatDBException {
 
 public:
 
   explicit FileIdAlreadyExistDiskMgr(FileId file_id);
 
   ~FileIdAlreadyExistDiskMgr() throw() {}
 
   FileId getFileId() const throw();
 
 private:
 
   FileId file_id;
};
 
 
class DiskErrorDiskMgr : public SwatDBException {
 
 public:
 
   explicit DiskErrorDiskMgr();
 
   ~DiskErrorDiskMgr() throw() {}
 
};
 
 
class InvalidPageIdBufMgr : public SwatDBException {
 
  public:
 
    explicit InvalidPageIdBufMgr(PageId page_id);
 
    ~InvalidPageIdBufMgr() throw() {}
 
    PageId getPageId() const throw();
 
  private:
 
    PageId page_id;
};
 
class PageNotFoundBufMgr : public SwatDBException {
 
  public:
 
    explicit PageNotFoundBufMgr(PageId page_id);
 
    ~PageNotFoundBufMgr() throw() {}
 
    PageId getPageId() const throw();
 
  private:
 
    PageId page_id;
 
};
 
class PageAlreadyLoadedBufMgr : public SwatDBException {
 
  public:
 
    explicit PageAlreadyLoadedBufMgr(PageId page_id);
 
    ~PageAlreadyLoadedBufMgr() throw() {}
 
    PageId getPageId() const throw();
 
  private:
 
    PageId page_id;
 
};
 
class PageNotPinnedBufMgr : public SwatDBException {
 
  public:
 
    explicit PageNotPinnedBufMgr(PageId page_id);
 
    ~PageNotPinnedBufMgr() throw() {}
 
    PageId getPageId() const throw();
 
  private:
 
    PageId page_id;
 
};
 
class PagePinnedBufMgr : public SwatDBException {
 
  public:
 
    explicit PagePinnedBufMgr(PageId page_id);
 
    ~PagePinnedBufMgr() throw() {}
 
    PageId getPageId() const throw();
 
  private:
 
    PageId page_id;
 
};
 
 
class InsufficientSpaceBufMgr : public SwatDBException {
 
 public:
 
   explicit InsufficientSpaceBufMgr();
 
   ~InsufficientSpaceBufMgr() throw() {}
 
};
 
 
class InvalidPolicyBufMgr : public SwatDBException {
 
 public:
 
   explicit InvalidPolicyBufMgr();
 
   ~InvalidPolicyBufMgr() throw() {}
 
};
 
class InvalidFileTypeFileMgr : public SwatDBException {
 
  public:
 
    explicit InvalidFileTypeFileMgr(CatType file_type);
 
    ~InvalidFileTypeFileMgr() throw() {}
 
    CatType getFileType() const throw();
 
  private:
 
    CatType type;
 
};
 
class FileNotFoundFileMgr : public SwatDBException {
 
 public:
 
   explicit FileNotFoundFileMgr();
 
   ~FileNotFoundFileMgr() throw() {}
 
};
 
class MismatchingFieldsRelOpsManager: public SwatDBException {
  public:
    explicit MismatchingFieldsRelOpsManager(); 
 
    ~MismatchingFieldsRelOpsManager() throw() {}
 
};
 
 
class InvalidFileIdRelOpsManager: public SwatDBException {
  public:
    explicit InvalidFileIdRelOpsManager(); 
 
    ~InvalidFileIdRelOpsManager() throw() {}
 
};
 
 
class FileAlreadyExistCat: public SwatDBException {
 
  public:
 
    explicit FileAlreadyExistCat(const std::string& filename);
 
    ~FileAlreadyExistCat() throw() {}
 
    std::string getFileName() const throw();
 
  private:
 
    std::string file_name;
};
 
 
class NameAlreadyExistCat: public SwatDBException {
 
  public:
 
    explicit NameAlreadyExistCat(const std::string& relname);
 
    ~NameAlreadyExistCat() throw() {}
 
    std::string getName() const throw();
 
  private:
 
    std::string name;
};
 
 
 
class InvalidFileIdCat : public SwatDBException {
 
  public:
 
    explicit InvalidFileIdCat(FileId file_id);
 
    ~InvalidFileIdCat() throw() {}
 
    FileId getFileId() const throw();
 
  private:
 
    FileId file_id;
};
 
class InvalidNameCat : public SwatDBException {
 
 public:
 
   explicit InvalidNameCat(const std::string& name);
 
   ~InvalidNameCat() throw() {}
 
   std::string getName() const throw();
 
 private:
 
   std::string name;
};
 
class InvalidSlotIdHeapPage : public SwatDBException {
 
  public:
 
    explicit InvalidSlotIdHeapPage(SlotId slot_id);
 
    ~InvalidSlotIdHeapPage() throw() {}
 
    SlotId getSlotId() const throw();
 
  private:
 
    SlotId slot_id;
 
};
 
class InsufficientSpaceHeapPage : public SwatDBException {
 
  public:
 
    explicit InsufficientSpaceHeapPage();
 
    ~InsufficientSpaceHeapPage() throw() {}
 
};
 
 
class CorruptedDataHeapPage : public SwatDBException {
 
  public:
 
    explicit CorruptedDataHeapPage();
 
    ~CorruptedDataHeapPage() throw() {}
 
};
 
 class EmptyDataHeapPage : public SwatDBException {
 
   public:
 
    explicit EmptyDataHeapPage();
 
    ~EmptyDataHeapPage() throw() {}
 };
 
class InvalidFileIdHeapFile : public SwatDBException {
 
  public:
 
    explicit InvalidFileIdHeapFile(FileId file_id);
 
    ~InvalidFileIdHeapFile() throw() {}
 
    FileId getFileId() const throw();
 
  private:
 
    FileId file_id;
 
};
 
 
class InvalidSchemaHeapFile : public SwatDBException {
 
  public:
 
    explicit InvalidSchemaHeapFile();
 
    ~InvalidSchemaHeapFile() throw() {}
 
};
 
class InsufficientSpaceHeapFile : public SwatDBException {
 
  public:
 
    explicit InsufficientSpaceHeapFile();
 
    ~InsufficientSpaceHeapFile() throw() {}
 
};
 
class InvalidSizeData : public SwatDBException {
 
 public:
 
   explicit InvalidSizeData();
 
   ~InvalidSizeData() throw() {}
 
};
 
class InvalidFieldNameSchema : public SwatDBException {
 
  public:
 
    explicit InvalidFieldNameSchema();
 
    ~InvalidFieldNameSchema() throw() {}
 
};
 
/************* Key class execeptions ********************/
 
class InvalidFormatKey : public SwatDBException {
 
 public:
 
   explicit InvalidFormatKey();
 
   ~InvalidFormatKey() throw() {}
 
};
 
class InvalidSchemaKey: public SwatDBException {
 
 public:
 
   explicit InvalidSchemaKey();
 
   ~InvalidSchemaKey() throw() {}
 
};
 
 
class InsufficentCapacityKey: public SwatDBException {
 
 public:
 
   explicit InsufficentCapacityKey();
 
   ~InsufficentCapacityKey() throw() {}
 
};
 
 
 
class InvalidKeyFormatRecord : public SwatDBException {
 
 public:
 
   explicit InvalidKeyFormatRecord();
 
   ~InvalidKeyFormatRecord() throw() {}
 
};
 
class InsufficientSpaceHashBucketPage : public SwatDBException {
 
  public:
 
    explicit InsufficientSpaceHashBucketPage();
 
    ~InsufficientSpaceHashBucketPage() throw() {}
 
};
 
class CorruptedDataHashBucketPage : public SwatDBException {
 
  public:
 
    explicit CorruptedDataHashBucketPage();
 
    ~CorruptedDataHashBucketPage() throw() {}
 
};
 
class InvalidSlotIdHashBucketPage : public SwatDBException {
 
  public:
 
    explicit InvalidSlotIdHashBucketPage(SlotId slot_id);
 
    ~InvalidSlotIdHashBucketPage() throw() {}
 
    SlotId getSlotId() const throw();
 
  private:
 
    SlotId slot_id;
 
};
 
 class EmptyDataHashBucketPage : public SwatDBException {
 
   public:
 
    explicit EmptyDataHashBucketPage();
 
    ~EmptyDataHashBucketPage() throw() {}
 };
 
 
class InvalidSlotHashDirPage : public SwatDBException {
 
  public:
 
    explicit InvalidSlotHashDirPage(SlotId slot_id);
 
    ~InvalidSlotHashDirPage() throw() {}
 
    SlotId getSlotId() const throw();
 
  private:
 
    SlotId slot_id;
 
};
 
 
 class InsufficientSpaceHashBucket : public SwatDBException {
 
   public:
 
    explicit InsufficientSpaceHashBucket();
 
    ~InsufficientSpaceHashBucket() throw() {}
 };
 
 class InvalidKeyFormatHashIndex : public SwatDBException {
 
   public:
 
    explicit InvalidKeyFormatHashIndex();
 
    ~InvalidKeyFormatHashIndex() throw() {}
 };
 
 class InsufficientSpaceHashIndex : public SwatDBException {
 
   public:
 
    explicit InsufficientSpaceHashIndex();
 
    ~InsufficientSpaceHashIndex() throw() {}
 };
 
 
 class InvalidEntryHashIndex : public SwatDBException {
 
   public:
 
    explicit InvalidEntryHashIndex();
 
    ~InvalidEntryHashIndex() throw() {}
 };
 
 
#endif