src/Navaids/NavDataCache.hxx

   1 /**
   2  * NavDataCache.hxx - defines a unified binary cache for navigation
   3  * data, parsed from various text / XML sources.
   4  */
   5
   6 // Written by James Turner, started 2012.
   7 //
   8 // Copyright (C) 2012 James Turner
   9 //
  10 // This program is free software; you can redistribute it and/or
  11 // modify it under the terms of the GNU General Public License as
  12 // published by the Free Software Foundation; either version 2 of the
  13 // License, or (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful, but
  16 // WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18 // General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  23
  24 #ifndef FG_NAVDATACACHE_HXX
  25 #define FG_NAVDATACACHE_HXX
  26
  27 #include <memory>
  28
  29 #include <simgear/misc/strutils.hxx> // for string_list
  30 #include <Navaids/positioned.hxx>
  31
  32 class SGPath;
  33 class FGRunway;
  34
  35 namespace flightgear
  36 {
  37
  38 /// a pair of airport ID, runway ID
  39 typedef std::pair<PositionedID, PositionedID> AirportRunwayPair;
  40
  41 typedef std::pair<FGPositioned::Type, PositionedID> TypedPositioned;
  42 typedef std::vector<TypedPositioned> TypedPositionedVec;
  43
  44 // pair of airway ID, destination node ID
  45 typedef std::pair<int, PositionedID> AirwayEdge;
  46 typedef std::vector<AirwayEdge> AirwayEdgeVec;
  47
  48 namespace Octree {
  49   class Node;
  50   class Branch;
  51 }
  52
  53 class NavDataCache
  54 {
  55 public:
  56     ~NavDataCache();
  57
  58 // singleton accessor
  59     static NavDataCache* instance();
  60
  61   /**
  62    * predicate - check if the cache needs to be rebuilt.
  63    * This can happen is the cache file is missing or damaged, or one of the
  64    ** global input files is changed.
  65    */
  66   bool isRebuildRequired();
  67
  68   /**
  69    * run the cache rebuild - returns true if rebuild is complete,
  70    * otherwise keep going.
  71    */
  72   bool rebuild();
  73
  74   bool isCachedFileModified(const SGPath& path) const;
  75   void stampCacheFile(const SGPath& path);
  76
  77   int readIntProperty(const std::string& key);
  78   double readDoubleProperty(const std::string& key);
  79   std::string readStringProperty(const std::string& key);
  80
  81   void writeIntProperty(const std::string& key, int value);
  82   void writeStringProperty(const std::string& key, const std::string& value);
  83   void writeDoubleProperty(const std::string& key, const double& value);
  84
  85   string_list readStringListProperty(const std::string& key);
  86   void writeStringListProperty(const std::string& key, const string_list& values);
  87
  88   /**
  89    * retrieve an FGPositioned from the cache.
  90    * This may be trivial if the object is previously loaded, or require actual
  91    * disk IO.
  92    */
  93   FGPositioned* loadById(PositionedID guid);
  94
  95   PositionedID insertAirport(FGPositioned::Type ty, const std::string& ident,
  96                              const std::string& name);
  97   void insertTower(PositionedID airportId, const SGGeod& pos);
  98   PositionedID insertRunway(FGPositioned::Type ty, const std::string& ident,
  99                           const SGGeod& pos, PositionedID apt,
 100                           double heading, double length, double width, double displacedThreshold,
 101                           double stopway, int surfaceCode);
 102   void setRunwayReciprocal(PositionedID runway, PositionedID recip);
 103   void setRunwayILS(PositionedID runway, PositionedID ils);
 104
 105   void updateRunwayThreshold(PositionedID runwayID, const SGGeod &aThreshold,
 106                     double aHeading, double aDisplacedThreshold,
 107                     double aStopway);
 108
 109   PositionedID insertNavaid(FGPositioned::Type ty, const std::string& ident,
 110                             const std::string& name, const SGGeod& pos, int freq, int range, double multiuse,
 111                             PositionedID apt, PositionedID runway);
 112   void updateILS(PositionedID ils, const SGGeod& newPos, double aHdg);
 113
 114   PositionedID insertCommStation(FGPositioned::Type ty,
 115                                  const std::string& name, const SGGeod& pos, int freq, int range,
 116                                 PositionedID apt);
 117   PositionedID insertFix(const std::string& ident, const SGGeod& aPos);
 118
 119   PositionedID createPOI(FGPositioned::Type ty, const std::string& ident, const SGGeod& aPos);
 120
 121   void removePOI(FGPositioned::Type ty, const std::string& aIdent);
 122
 123   void dropGroundnetFor(PositionedID aAirport);
 124
 125   PositionedID insertParking(const std::string& name, const SGGeod& aPos,
 126                              PositionedID aAirport,
 127                              double aHeading, int aRadius, const std::string& aAircraftType,
 128                              const std::string& aAirlines);
 129
 130   void setParkingPushBackRoute(PositionedID parking, PositionedID pushBackNode);
 131
 132   PositionedID insertTaxiNode(const SGGeod& aPos, PositionedID aAirport, int aHoldType, bool aOnRunway);
 133
 134   void insertGroundnetEdge(PositionedID aAirport, PositionedID from, PositionedID to);
 135
 136   /// update the metar flag associated with an airport
 137   void setAirportMetar(const std::string& icao, bool hasMetar);
 138
 139   /**
 140    * Modify the position of an existing item.
 141    */
 142   void updatePosition(PositionedID item, const SGGeod &pos);
 143
 144   FGPositioned::List findAllWithIdent(const std::string& ident,
 145                                       FGPositioned::Filter* filter, bool exact);
 146   FGPositioned::List findAllWithName(const std::string& ident,
 147                                       FGPositioned::Filter* filter, bool exact);
 148
 149   FGPositionedRef findClosestWithIdent(const std::string& aIdent,
 150                                       const SGGeod& aPos, FGPositioned::Filter* aFilter);
 151
 152
 153   /**
 154    * Helper to implement the AirportSearch widget. Optimised text search of
 155    * airport names and idents, returning a list suitable for passing directly
 156    * to PLIB.
 157    */
 158   char** searchAirportNamesAndIdents(const std::string& aFilter);
 159
 160   /**
 161    * Find the closest matching comm-station on a frequency, to a position.
 162    * The filter with be used for both type ranging and to validate the result
 163    * candidates.
 164    */
 165   FGPositionedRef findCommByFreq(int freqKhz, const SGGeod& pos, FGPositioned::Filter* filt);
 166
 167   /**
 168    * find all items of a specified type (or range of types) at an airport
 169    */
 170   PositionedIDVec airportItemsOfType(PositionedID apt, FGPositioned::Type ty,
 171                                      FGPositioned::Type maxTy = FGPositioned::INVALID);
 172
 173   /**
 174    * find the first match item of the specified type and ident, at an airport
 175    */
 176   PositionedID airportItemWithIdent(PositionedID apt, FGPositioned::Type ty, const std::string& ident);
 177
 178   /**
 179    * Find all navaids matching a particular frequency, sorted by range from the
 180    * supplied position. Type-range will be determined from the filter
 181    */
 182   PositionedIDVec findNavaidsByFreq(int freqKhz, const SGGeod& pos, FGPositioned::Filter* filt);
 183
 184   /// overload version of the above that does not consider positioned when
 185   /// returning results. Only used by TACAN carrier search
 186   PositionedIDVec findNavaidsByFreq(int freqKhz, FGPositioned::Filter* filt);
 187
 188   /**
 189    * Given a runway and type, find the corresponding navaid (ILS / GS / OM)
 190    */
 191   PositionedID findNavaidForRunway(PositionedID runway, FGPositioned::Type ty);
 192
 193   /**
 194    * given a navaid name (or similar) from apt.dat / nav.dat, find the
 195    * corresponding airport and runway IDs.
 196    * Such names look like: 'LHBP 31L DME-ILS' or 'UEEE 23L MM'
 197    */
 198   AirportRunwayPair findAirportRunway(const std::string& name);
 199
 200   /**
 201    * Given an aiport, and runway and ILS identifier, find the corresponding cache
 202    * entry. This matches the data we get in the ils.xml files for airports.
 203    */
 204   PositionedID findILS(PositionedID airport, const std::string& runway, const std::string& navIdent);
 205
 206   /**
 207    * Given an Octree node ID, return a bit-mask defining which of the child
 208    * nodes exist. In practice this means an 8-bit value be sufficent, but
 209    * an int works fine too.
 210    */
 211   int getOctreeBranchChildren(int64_t octreeNodeId);
 212
 213   void defineOctreeNode(Octree::Branch* pr, Octree::Node* nd);
 214
 215   /**
 216    * given an octree leaf, return all its child positioned items and their types
 217    */
 218   TypedPositionedVec getOctreeLeafChildren(int64_t octreeNodeId);
 219
 220 // airways
 221   int findAirway(int network, const std::string& aName);
 222
 223   /**
 224    * insert an edge between two positioned nodes, into the network.
 225    * The airway identifier will be set accordingly. No reverse edge is created
 226    * by this method - edges are directional so a reverses must be explicitly
 227    * created.
 228    */
 229   void insertEdge(int network, int airwayID, PositionedID from, PositionedID to);
 230
 231   /// is the specified positioned a node on the network?
 232   bool isInAirwayNetwork(int network, PositionedID pos);
 233
 234   /**
 235    * retrive all the destination points reachcable from a positioned
 236    * in an airway
 237    */
 238   AirwayEdgeVec airwayEdgesFrom(int network, PositionedID pos);
 239
 240 // ground-network
 241   PositionedIDVec groundNetNodes(PositionedID aAirport, bool onlyPushback);
 242   void markGroundnetAsPushback(PositionedID nodeId);
 243
 244   PositionedID findGroundNetNode(PositionedID airport, const SGGeod& aPos,
 245                                  bool onRunway, FGRunway* aRunway = NULL);
 246   PositionedIDVec groundNetEdgesFrom(PositionedID pos, bool onlyPushback);
 247
 248   PositionedIDVec findAirportParking(PositionedID airport, const std::string& flightType,
 249                                      int radius);
 250
 251
 252     class Transaction
 253     {
 254     public:
 255         Transaction(NavDataCache* cache);
 256         ~Transaction();
 257
 258         void commit();
 259     private:
 260         NavDataCache* _instance;
 261         bool _committed;
 262     };
 263 private:
 264   NavDataCache();
 265
 266   friend class RebuildThread;
 267   void doRebuild();
 268
 269   friend class Transaction;
 270
 271     void beginTransaction();
 272     void commitTransaction();
 273     void abortTransaction();
 274
 275   class NavDataCachePrivate;
 276   std::auto_ptr<NavDataCachePrivate> d;
 277 };
 278
 279 } // of namespace flightgear
 280
 281 #endif // of FG_NAVDATACACHE_HXX
 282