Database.cpp

Go to the documentation of this file.

/*
 * Database.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/FlyLegacy.h"
#include "../Include/Database.h"
#include "../Include/Globals.h"
#include "../Include/Endian.h"


static void DecodeAirportRecord (char* rec, SAirport *airport)
{
  // Temporary variables for reading individual fields
  unsigned long i;
  double d;
  char c;

  strncpy (airport->airportKey, rec+4, 10);
  strncpy (airport->faaID, rec+14, 4);
  strncpy (airport->icaoID, rec+18, 5);

  i = *(unsigned long*)(rec+89);
  i = LittleEndian (i);
  airport->type = i;

  strncpy (airport->name, rec+23, 40);
  strncpy (airport->country, rec+63, 3);
  strncpy (airport->state, rec+66, 3);
  strncpy (airport->county, rec+69, 20);
  strcpy (airport->city, "");

  i = *(unsigned long*)(rec+109);
  i = LittleEndian (i);
  airport->elevation = i;

  i = *(unsigned long*)(rec+113);
  i = LittleEndian (i);
  airport->ownership = i;

  i = *(unsigned long*)(rec+117);
  i = LittleEndian (i);
  airport->usage = i;

  d = *(double*)(rec+166);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  airport->magneticVariation = d;
  
  d = *(double*)(rec+174);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  airport->trafficAltitude = d;
  
  c = *(rec+178);
  airport->fssAvailable = c;
  
  c = *(rec+179);
  airport->notamAvailable = c;
  
  c = *(rec+180);
  airport->atcAvailable = c;
  
  c = *(rec+181);
  airport->segmentedCircle = c;
  
  c = *(rec+182);
  airport->landingFeesCharged = c;
  
  c = *(rec+183);
  airport->jointUseAirport = c;
  
  c = *(rec+184);
  airport->militaryLandingRights = c;
  
  c = *(rec+185);
  airport->customsEntryPoint = c;
  
  i = *(unsigned long*)(rec+186);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->fuelTypes = i;

  i = *(unsigned long*)(rec+190);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->frameService = i;

  i = *(unsigned long*)(rec+194);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->engineService = i;

  i = *(unsigned long*)(rec+198);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->bottledOxygen = i;

  i = *(unsigned long*)(rec+202);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->bulkOxygen = i;

  i = *(unsigned long*)(rec+206);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->beaconLensColor = i;

  i = *(unsigned long*)(rec+210);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->basedAircraft = i;

  i = *(unsigned long*)(rec+214);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->annualCommercialOps = i;

  i = *(unsigned long*)(rec+218);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->annualGeneralAvOps = i;

  i = *(unsigned long*)(rec+222);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->annualMilitaryOps = i;

  i = *(unsigned long*)(rec+226);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->attendanceFlags = i;

  i = *(unsigned long*)(rec+238);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  airport->lightingFlags = i;

  d = *(double*)(rec+93);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  airport->pos.lat = d;
  
  d = *(double*)(rec+101);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  airport->pos.lon = d;

  airport->pos.alt = airport->elevation;

  airport->runways = NULL;
  airport->comms = NULL;

  airport->prev = NULL;
  airport->next = NULL;
}


static void DecodeNavaidRecord (char* rec, SNavaid *navaid)
{
  strncpy (navaid->name, rec+19, 40);
  strncpy (navaid->id, rec+14, 5);

  // Temporary variables for reading individual fields
  unsigned long i;
  double d;

  i = *(unsigned long*)(rec+89);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  navaid->type = i;

  i = *(unsigned long*)(rec+93);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  navaid->classification = i;

  i = *(unsigned long*)(rec+97);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  navaid->usage = i;

  d = *(double*)(rec+101);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  navaid->pos.lat = d;

  d = *(double*)(rec+109);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  navaid->pos.lon = d;
  
  i = *(unsigned long*)(rec+117);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  navaid->pos.alt = i;

  d = *(double*)(rec+59);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  navaid->freq = d;
  
  i = *(unsigned long*)(rec+125);
  i = LittleEndian (i);
//  CorrectEndian (&i, sizeof(unsigned long));
  navaid->range = i;
  
  d = *(double*)(rec+67);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  navaid->magneticVariation = d;
  
  d = *(double*)(rec+75);
  d = LittleEndian (d);
//  CorrectEndian (&d, sizeof(double));
  navaid->slavedVariation = d;
  
  navaid->prev = NULL;
  navaid->next = NULL;
}


//
// Return a linked list of all navaids (VOR and NDB) within a 200nm radius
//
// The list is not guaranteed to be sorted in any particular order.
//
int GetLocalNavaids(SNavaid **navaids)
{
  int rc = 0;

  *navaids = NULL;
  SNavaid *last = NULL;

  // Get user position and determine globe tile
  SPosition pos = globals->sit->GetUserVehicle()->GetPosition();
  int gtx, gtz;
  lat_lon_to_globe_tile (pos.lat/3600, pos.lon/3600, gtx, gtz);

  int range = 3;
  for (int i=-range; i<=range; i++) {
    for (int j=-range; j<=range; j++) {
      int x = (gtx + j) % 256;
      int z = (gtz + i) % 256;
      SNavaid *temp = NULL;
      rc += SearchNavaidsByGlobeTile (x, z, &temp);
      if (temp != NULL) {
        // Append navaids in this globe tile to the overall list
        if (*navaids == NULL) {
          // First time
          *navaids = temp;
        } else {
          // Subsequent times
          temp->prev = last;
          last->next = temp;
        }
        // Set *last to last item in overall list
        last = temp;
        while (last->next != NULL) last = last->next;
      }
    }
  }

  return rc;
}


//
// Return a linked list of all ILS within a 200nm radius
//
int GetLocalILS(SILS **ils)
{
  int rc = 0;
  return rc;
}


//
// Return a linked list of all Comms facilities within a 200nm radius
//
int GetLocalComms(SComm **comms)
{
  int rc = 0;
  return rc;
}


//
// Return a linked list of all Center comms facilities within a 200nm radius
//
int GetLocalCenters(SComm **comms)
{
  int rc = 0;
  return rc;
}


//
// Return a linked list of all airports within a 200nm radius
//
int GetLocalAirports(SAirport **airports)
{
  int rc = 0;
  return rc;
}


//
// Return a linked list of all Waypoints within a 200nm radius
//
int GetLocalWaypoints(SWaypoint **waypoints)
{
  int rc = 0;
  return rc;
}


//
// Copy details about the nearest navaid (VOR or NDB) within the specified range
//
// Input parameters:
//  pos       Position from which the search is based
//  navType     Bitwise OR of ENavaidTypes used to filter the search
//
// Output parameters:
//  navaid      Updated with navaid details
//  distanceInFeet  Distance from search position to navaid, in feet
// 
// Return code:
//  int       1 if a suitable navaid was found, 0 if not
//
int GetNearestNavaid(SPosition *pos, int navType, SNavaid *navaid, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Copy details about the nearest navaid (VOR or NDB) within the specified range and
//   using the specified frequency
//
// Input parameters:
//  pos       Position from which the search is based
//  navType     Bitwise OR of ENavaidTypes used to filter the search
//  freq      Navaid frequency (MHz)
//
// Output parameters:
//  navaid      Updated with navaid details
//  distanceInFeet  Distance from search position to navaid, in feet
// 
// Return code:
//  int       1 if a suitable navaid was found, 0 if not
//
int GetNearestNavaidByFreq(SPosition *pos, int navType, float freq,
                           SNavaid *navaid, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Copy details about the nearest ILS facility within the specified range
//
// Input parameters:
//  pos       Position from which the search is based
//  freq      ILS frequency (MHz)
//
// Output parameters:
//  navaid      Updated with ILS details
//  distanceInFeet  Distance from search position to ILS facility, in feet
// 
// Return code:
//  int       1 if a suitable ILS facility was found, 0 if not
//
int GetNearestILS(SPosition *pos, float freq, SILS *ils, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Copy details about the nearest Comm facilitiy within the specified range
//
int GetNearestComm(SPosition *pos, float freq, SComm *comm, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Copy details about the nearest Comm facility within the specified range
//
int GetNearestAirportComm(SPosition *pos, float freq, SComm *comm, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Copy details about the nearest Center facility within the specified range
//
int GetNearestCenterComm(SPosition *pos, float freq, SComm *comm, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Copy details about the nearest airport within the specified range
//
int GetNearestAirport(SPosition *pos, SAirport *airport, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Determine if the specified position is near any airport
//
int InAirportRegion(SPosition *pos, float *distanceInFeet)
{
  int rc = 0;

  return rc;
}


//
// Search for an airport using its unique DAFIF key
//
int GetAirport(char *airportKey, SAirport *airport)
{
  int rc = 0;

  return rc;
}


//
// Return a list of all navaids in the database whose ID field matches the
//   specified key value.
//
int SearchNavaidsByID(char *id, int navType, SNavaid **navaids)
{
  int rc = 0;

  return rc;
}


//
// Return a list of all navaids in the database whose name matches the
//   specified key value.
//
int SearchNavaidsByName(char *name, int navType, SNavaid **navaids)
{
  int rc = 0;

  return rc;
}


//
// Return a list of all navaids in the specified Globe Tile
//
int SearchNavaidsByGlobeTile (int x, int z, SNavaid **navaids)
{
  int rc = 0;
  *navaids = NULL;

  char key[16];
  sprintf (key, "%03d%03d", x, z);
  unsigned long offset = dbNavaid->Search ('nltl', key);
  if (offset != 0) {
    // Retrieve the raw database record
    int recLength = dbNavaid->GetRawRecordLength ();
    char *rec = new char[recLength];
    dbNavaid->GetRawRecord (offset, rec);

    // Allocate first SNavaid struct
    SNavaid *first = new SNavaid;
    DecodeNavaidRecord (rec, first);

    // Save pointer to first navaid in return parameter
    *navaids = first;
    rc++;

    // Link remaining navaids to the first one
    SNavaid *prev = first;
    while ((offset = dbNavaid->SearchNext ()) != 0) {
      // Get raw data record
      dbNavaid->GetRawRecord (offset, rec);

      // Allocate next SNavaid struct
      SNavaid *next = new SNavaid;
      DecodeNavaidRecord (rec, next);

      // Cross-link this record into the list
      next->prev = prev;
      prev->next = next;
      prev = next;
    }

    // Free buffer for raw database record
    delete rec;
  }

  return rc;
}

//
// Return a list of all waypoints in the database whose name field matches the
//   specified key value.
//
int SearchWaypointsByName(char *name, SWaypoint **waypoints)
{
  int rc = 0;

  return rc;
}


//
// Search the airports database based on the FAA airport ID
//
int SearchAirportsByFAA(char *faaID, SAirport **airports)
{
  int rc = 0;
  *airports = NULL;

  // Start search of FAA Index to airport database
  unsigned long offset = dbAirport->Search ('aafa', faaID);
  if (offset != 0) {
    // Retrieve the raw database record
    int recLength = dbAirport->GetRawRecordLength ();
    char *rec = new char[recLength];
    dbAirport->GetRawRecord (offset, rec);

    // Allocate first SAirport struct
    SAirport *first = new SAirport;
    DecodeAirportRecord (rec, first);

    // Save pointer to first navaid in return parameter
    *airports = first;
    rc++;


    // Free buffer for raw database record
    delete rec;
  }

  return rc;
}


//
// Search the airports database based on the ICAO airport ID
//
int SearchAirportsByICAO(char *icaoID, SAirport **airports)
{
  int rc = 0;
  *airports = NULL;

  // Start search of ICAO Index to airport database
  unsigned long offset = dbAirport->Search ('acia', icaoID);
  if (offset != 0) {
    // Retrieve the raw database record
    int recLength = dbAirport->GetRawRecordLength ();
    char *rec = new char[recLength];
    dbAirport->GetRawRecord (offset, rec);

    // Allocate first SAirport struct
    SAirport *first = new SAirport;
    DecodeAirportRecord (rec, first);

    // Save pointer to first navaid in return parameter
    *airports = first;
    rc++;


    // Free buffer for raw database record
    delete rec;
  }

  return rc;
}


//
// Search the airports database based on the airport name
//
int SearchAirportsByName(char *name, SAirport **airports)
{
  int rc = 0;


  return rc;
}


//
// Search for a specific ILS facility.  The airportKey value is the unique
//   DAFIF identifier for the airport, and the runwayEndID is the runway end
//   to search, e.g. "23L"
//
int SearchILS(char *airportKey, char *runwayEndID, SILS **ils)
{
  int rc = 0;


  return rc;
}


//
// Perform a generic database search.  The db field contains the name of the
//   DBD database file, the index field contains the name of the DBI index,
//   and key is the index key value to search for.  All matching database records
//   will be put into a linked list which is returned in the list argument.
//
int SearchDatabase(char *db, char *index, char *key, SGeneric **list)
{
  int rc = 0;


  return rc;
}


//
// Free a list of navaid database records
//
void FreeNavaid(SNavaid *navaids)
{
  SNavaid *next = navaids;

  while (next != NULL) {
    SNavaid *prev = next;
    next = next->next;
    delete prev;
  }
}


//
// Free a list of ILS database records
//
void FreeILS(SILS *ils)
{
  SILS *next = ils;

  while (next != NULL) {
    SILS *prev = next;
    next = next->next;
    delete prev;
  }
}


//
// Free a list of waypoint database records
//
void FreeWaypoint(SWaypoint *waypoint)
{
  SWaypoint *next = waypoint;

  while (next != NULL) {
    SWaypoint *prev = next;
    next = next->next;
    delete prev;
  }
}


//
// Free a list of ILS facilities
//
void FreeComm(SComm *comm)
{
  SComm *next = comm;

  while (next != NULL) {
    SComm *prev = next;
    next = next->next;
    delete prev;
  }
}


//
// Free a list of airport database records
//
void FreeAirport(SAirport *airport)
{
  SAirport *next = airport;

  while (next != NULL) {
    SAirport *prev = next;
    next = next->next;
    delete prev;
  }
}


//
// Free a list of generic database records
//
void FreeGeneric(SGeneric *list)
{
  SGeneric *next = list;

  while (next != NULL) {
    SGeneric *prev = next;
    next = next->next;
    delete prev;
  }
}

Documentation generated by