src/Airports/runways.cxx

   1 // runways.hxx -- a simple class to manage airport runway info
   2 //
   3 // Written by Curtis Olson, started August 2000.
   4 //
   5 // Copyright (C) 2000  Curtis L. Olson  - curt@flightgear.org
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28 // #include <sys/types.h>               // for gdbm open flags
  29 // #include <sys/stat.h>                // for gdbm open flags
  30
  31 #include <simgear/compiler.h>
  32
  33 #include <simgear/debug/logstream.hxx>
  34 #include <simgear/misc/sgstream.hxx>
  35
  36 #include STL_STRING
  37 #include STL_FUNCTIONAL
  38 #include STL_ALGORITHM
  39
  40 #include "runways.hxx"
  41
  42 SG_USING_NAMESPACE(std);
  43
  44
  45 FGRunway::FGRunway() {
  46 }
  47
  48
  49 FGRunway::~FGRunway() {
  50 }
  51
  52
  53 FGRunways::FGRunways( const string& file ) {
  54     // open the specified database readonly
  55     storage = new c4_Storage( file.c_str(), false );
  56
  57     if ( !storage->Strategy().IsValid() ) {
  58         SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );
  59         exit(-1);
  60     }
  61
  62     vRunway = new c4_View;
  63     *vRunway =
  64         storage->GetAs("runway[ID:S,Rwy:S,Longitude:F,Latitude:F,Heading:F,Length:F,Width:F,SurfaceFlags:S,End1Flags:F,End2Flags:F]");
  65
  66     next_index = 0;
  67 }
  68
  69
  70 // search for the specified apt id
  71 bool FGRunways::search( const string& aptid, FGRunway* r ) {
  72     c4_StringProp pID ("ID");
  73     c4_StringProp pRwy ("Rwy");
  74     c4_FloatProp pLon ("Longitude");
  75     c4_FloatProp pLat ("Latitude");
  76     c4_FloatProp pHdg ("Heading");
  77     c4_FloatProp pLen ("Length");
  78     c4_FloatProp pWid ("Width");
  79     c4_StringProp pSurf ("SurfaceFlags");
  80     c4_StringProp pEnd1 ("End1Flags");
  81     c4_StringProp pEnd2 ("End2Flags");
  82
  83     int index = vRunway->Find(pID[aptid.c_str()]);
  84     cout << "index = " << index << endl;
  85
  86     if ( index == -1 ) {
  87         return false;
  88     }
  89
  90     next_index = index + 1;
  91
  92     c4_RowRef row = vRunway->GetAt(index);
  93
  94     r->id =      (const char *) pID(row);
  95     r->rwy_no =  (const char *) pRwy(row);
  96     r->lon =     (double) pLon(row);
  97     r->lat =     (double) pLat(row);
  98     r->heading = (double) pHdg(row);
  99     r->length =  (double) pLen(row);
 100     r->width =   (double) pWid(row);
 101     r->surface_flags = (const char *) pSurf(row);
 102     r->end1_flags =    (const char *) pEnd1(row);
 103     r->end2_flags =    (const char *) pEnd2(row);
 104
 105     return true;
 106 }
 107
 108
 109 // search for the specified apt id and runway no
 110 bool FGRunways::search( const string& aptid, const string& rwyno, FGRunway* r )
 111 {
 112     c4_StringProp pID ("ID");
 113     c4_StringProp pRwy ("Rwy");
 114     c4_FloatProp pLon ("Longitude");
 115     c4_FloatProp pLat ("Latitude");
 116     c4_FloatProp pHdg ("Heading");
 117     c4_FloatProp pLen ("Length");
 118     c4_FloatProp pWid ("Width");
 119     c4_StringProp pSurf ("SurfaceFlags");
 120     c4_StringProp pEnd1 ("End1Flags");
 121     c4_StringProp pEnd2 ("End2Flags");
 122
 123     int index = vRunway->Find(pID[aptid.c_str()]);
 124     cout << "index = " << index << endl;
 125
 126     if ( index == -1 ) {
 127         return false;
 128     }
 129
 130     c4_RowRef row = vRunway->GetAt(index);
 131     string rowid = (const char *) pID(row);
 132     string rowrwyno = (const char *) pRwy(row);
 133     while ( rowid == aptid ) {
 134         next_index = index + 1;
 135
 136         if ( rowrwyno == rwyno ) {
 137             r->id =      (const char *) pID(row);
 138             r->rwy_no =  (const char *) pRwy(row);
 139             r->lon =     (double) pLon(row);
 140             r->lat =     (double) pLat(row);
 141             r->heading = (double) pHdg(row);
 142             r->length =  (double) pLen(row);
 143             r->width =   (double) pWid(row);
 144             r->surface_flags = (const char *) pSurf(row);
 145             r->end1_flags =    (const char *) pEnd1(row);
 146             r->end2_flags =    (const char *) pEnd2(row);
 147
 148             return true;
 149         }
 150
 151         index++;
 152         c4_RowRef row = vRunway->GetAt(index);
 153         string rowid = (const char *) pID(row);
 154         string rowrwyno = (const char *) pRwy(row);
 155     }
 156
 157     return false;
 158 }
 159
 160
 161 FGRunway FGRunways::search( const string& aptid ) {
 162     FGRunway a;
 163     search( aptid, &a );
 164     return a;
 165 }
 166
 167
 168 // search for the specified id
 169 bool FGRunways::next( FGRunway* r ) {
 170     c4_StringProp pID ("ID");
 171     c4_StringProp pRwy ("Rwy");
 172     c4_FloatProp pLon ("Longitude");
 173     c4_FloatProp pLat ("Latitude");
 174     c4_FloatProp pHdg ("Heading");
 175     c4_FloatProp pLen ("Length");
 176     c4_FloatProp pWid ("Width");
 177     c4_StringProp pSurf ("SurfaceFlags");
 178     c4_StringProp pEnd1 ("End1Flags");
 179     c4_StringProp pEnd2 ("End2Flags");
 180
 181     int size = vRunway->GetSize();
 182     // cout << "total records = " << size << endl;
 183
 184     int index = next_index;
 185     // cout << "index = " << index << endl;
 186
 187     if ( index == -1 || index >= size ) {
 188         return false;
 189     }
 190
 191     next_index = index + 1;
 192
 193     c4_RowRef row = vRunway->GetAt(index);
 194
 195     r->id =      (const char *) pID(row);
 196     r->rwy_no =  (const char *) pRwy(row);
 197     r->lon =     (double) pLon(row);
 198     r->lat =     (double) pLat(row);
 199     r->heading = (double) pHdg(row);
 200     r->length =  (double) pLen(row);
 201     r->width =   (double) pWid(row);
 202     r->surface_flags = (const char *) pSurf(row);
 203     r->end1_flags =    (const char *) pEnd1(row);
 204     r->end2_flags =    (const char *) pEnd2(row);
 205
 206     return true;
 207 }
 208
 209
 210 // Destructor
 211 FGRunways::~FGRunways( void ) {
 212     delete storage;
 213 }
 214
 215
 216 // Constructor
 217 FGRunwaysUtil::FGRunwaysUtil() {
 218 }
 219
 220
 221 // load the data
 222 int FGRunwaysUtil::load( const string& file ) {
 223     FGRunway r;
 224     string apt_id;
 225
 226     runways.erase( runways.begin(), runways.end() );
 227
 228     sg_gzifstream in( file );
 229     if ( !in.is_open() ) {
 230         SG_LOG( SG_GENERAL, SG_ALERT, "Cannot open file: " << file );
 231         exit(-1);
 232     }
 233
 234     // skip first line of file
 235     char tmp[2048];
 236     in.getline( tmp, 2048 );
 237
 238     // read in each line of the file
 239
 240 #ifdef __MWERKS__
 241
 242     in >> ::skipws;
 243     char c = 0;
 244     while ( in.get(c) && c != '\0' ) {
 245         if ( c == 'A' ) {
 246             in >> apt_id;
 247             in >> skipeol;
 248         } else if ( c == 'R' ) {
 249             in >> r;
 250             r.id = apt_id;
 251             runways.push_back(r);
 252         } else {
 253             in >> skipeol;
 254         }
 255         in >> ::skipws;
 256     }
 257
 258 #else
 259
 260     in >> ::skipws;
 261     while ( ! in.eof() ) {
 262         char c = 0;
 263         in.get(c);
 264         if ( c == 'A' ) {
 265             in >> apt_id;
 266             in >> skipeol;
 267         } else if ( c == 'R' ) {
 268             in >> r;
 269             r.id = apt_id;
 270             // cout << apt_id << " " << r.rwy_no << endl;
 271             runways.push_back(r);
 272         } else {
 273             in >> skipeol;
 274         }
 275         in >> ::skipws;
 276     }
 277
 278 #endif
 279
 280     return 1;
 281 }
 282
 283
 284 // save the data in gdbm format
 285 bool FGRunwaysUtil::dump_mk4( const string& file ) {
 286
 287     // open database for writing
 288     c4_Storage storage( file.c_str(), true );
 289
 290     // need to do something about error handling here!
 291
 292     // define the properties
 293     c4_StringProp pID ("ID");
 294     c4_StringProp pRwy ("Rwy");
 295     c4_FloatProp pLon ("Longitude");
 296     c4_FloatProp pLat ("Latitude");
 297     c4_FloatProp pHdg ("Heading");
 298     c4_FloatProp pLen ("Length");
 299     c4_FloatProp pWid ("Width");
 300     c4_StringProp pSurf ("SurfaceFlags");
 301     c4_StringProp pEnd1 ("End1Flags");
 302     c4_StringProp pEnd2 ("End2Flags");
 303
 304     // Start with an empty view of the proper structure.
 305     c4_View vRunway =
 306         storage.GetAs("runway[ID:S,Rwy:S,Longitude:F,Latitude:F,Heading:F,Length:F,Width:F,SurfaceFlags:S,End1Flags:F,End2Flags:F]");
 307
 308     c4_Row row;
 309
 310     iterator current = runways.begin();
 311     const_iterator end = runways.end();
 312     while ( current != end ) {
 313         // add each runway record
 314         pID (row) = current->id.c_str();
 315         pRwy (row) = current->rwy_no.c_str();
 316         pLon (row) = current->lon;
 317         pLat (row) = current->lat;
 318         pHdg (row) = current->heading;
 319         pLen (row) = current->length;
 320         pWid (row) = current->width;
 321         pSurf (row) = current->surface_flags.c_str();
 322         pEnd1 (row) = current->end1_flags.c_str();
 323         pEnd2 (row) = current->end2_flags.c_str();
 324         vRunway.Add(row);
 325
 326         ++current;
 327     }
 328
 329     // commit our changes
 330     storage.Commit();
 331
 332     return true;
 333 }
 334
 335
 336 #if 0
 337 // search for the specified id
 338 bool
 339 FGRunwaysUtil::search( const string& id, FGRunway* a ) const
 340 {
 341     const_iterator it = runways.find( FGRunway(id) );
 342     if ( it != runways.end() )
 343     {
 344         *a = *it;
 345         return true;
 346     }
 347     else
 348     {
 349         return false;
 350     }
 351 }
 352
 353
 354 FGRunway
 355 FGRunwaysUtil::search( const string& id ) const
 356 {
 357     FGRunway a;
 358     this->search( id, &a );
 359     return a;
 360 }
 361 #endif
 362
 363 // Destructor
 364 FGRunwaysUtil::~FGRunwaysUtil( void ) {
 365 }
 366
 367