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
 */

#pragma once

#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 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 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() {}

};