Database.h

Go to the documentation of this file.

/*
 * Database.h
 *
 * 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
 *
 */

#ifndef DATABASE_H_
#define DATABASE_H_


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>

#include "FlyLegacy.h"


//
// Common class definitions
//
// These classes are used commonly across several database modules.
//
// These classes are implemented in DBUtilities.cpp
//
class CDatabaseField {
public:
  // Constructor/Destructor
  CDatabaseField (void);

  // Public methods
  char            GetType (void);       
  unsigned long   GetLength (void);     
  void            GetString (char *s);  
  double          GetDouble (void);     
  long            GetInt (void);        
  void            Format (char *s);     

public:
  char           type;
  unsigned long  length;
  union {
    char    charData[256];
    double  doubleData;
    long    intData;
  } data;
};


//
// Template related class definitions
//
// Each database has a template (.DBT) file that defines the physical structure
//   of the database records.  This is a data-driven approach that allows new
//   databases to be integrated into the application with minimal effort.
//
// These classes are implemented in DBTemplate.cpp
//
class CDatabaseTemplateItem {
public:
  // Constructor/Destructor
  CDatabaseTemplateItem (void);

  // Public methods

public:
  Tag            id;
  unsigned long  start;
  unsigned long  length;
  char           type;
  char           name[256];
};

class CDatabaseTemplate {
public:
  // Constructor/Destructor
  ~CDatabaseTemplate (void);

  // Public methods
  void                   Load (const char* fileName);
  int                    GetNumItems (void);
  CDatabaseTemplateItem* GetItem (int i);
  void                   Dump (FILE *f);

protected:
  // Protected methods
  void                   Load (PODFILE *f);

protected:
  std::vector<CDatabaseTemplateItem*>    item;  
};


//
// Index related class definitions
//
// Each database can have an arbitrary number of indices assigned to it.  Each index
//   is stored in an associated .DBI file.  The index header specifies the type of
//   key that the index is based on; key types do not necessarily map directly to
//   a field in the database; applications that use the database must know how to
//   construct key values in order to effectively use them.
//
// These classes are implemented in DBIndex.cpp
//

typedef std::multimap<std::string, unsigned long>   StringIndex;
typedef std::multimap<double, unsigned long>        DoubleIndex;
typedef std::multimap<long, unsigned long>          IntIndex;

class CDatabaseIndex {
public:
  // Constructor/destructor
  CDatabaseIndex (const char* dbiFilename);
  ~CDatabaseIndex (void);

  // Public functions
  int           GetNumItems (void);
  Tag           GetKeyId (void);
  char          GetKeyType (void);
  unsigned long GetKeyLength (void);
  unsigned long Search (const char* key);
  unsigned long Search (double key);
  unsigned long Search (long key);
  unsigned long SearchNext (void);
  void          Dump (FILE *f);

protected:
  void          Load (PODFILE *f);
  void          Load (const char *dbiFilename);

protected:
  Tag           keyId;
  unsigned char keyType;
  unsigned long keyLength;

  std::multimap<std::string, unsigned long> *stringIndex;
  std::multimap<double, unsigned long> *doubleIndex;
  std::multimap<long, unsigned long>   *intIndex;

  std::pair<StringIndex::iterator,StringIndex::iterator>  stringRange;
  std::pair<DoubleIndex::iterator,DoubleIndex::iterator>  doubleRange;
  std::pair<IntIndex::iterator,IntIndex::iterator>        intRange;

  StringIndex::iterator   stringIter;
  DoubleIndex::iterator   doubleIter;
  IntIndex::iterator      intIter;
};


//
// Database related class definitions
//
// These classes are implemented in DBDatabase.cpp
//
class CDatabaseRecord {
public:
  // Constructor/Destructor
  CDatabaseRecord (void);

  // Public methods
  void            SetSequence (unsigned long sequence);
  void            AddField (CDatabaseField f);
  int             GetNumFields (void);
  CDatabaseField* GetField (unsigned int i);

protected:
  unsigned long                sequence;  
  std::vector<CDatabaseField>  field;     
};

typedef enum {
  DB_UNMOUNTED,
  DB_MOUNTED
} EDatabaseState;

class CDatabase {
public:
  // Constructors
  CDatabase (const char* dbtFilename);
  ~CDatabase (void);
    
  // Template related methods
  CDatabaseTemplate* GetTemplate (void);

  // Index related methods
  void            AddIndex (const char *dbiFilename);
  unsigned int    GetNumIndexes (void);
  CDatabaseIndex* GetIndex (Tag tag);

  // Data import/export
  void      Mount (PODFILE *f);
  void      Mount (const char *dbdFilename);
  void      Unmount (void);
//  void      Load (PODFILE *f);
//  void      Load (const char *dataFilename);
//  void      Save (FILE *f);
//  void      Save (const char *dataFilename);
  void      Dump (FILE *f);

  // Data access members
  unsigned long    GetRawRecordLength (void);
  unsigned long    GetNumRecords (void);
  unsigned long    GetNumFields (void);
  CDatabaseRecord* GetRecordByOffset (unsigned long offset);
  unsigned long    RecordOffset (unsigned long index);
  CDatabaseRecord* GetRecordByIndex (unsigned long index);
  unsigned long    Search (Tag index, const char* key);
  unsigned long    Search (Tag index, double key);
  unsigned long    Search (Tag index, long key);
  unsigned long    SearchNext (void);
  void             GetRawRecord (unsigned long offset, char* buffer);

protected:
  void            LoadTemplate (const char* dbtFilename);

private:
  // Database state
  EDatabaseState  state;
  PODFILE*        podfile;
  unsigned long   signature;
  unsigned long   nRecords;   
  unsigned long   recLength;

  CDatabaseTemplate               dbt;    
  std::vector<CDatabaseIndex*>    dbi;    

  char*               recordBuffer;       

  unsigned long       cacheOffset;       
  CDatabaseRecord*    cacheRecord;        
  
  CDatabaseIndex*     search_index;       
};

//
// DBUtilities.cpp
//
//void CorrectEndian (void *pData, int nBytes);
void ReadLong (PODFILE *f, long *i);
void ReadULong (PODFILE *f, unsigned long *i);
void ReadUShort (PODFILE *f, unsigned short *i);
void ReadUChar (PODFILE *f, unsigned char *i);
void ReadDouble (PODFILE *f, double *i);
void ReadFloat (PODFILE *f, double *i);

char * TabNextField (char *s, char *szField);
char * TabSkipFields (char *s, int nFields);


//
// Extern definitions for instantiated databases in Main.cpp
//
extern CDatabase* dbAirport;
extern CDatabase* dbAtsRoute;
extern CDatabase* dbComm;
extern CDatabase* dbCountry;
extern CDatabase* dbState;
extern CDatabase* dbIls;
extern CDatabase* dbNavaid;
extern CDatabase* dbObstruct;
extern CDatabase* dbRunway;
extern CDatabase* dbWaypoint;

#endif // DATABASE_H_

Documentation generated by