/afs/cs.wisc.edu/u/n/w/nwilliam/private/workspace/Quut/src/sort.h

#pragma once

#include <vector>
#include "filescan.h"

namespace badgerdb
{

typedef struct
{
  RecordId rid;       // record id of current record
  char* field;        // pointer to field
  int length;         // length of field
} SORTREC;


class SortedFile {
 public:
  /*
   * Constructor
   * @param filename  Name of the original file
   * @param offset    Offset of sort key
   * @param length    Length of sort key
   * @param type      Type of sort key
   * @param maxItems  Maximum number of items in every sorted run. 
   */
  SortedFile(const std::string & fileName, int offset, int length, Datatype type, int maxItems);

  /*
   * Fetch next record in sort order.
   * @throws EndOfFileException() when all records are read.
   */
  std::string next();

  /*
   * Record a position in sort sequence.
   */
  void setMark();

  /*
   * Go to last recorded spot.
   */
  void gotoMark();

  /*
   * Destructor
   */
  ~SortedFile();

 private:
  void sortFile();                    // split source file into sub-runs
  void generateRun(int numItems);     // generate one sub-run of file
  void startScans();                  // start a scan on each sorted run

  typedef struct
  {
    std::string name;                 // name of run file
    FileScan* file;                   // ptr to sorted run of file
    int valid;                        // TRUE if recPtr has a record
    std::string rec;
    RecordId rid;                     // RecordId of current record of run
    RecordId mark;                    // last marked spot (RecordId) in file
  } RUN;

  std::vector<RUN> runs;              // holds info about each sub-run

  FileScan* file;                     // source file to sort
  std::string fileName;               // name of source file to sort
  Datatype type;                      // type of sort attribute
  int offset;                         // offset of sort attribute
  int length;                         // length of sort attribute

  SORTREC *buffer;                    // in-memory sort buffer
  int maxItems;                       // max. # of items/tuples in buffer
  int numItems;                       // current # of items in buffer
};

}