page.h

#pragma once

#include <cstddef>
#include <stdint.h>
#include <memory>
#include <string>
#include <cstring>
#include "include/types.h"

namespace wiscdb {

struct PageHeader {
  std::uint16_t free_space_begin;

  std::uint16_t free_space_end;

  std::uint16_t num_slots;

  std::uint16_t num_free_slots;

  PageId current_page_number;

  PageId next_page_number;

  bool operator==(const PageHeader& rhs) const {
    return num_slots == rhs.num_slots &&
        num_free_slots == rhs.num_free_slots &&
        current_page_number == rhs.current_page_number &&
        next_page_number == rhs.next_page_number;
  }
};

struct PageSlot {
  bool used;

  std::uint16_t slot_offset;

  std::uint16_t slot_length;
};

class PageIterator;

class Page {
 
 //Public data members; This section contains constants that can be 
 //  referenced externally
 public:
  //static const std::size_t SIZE = 8192;
  // SIZE for testing
  static const std::size_t SIZE = 
   sizeof(PageHeader) + 10*sizeof(PageSlot) + 10*strlen("Hello!") + 5;

  static const std::size_t DATA_SIZE = SIZE - sizeof(PageHeader);

  static const PageId INVALID_NUMBER = 0;

  static const SlotId INVALID_SLOT = 0;

 //private data members that define the central structures of a page

  PageHeader header;

 private:

  char data[DATA_SIZE];

 //Public methods that define the Page interface
 public:
  Page();

  RecordId insertRecord(const char* record_data);

  std::string getRecord(const RecordId& record_id) const;

  void updateRecord(const RecordId& record_id, const char* record_data);

  void deleteRecord(const RecordId& record_id);

  bool hasSpaceForRecord(const char* record_data) const;

  std::uint16_t getFreeSpace() const;

  PageId page_number() const;

  PageId next_page_number() const;

  PageIterator begin();

  PageIterator end();

  void print();

 //Private helper methods
 private:
  void reset();

  void setPageNumber(const PageId new_page_number);

  void setNextPageNumber(const PageId new_next_page_number);

  void deleteRecord(const RecordId& record_id,
                    const bool allow_slot_compaction);

  PageSlot* getSlot(const SlotId slot_number);

  const PageSlot& getSlot(const SlotId slot_number) const;

  SlotId getAvailableSlot();

  void insertRecordInSlot(const SlotId slot_number,
                          const char* record_data);
 //private:
  void validateRecordId(const RecordId& record_id) const;

  bool isUsed() const;

  friend class File;
  friend class PageIterator;
  friend class PageTest;
  friend class BufferTest;
};

/*Assumptions built into the DB that need to be verified
 * 1. The header information on each page can't be bigger than the page itself
 * 2. There must be some room for data
 */
static_assert(Page::SIZE > sizeof(PageHeader),
              "Page size must be large enough to hold header and data.");
static_assert(Page::DATA_SIZE > 0,
              "Page must have some space to hold data.");

}