file.h

#pragma once

#include <fstream>
#include <string>
#include <map>
#include <memory>

#include "page.h"

namespace badgerdb {

class FileIterator;

struct FileHeader {
  PageId num_pages;

  PageId first_used_page;

  PageId num_free_pages;

  PageId first_free_page;

  bool operator==(const FileHeader& rhs) const {
    return num_pages == rhs.num_pages &&
        num_free_pages == rhs.num_free_pages &&
        first_used_page == rhs.first_used_page &&
        first_free_page == rhs.first_free_page;
  }
};

class File {
 public:

  File(const std::string& name, const bool create_new);

  static void remove(const std::string& filename);

  static bool isOpen(const std::string& filename);


  static bool exists(const std::string& filename);

  virtual ~File();

  virtual Page allocatePage(PageId &new_page_number) = 0;

  virtual Page readPage(const PageId page_number) const = 0;

  virtual void writePage(const PageId page_number, const Page& new_page) = 0;

  virtual void deletePage(const PageId page_number) = 0;

  const std::string& filename() const { return filename_; }

  PageId getFirstPageNo();

 protected:
  static std::streampos pagePosition(const PageId page_number) {
    return sizeof(FileHeader) + ((page_number - 1) * Page::SIZE);
  }

  void openIfNeeded(const bool create_new);

  void close();

  FileHeader readHeader() const;

  void writeHeader(const FileHeader& header);

  typedef std::map<std::string, std::shared_ptr<std::fstream> > StreamMap;
  typedef std::map<std::string, int> CountMap;

  static StreamMap open_streams_;

  static CountMap open_counts_;

  std::string filename_;

  std::shared_ptr<std::fstream> stream_;

  friend class FileIterator;
};

class PageFile : public File {
 public:

  static PageFile create(const std::string& filename);

  static PageFile open(const std::string& filename);

  PageFile(const std::string& name, const bool create_new);

  PageFile(const PageFile& other);

  PageFile& operator=(const PageFile& rhs);

  ~PageFile();

  Page allocatePage(PageId &new_page_number);

  Page readPage(const PageId page_number) const;

  void writePage(const PageId page_number, const Page& new_page);

  void deletePage(const PageId page_number);

  FileIterator begin();

  FileIterator end();

 private:

  Page readPage(const PageId page_number, const bool allow_free) const;

  void writePage(const PageId page_number, const PageHeader& header,
                 const Page& new_page);

  PageHeader readPageHeader(const PageId page_number) const;

  friend class FileIterator;
};

class BlobFile : public File {
 public:

  static BlobFile create(const std::string& filename);

  static BlobFile open(const std::string& filename);

  BlobFile(const std::string& name, const bool create_new);

  BlobFile(const BlobFile& other);

  BlobFile& operator=(const BlobFile& rhs);

  ~BlobFile();

  Page allocatePage(PageId &new_page_number);

  Page readPage(const PageId page_number) const;

  void writePage(const PageId page_number, const Page& new_page);

  void deletePage(const PageId page_number);
};

}