DBDatabase.cpp

Go to the documentation of this file.

/*
 * DBDatabase.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "../Include/Globals.h"
#include "../Include/Database.h"
#include "../Include/Pod.h"

using namespace std;


CDatabaseRecord::CDatabaseRecord (void)
{
  sequence = 0;
}

void CDatabaseRecord::SetSequence (unsigned long sequence)
{
  this->sequence = sequence;
}

void CDatabaseRecord::AddField (CDatabaseField f)
{
  field.push_back (f);
}

int CDatabaseRecord::GetNumFields (void)
{
  return field.size();
}

CDatabaseField *CDatabaseRecord::GetField (unsigned int i)
{
  CDatabaseField *rc = NULL;

  if (i < field.size()) {
    rc = &(field[i]);
  }

  return rc;
}


CDatabase::CDatabase (const char* dbtFilename)
{
  // Load the database template
  LoadTemplate (dbtFilename);

  // Allocate a data record used to cache the last-read record
  cacheRecord = NULL;
/*
  int nFields = dbt.GetNumItems ();
  cacheOffset = 0;
  cacheRecord = new CDatabaseRecord;
  // \todo Add fields to cache record
*/

  // Initialize state to UNMOUNTED until Mount() is called
  state = DB_UNMOUNTED;
  podfile = NULL;
  recordBuffer = NULL;
}

CDatabase::~CDatabase (void)
{
  // Delete buffer for current record
  if (recordBuffer != NULL) delete[] recordBuffer;

  // Delete data record cache
  if (cacheRecord != NULL) {
    delete cacheRecord;
  }

  // Delete indices
  vector<CDatabaseIndex*>::iterator i;
  for (i=dbi.begin(); i!=dbi.end(); i++) delete *i;

  Unmount ();
}

//
// Template related methods
//

void CDatabase::LoadTemplate (const char* dbtFilename)
{
  dbt.Load (dbtFilename);
}

CDatabaseTemplate* CDatabase::GetTemplate (void)
{
  return &dbt;
}

//
// Index related methods
//

void CDatabase::AddIndex (const char *dbiFilename)
{
  dbi.push_back (new CDatabaseIndex (dbiFilename));
}

unsigned int CDatabase::GetNumIndexes (void)
{
  return dbi.size();
}

CDatabaseIndex* CDatabase::GetIndex (Tag tag)
{
  CDatabaseIndex *rc = NULL;

  vector<CDatabaseIndex*>::iterator i;
  for (i=dbi.begin(); i!=dbi.end(); i++) {
    Tag iKey = (*i)->GetKeyId();
    if (iKey == tag) {
      rc = *i;
    }
  }

  return rc;
}


//
// Data (DBD) related methods
//

typedef struct {
  unsigned long  signature;
  unsigned long  unknown0;
  unsigned long  unknown1;
  unsigned long  checksum;
  unsigned long  nRecords;
  unsigned long  recLength;
  unsigned long  dummy[8];
} DBDHeader;


//
// Mount the database but do not load any of the records into memory
//
void CDatabase::Mount (PODFILE *f)
{
  // Confirm that valid template exists
  int nFields = dbt.GetNumItems();
  if (nFields > 0) {
    // Read header
    DBDHeader h;
    ReadULong (f, &h.signature);
    ReadULong (f, &h.unknown0);
    ReadULong (f, &h.unknown1);
    ReadULong (f, &h.checksum);
    ReadULong (f, &h.nRecords);
    ReadULong (f, &h.recLength);
    for (unsigned int i=0; i<8; i++) ReadULong (f, &h.dummy[i]);

    nRecords = h.nRecords;
    recLength = h.recLength;
  }

  // Update database state
  state = DB_MOUNTED;
  podfile = f;
  recordBuffer = new char[recLength];
}

void CDatabase::Mount (const char* dbdFilename)
{
  char fullFilename[64];
  strcpy (fullFilename, "Database\\");
  strcat (fullFilename, dbdFilename);
  PODFILE *p = popen (&globals->pfs, fullFilename);
  if (p) {
    // Mount the database, PODFILE must be left open
    Mount (p);
  }
}

void CDatabase::Unmount (void)
{
  if (podfile != NULL) {
    pclose (podfile);
  }
}
/*
void CDatabase::Load (PODFILE *f)
{
  unsigned int i, j;

  // Confirm that valid template exists
  unsigned int nFields = dbt.GetNumItems();
  if (nFields > 0) {
    // Read header
    DBDHeader h;
    ReadULong (f, &h.signature);
    ReadULong (f, &h.unknown0);
    ReadULong (f, &h.unknown1);
    ReadULong (f, &h.checksum);
    ReadULong (f, &h.nRecords);
    ReadULong (f, &h.recLength);
    for (i=0; i<8; i++) ReadULong (f, &h.dummy[i]);

    // Allocate buffer for raw data record storage
    char *buffer = new char[h.recLength];

    // Allocate storage for data records
    nRecords = h.nRecords;
    recLength = h.recLength;
    record = new DataRecord[nRecords];

    // Read data records
    for (i=0; i<nRecords; i++) {
      // Read raw data record into buffer
      pread (buffer, h.recLength, 1, f);

      // Read record sequence number
      unsigned long tempLong;
      memcpy (&tempLong, buffer, sizeof(unsigned long));
      CorrectEndian (&tempLong, sizeof(unsigned long));
      record[i].sequence = tempLong;

      // Allocate storage within record for fields
      record[i].field = new DataItem[nFields];

      for (j=0; j<nFields; j++) {

        // Initialize locals from database template field
        unsigned long dataStart = dbt.item[j].start;
        unsigned char dataType = dbt.item[j].type;
        int dataLength = dbt.item[j].length;

        // Initialize pointer to field data in raw buffer
        char *p = buffer + dataStart;

        record[i].field[j].type = dataType;
        record[i].field[j].length = dataLength;
        switch (dataType) {
          case 'C':
            {
              // Char string data
              char *s = new char[dataLength+1];
              memcpy (s, p, dataLength);
              s[dataLength] = '\0';
              record[i].field[j].pData = s;
            }
            break;

          case 'D':
            // Double-precision float data
            record[i].field[j].pData = new double;
            memcpy (record[i].field[j].pData, p, dataLength);
            CorrectEndian (record[i].field[j].pData, dataLength);
            break;

          case 'I':
            // Integer (unsigned long) data
            record[i].field[j].pData = new unsigned long;
            memcpy (record[i].field[j].pData, p, dataLength);
            CorrectEndian (record[i].field[j].pData, dataLength);
            break;
        }
      }
    }

    delete[] buffer;
  }

  // Update database state
  state = DB_LOADED;
}

void CDatabase::Load (const char *dbdFilename)
{
  char fullFilename[64];
  strcpy (fullFilename, "Database\\");
  strcat (fullFilename, dbdFilename);
  PODFILE *p = popen (&globals->pfs, fullFilename);
  if (p) {
    Load (p);
    pclose (p);
  }
}

void CDatabase::Save (FILE *f)
{
  int i, j;

  // Confirm that valid template exists
  int nFields = dbt.GetNumItems();
  if (nFields > 0) {
    // Initialize header
    DBDHeader h;
    h.signature = signature;
    h.unknown0 = 0;
    h.unknown1 = 1;
    h.checksum = 0;
    h.nRecords = GetNumDataRecords();

    // Calculate raw record length
    int nFields = dbt.GetNumItems();
    int recLength = 4;
    for (i=0; i<nFields; i++) {
      TemplateItem ti = dbt.GetItem (i);
      recLength += ti.length;
    }
    h.recLength = recLength;
    for (i=0; i<8; i++) {
      h.dummy[i] = 0;
    }

    // Write header
    fwrite (&h, sizeof(DBDHeader), 1, f);

    // Write data records
    for (i=0; i<(int)nRecords; i++) {
      // Write record sequence number
      fwrite (&record[i].sequence, sizeof(unsigned long), 1, f);

      // Write field data
      for (j=0; j<nFields; j++) {
        DataItem &item = record[i].field[j];
        fwrite (item.pData, item.length, 1, f);
      }
    }
  }
}

void CDatabase::Save (const char *dataFilename)
{
  FILE *f;
  f = fopen (dataFilename, "wb");
  if (f) {
    Save (f);
    fclose (f);
  }
}
*/


//
// Data access methods
//

unsigned long CDatabase::GetRawRecordLength (void)
{
  return recLength;
}

unsigned long CDatabase::GetNumRecords (void)
{
  return nRecords;
}

unsigned long CDatabase::GetNumFields (void)
{
  return dbt.GetNumItems();
}


//
// Start a new search of the database.  The index and search key are saved 
//   such that subsequent matching records can be retrieved using the SearchNext
//   method
//
//  @param tag       Unique identifier of index to search on
//  @param key       String value to search for
//
//  @return Pointer to first database record matching key, or NULL if none found
//
unsigned long CDatabase::Search (Tag tag, const char* key)
{
  unsigned long rc = 0;

  // Verify that database is mounted
  if (state == DB_MOUNTED) {
    search_index = GetIndex (tag);
    if (search_index != NULL) {
      rc = search_index->Search (key);
    }
  }

  return rc;
}

unsigned long CDatabase::Search (Tag tag, double key)
{
  unsigned long rc = 0;

  // Verify that database is mounted
  if (state == DB_MOUNTED) {
    search_index = GetIndex (tag);
    if (search_index != NULL) {
      rc = search_index->Search (key);
    }
  }

  return rc;
}

unsigned long CDatabase::Search (Tag tag, long key)
{
  unsigned long rc = 0;

  // Verify that database is mounted
  if (state == DB_MOUNTED) {
    search_index = GetIndex (tag);
    if (search_index != NULL) {
      rc = search_index->Search (key);
    }
  }

  return rc;
}

//
// Continue searching using the same key values from the last call to Search()
//
// Return code:
//  unsigned long Record pointer of next match
//
unsigned long CDatabase::SearchNext (void)
{
  unsigned long rc = 0;

  // Verify that database is mounted or loaded
  if ((state == DB_MOUNTED) && (search_index != NULL)) {
    rc = search_index->SearchNext ();
  }

  return rc;
}

/*
CDatabaseRecord* CDatabase::Search (Tag tag, const char* key)
{
  CDatabaseRecord *rc = NULL;

  // Verify that database is mounted
  if (state == DB_MOUNTED) {
    search_index = GetIndex (tag);
    if (search_index != NULL) {
      unsigned long offset = search_index->Search (key);
      if (offset != 0) {
        rc = GetRecordByOffset (offset);
      }
    }
  }

  return rc;
}

CDatabaseRecord* CDatabase::Search (Tag tag, double key)
{
  CDatabaseRecord *rc = NULL;

  // Verify that database is mounted
  if (state == DB_MOUNTED) {
    search_index = GetIndex (tag);
    if (search_index != NULL) {
      unsigned long offset = search_index->Search (key);
      if (offset != 0) {
        rc = GetRecordByOffset (offset);
      }
    }
  }

  return rc;
}

CDatabaseRecord* CDatabase::Search (Tag tag, long key)
{
  CDatabaseRecord *rc = NULL;

  // Verify that database is mounted
  if (state == DB_MOUNTED) {
    search_index = GetIndex (tag);
    if (search_index != NULL) {
      unsigned long offset = search_index->Search (key);
      if (offset != 0) {
        rc = GetRecordByOffset (offset);
      }
    }
  }

  return rc;
}

//
// Continue searching using the same key values from the last call to Search()
//
// Return code:
//  unsigned long Record pointer of next match
//
CDatabaseRecord* CDatabase::SearchNext (void)
{
  CDatabaseRecord *rc = NULL;

  // Verify that database is mounted or loaded
  if ((state == DB_MOUNTED) && (search_index != NULL)) {
      unsigned long offset = search_index->SearchNext ();
      if (offset != 0) {
        rc = GetRecordByOffset (offset);
      }
  }

  return rc;
}
*/

//
// Retrieve a raw data record from the database.  The application is responsible
//   for decoding and formatting the fields
//
void CDatabase::GetRawRecord (unsigned long offset, char* buffer)
{
  // Verify that database is mounted
  if (state == DB_MOUNTED) {
    pseek (podfile, offset, SEEK_SET);
    pread (buffer, recLength, 1, podfile);
  }
}

CDatabaseRecord* CDatabase::GetRecordByOffset (unsigned long offset)
{
  CDatabaseRecord* rc = new CDatabaseRecord;

  GetRawRecord (offset, recordBuffer);
  for (unsigned long i=0; i<GetNumFields(); i++) {
    CDatabaseField f;
    CDatabaseTemplateItem *t = dbt.GetItem (i);
    f.type = t->type;
    f.length = t->length;
    void *pData = recordBuffer + t->start;
    switch (t->type) {
    case 'C':
      if (t->length < 256) {
        strncpy (f.data.charData, (char*)pData, t->length);
      } else {
        gtfo ("CDatabase::GetRecord : Char field length > 255 chars");
      }
      break;

    case 'D':
      f.data.doubleData = *((double*)pData);
      break;

    case 'I':
      f.data.intData = *((long*)pData);
      break;
    }
    rc->AddField (f);
  }

  return rc;
}

unsigned long CDatabase::RecordOffset (unsigned long index)
{
  return sizeof(DBDHeader) + (index * recLength);
}

CDatabaseRecord* CDatabase::GetRecordByIndex (unsigned long index)
{
  return GetRecordByOffset (RecordOffset (index));
}


//
// Dump the database contents to a file for debugging
//
void CDatabase::Dump (FILE *f)
{
  // Dump template
  dbt.Dump (f);
  fprintf (f, "\n");

  // Dump indices
  vector<CDatabaseIndex*>::iterator i;
  for (i=dbi.begin(); i!=dbi.end(); i++) {
    (*i)->Dump (f);
  }
  fprintf (f, "\n");

  // Dump database state
  fprintf (f, "State : ");
  switch (state) {
  case DB_UNMOUNTED:
    fprintf (f, "UNMOUNTED\n");
    break;

  case DB_MOUNTED:
    fprintf (f, "MOUNTED\n");
    break;
  }

  // Dump all data records
  if (state == DB_MOUNTED) {
    int nRecords = GetNumRecords ();
    fprintf (f, "  nRecords = %d\n", nRecords);
    int nFields = GetNumFields ();
    fprintf (f, "  nFields  = %d\n", nFields);

    int i, j;
    for (i=0; i < nRecords; i++) {
      CDatabaseRecord *record = GetRecordByIndex (i);

      for (j=0; j < nFields; j++) {
        CDatabaseField *field =  record->GetField (j);
        char s[256];
        field->Format (s);
        if (j != 0) fprintf (f, ", ");
        fprintf (f, "%s", s);
      }
      fprintf (f, "\n");
    }
  }
}

Documentation generated by