From: Thomas Geymayer <tomgey@gmail.com>
Date: Wed, 6 Mar 2013 22:21:29 +0000 (+0100)
Subject: Clean up/simplify NasalPositioned_cppbind
X-Git-Url: https://git.mxchange.org/?a=commitdiff_plain;h=3047c316dc60142508a7e47c24108ba415525f15;p=flightgear.git

Clean up/simplify NasalPositioned_cppbind

Ensure all FGPositioned related functions return SGSharedPtr
instead of raw pointers to allow automatic conversion to
nasal ghosts without custom helper functions.
---

diff --git a/src/ATC/CommStation.cxx b/src/ATC/CommStation.cxx
index b5280f38b..bdbb47114 100644
--- a/src/ATC/CommStation.cxx
+++ b/src/ATC/CommStation.cxx
@@ -1,5 +1,5 @@
 #include "CommStation.hxx"
-
+#include <Airports/airport.hxx>
 #include <Navaids/NavDataCache.hxx>
 
 namespace flightgear {
@@ -17,9 +17,9 @@ void CommStation::setAirport(PositionedID apt)
     mAirport = apt;
 }
   
-FGAirport* CommStation::airport() const
+FGAirportRef CommStation::airport() const
 {
-  return (FGAirport*) NavDataCache::instance()->loadById(mAirport);
+  return FGPositioned::loadById<FGAirport>(mAirport);
 }
 
 double CommStation::freqMHz() const
@@ -27,7 +27,7 @@ double CommStation::freqMHz() const
     return mFreqKhz / 1000.0;
 }
 
-CommStation*
+CommStationRef
 CommStation::findByFreq(int freqKhz, const SGGeod& pos, FGPositioned::Filter* filt)
 {
   return (CommStation*) NavDataCache::instance()->findCommByFreq(freqKhz, pos, filt).ptr();
diff --git a/src/ATC/CommStation.hxx b/src/ATC/CommStation.hxx
index 33019f980..d1a6b26f3 100644
--- a/src/ATC/CommStation.hxx
+++ b/src/ATC/CommStation.hxx
@@ -1,10 +1,9 @@
 #ifndef FG_ATC_COMM_STATION_HXX
 #define FG_ATC_COMM_STATION_HXX
 
+#include <Airports/airports_fwd.hxx>
 #include <Navaids/positioned.hxx>
 
-class FGAirport;
-
 namespace flightgear
 {
 
@@ -14,7 +13,7 @@ public:
     CommStation(PositionedID aGuid, const std::string& name, FGPositioned::Type t, const SGGeod& pos, int range, int freq);
 
     void setAirport(PositionedID apt);
-    FGAirport* airport() const;
+    FGAirportRef airport() const;
     
     int rangeNm() const
         { return mRangeNM; }
@@ -24,7 +23,7 @@ public:
         
     double freqMHz() const;
     
-    static CommStation* findByFreq(int freqKhz, const SGGeod& pos, FGPositioned::Filter* filt = NULL);
+    static CommStationRef findByFreq(int freqKhz, const SGGeod& pos, FGPositioned::Filter* filt = NULL);
 private:
     int mRangeNM;
     int mFreqKhz;
diff --git a/src/ATC/atcdialog.cxx b/src/ATC/atcdialog.cxx
index ad75f3001..00c3e2c05 100644
--- a/src/ATC/atcdialog.cxx
+++ b/src/ATC/atcdialog.cxx
@@ -92,7 +92,7 @@ void FGATCDialogNew::frequencySearch()
 	button_group->removeChildren("button", false);
   
   AirportsWithATC filt;
-  FGPositioned::List results = FGPositioned::findWithinRange(globals->get_aircraft_position(), 50.0, &filt);
+  FGPositionedList results = FGPositioned::findWithinRange(globals->get_aircraft_position(), 50.0, &filt);
   FGPositioned::sortByRange(results, globals->get_aircraft_position());
   for (unsigned int r=0; (r<results.size()) && (r < 6); ++r) {
     
diff --git a/src/Airports/airport.cxx b/src/Airports/airport.cxx
index 1c96c2ef2..89a98202e 100644
--- a/src/Airports/airport.cxx
+++ b/src/Airports/airport.cxx
@@ -144,14 +144,14 @@ unsigned int FGAirport::numHelipads() const
 }
 
 //------------------------------------------------------------------------------
-FGRunway* FGAirport::getRunwayByIndex(unsigned int aIndex) const
+FGRunwayRef FGAirport::getRunwayByIndex(unsigned int aIndex) const
 {
   loadRunways();
   return loadById<FGRunway>(mRunways, aIndex);
 }
 
 //------------------------------------------------------------------------------
-FGHelipad* FGAirport::getHelipadByIndex(unsigned int aIndex) const
+FGHelipadRef FGAirport::getHelipadByIndex(unsigned int aIndex) const
 {
   loadHelipads();
   return loadById<FGHelipad>(mHelipads, aIndex);
@@ -196,18 +196,24 @@ FGHelipadMap FGAirport::getHelipadMap() const
 //------------------------------------------------------------------------------
 bool FGAirport::hasRunwayWithIdent(const std::string& aIdent) const
 {
-  return flightgear::NavDataCache::instance()->airportItemWithIdent(guid(), FGPositioned::RUNWAY, aIdent) != 0;
+  return flightgear::NavDataCache::instance()
+    ->airportItemWithIdent(guid(), FGPositioned::RUNWAY, aIdent) != 0;
 }
 
+//------------------------------------------------------------------------------
 bool FGAirport::hasHelipadWithIdent(const std::string& aIdent) const
 {
-  return flightgear::NavDataCache::instance()->airportItemWithIdent(guid(), FGPositioned::HELIPAD, aIdent) != 0;
+  return flightgear::NavDataCache::instance()
+    ->airportItemWithIdent(guid(), FGPositioned::HELIPAD, aIdent) != 0;
 }
 
 //------------------------------------------------------------------------------
-FGRunway* FGAirport::getRunwayByIdent(const std::string& aIdent) const
+FGRunwayRef FGAirport::getRunwayByIdent(const std::string& aIdent) const
 {
-  PositionedID id = flightgear::NavDataCache::instance()->airportItemWithIdent(guid(), FGPositioned::RUNWAY, aIdent);  
+  PositionedID id =
+    flightgear::NavDataCache::instance()
+      ->airportItemWithIdent(guid(), FGPositioned::RUNWAY, aIdent);
+
   if (id == 0) {
     SG_LOG(SG_GENERAL, SG_ALERT, "no such runway '" << aIdent << "' at airport " << ident());
     throw sg_range_exception("unknown runway " + aIdent + " at airport:" + ident(), "FGAirport::getRunwayByIdent");
@@ -217,7 +223,7 @@ FGRunway* FGAirport::getRunwayByIdent(const std::string& aIdent) const
 }
 
 //------------------------------------------------------------------------------
-FGHelipad* FGAirport::getHelipadByIdent(const std::string& aIdent) const
+FGHelipadRef FGAirport::getHelipadByIdent(const std::string& aIdent) const
 {
   PositionedID id = flightgear::NavDataCache::instance()->airportItemWithIdent(guid(), FGPositioned::HELIPAD, aIdent);
   if (id == 0) {
@@ -229,7 +235,7 @@ FGHelipad* FGAirport::getHelipadByIdent(const std::string& aIdent) const
 }
 
 //------------------------------------------------------------------------------
-FGRunway* FGAirport::findBestRunwayForHeading(double aHeading) const
+FGRunwayRef FGAirport::findBestRunwayForHeading(double aHeading) const
 {
   loadRunways();
   
@@ -260,7 +266,7 @@ FGRunway* FGAirport::findBestRunwayForHeading(double aHeading) const
 }
 
 //------------------------------------------------------------------------------
-FGRunway* FGAirport::findBestRunwayForPos(const SGGeod& aPos) const
+FGRunwayRef FGAirport::findBestRunwayForPos(const SGGeod& aPos) const
 {
   loadRunways();
   
@@ -331,7 +337,7 @@ unsigned int FGAirport::numTaxiways() const
 }
 
 //------------------------------------------------------------------------------
-FGTaxiway* FGAirport::getTaxiwayByIndex(unsigned int aIndex) const
+FGTaxiwayRef FGAirport::getTaxiwayByIndex(unsigned int aIndex) const
 {
   loadTaxiways();
   return loadById<FGTaxiway>(mTaxiways, aIndex);
@@ -352,7 +358,7 @@ unsigned int FGAirport::numPavements() const
 }
 
 //------------------------------------------------------------------------------
-FGPavement* FGAirport::getPavementByIndex(unsigned int aIndex) const
+FGPavementRef FGAirport::getPavementByIndex(unsigned int aIndex) const
 {
   loadTaxiways();
   return loadById<FGPavement>(mPavements, aIndex);
@@ -366,7 +372,7 @@ FGPavementList FGAirport::getPavements() const
 }
 
 //------------------------------------------------------------------------------
-FGRunway* FGAirport::getActiveRunwayForUsage() const
+FGRunwayRef FGAirport::getActiveRunwayForUsage() const
 {
   FGEnvironmentMgr* envMgr = (FGEnvironmentMgr *) globals->get_subsystem("environment");
   
@@ -386,19 +392,19 @@ FGRunway* FGAirport::getActiveRunwayForUsage() const
   return findBestRunwayForHeading(hdg);
 }
 
-FGAirport* FGAirport::findClosest(const SGGeod& aPos, double aCuttofNm, Filter* filter)
+//------------------------------------------------------------------------------
+FGAirportRef FGAirport::findClosest( const SGGeod& aPos,
+                                     double aCuttofNm,
+                                     Filter* filter )
 {
   AirportFilter aptFilter;
-  if (filter == NULL) {
+  if( !filter )
     filter = &aptFilter;
-  }
   
-  FGPositionedRef r = FGPositioned::findClosest(aPos, aCuttofNm, filter);
-  if (!r) {
-    return NULL;
-  }
-  
-  return static_cast<FGAirport*>(r.ptr());
+  return static_pointer_cast<FGAirport>
+  (
+    FGPositioned::findClosest(aPos, aCuttofNm, filter)
+  );
 }
 
 FGAirport::HardSurfaceFilter::HardSurfaceFilter(double minLengthFt) :
@@ -446,14 +452,17 @@ bool FGAirport::TypeRunwayFilter::pass(FGPositioned* pos) const
 }
 
 //------------------------------------------------------------------------------
-FGAirport* FGAirport::findByIdent(const std::string& aIdent)
+FGAirportRef FGAirport::findByIdent(const std::string& aIdent)
 {
   AirportCache::iterator it = airportCache.find(aIdent);
   if (it != airportCache.end())
    return it->second;
 
   PortsFilter filter;
-  FGAirport* r = static_cast<FGAirport*> (FGPositioned::findFirstWithIdent(aIdent, &filter).get());
+  FGAirportRef r = static_pointer_cast<FGAirport>
+  (
+    FGPositioned::findFirstWithIdent(aIdent, &filter)
+  );
 
   // add airport to the cache (even when it's NULL, so we don't need to search in vain again)
   airportCache[aIdent] = r;
@@ -462,9 +471,10 @@ FGAirport* FGAirport::findByIdent(const std::string& aIdent)
   return r;
 }
 
-FGAirport* FGAirport::getByIdent(const std::string& aIdent)
+//------------------------------------------------------------------------------
+FGAirportRef FGAirport::getByIdent(const std::string& aIdent)
 {
-  FGAirport* r = findByIdent(aIdent);
+  FGAirportRef r = findByIdent(aIdent);
   if (!r)
     throw sg_range_exception("No such airport with ident: " + aIdent);
   return r;
@@ -854,7 +864,7 @@ FGAirport::commStations() const
                                                             FGPositioned::FREQ_GROUND,
                                                             FGPositioned::FREQ_UNICOM))
   {
-    result.push_back((CommStation*) cache->loadById(pos));
+    result.push_back( loadById<CommStation>(pos) );
   }
   
   return result;
@@ -866,7 +876,7 @@ FGAirport::commStationsOfType(FGPositioned::Type aTy) const
   NavDataCache* cache = NavDataCache::instance();
   CommStationList result;
   BOOST_FOREACH(PositionedID pos, cache->airportItemsOfType(guid(), aTy)) {
-    result.push_back((CommStation*) cache->loadById(pos));
+    result.push_back( loadById<CommStation>(pos) );
   }
   
   return result;
diff --git a/src/Airports/airport.hxx b/src/Airports/airport.hxx
index f0618018d..fdf365755 100644
--- a/src/Airports/airport.hxx
+++ b/src/Airports/airport.hxx
@@ -79,22 +79,22 @@ class FGAirport : public FGPositioned
 
     void setMetar(bool value) { _has_metar = value; }
 
-    FGRunway* getActiveRunwayForUsage() const;
+    FGRunwayRef getActiveRunwayForUsage() const;
 
     FGAirportDynamics *getDynamics();
     
     unsigned int numRunways() const;
     unsigned int numHelipads() const;
-    FGRunway* getRunwayByIndex(unsigned int aIndex) const;
-    FGHelipad* getHelipadByIndex(unsigned int aIndex) const;
+    FGRunwayRef getRunwayByIndex(unsigned int aIndex) const;
+    FGHelipadRef getHelipadByIndex(unsigned int aIndex) const;
     FGRunwayMap getRunwayMap() const;
     FGHelipadMap getHelipadMap() const;
 
     bool hasRunwayWithIdent(const std::string& aIdent) const;
     bool hasHelipadWithIdent(const std::string& aIdent) const;
-    FGRunway* getRunwayByIdent(const std::string& aIdent) const;
-    FGHelipad* getHelipadByIdent(const std::string& aIdent) const;
-    FGRunway* findBestRunwayForHeading(double aHeading) const;
+    FGRunwayRef getRunwayByIdent(const std::string& aIdent) const;
+    FGHelipadRef getHelipadByIdent(const std::string& aIdent) const;
+    FGRunwayRef findBestRunwayForHeading(double aHeading) const;
     
     /**
      * return the most likely target runway based on a position.
@@ -103,7 +103,7 @@ class FGAirport : public FGPositioned
      * This is a good approximation of which runway the position is on or
      * aiming towards.
      */
-    FGRunway* findBestRunwayForPos(const SGGeod& aPos) const;
+    FGRunwayRef findBestRunwayForPos(const SGGeod& aPos) const;
     
     /**
      * Retrieve all runways at the airport, but excluding the reciprocal
@@ -125,11 +125,11 @@ class FGAirport : public FGPositioned
     bool hasHardRunwayOfLengthFt(double aLengthFt) const;
 
     unsigned int numTaxiways() const;
-    FGTaxiway* getTaxiwayByIndex(unsigned int aIndex) const;
+    FGTaxiwayRef getTaxiwayByIndex(unsigned int aIndex) const;
     FGTaxiwayList getTaxiways() const;
 
     unsigned int numPavements() const;
-    FGPavement* getPavementByIndex(unsigned int aIndex) const;
+    FGPavementRef getPavementByIndex(unsigned int aIndex) const;
     FGPavementList getPavements() const;
     
     class AirportFilter : public Filter
@@ -230,20 +230,20 @@ class FGAirport : public FGPositioned
       * match for filter, and return it cast to FGAirport. The default filter
       * passes airports, but not seaports or heliports
       */
-     static FGAirport* findClosest(const SGGeod& aPos, double aCuttofNm, Filter* filter = NULL);
+     static FGAirportRef findClosest(const SGGeod& aPos, double aCuttofNm, Filter* filter = NULL);
      
      /**
       * Helper to look up an FGAirport instance by unique ident. Throws an 
       * exception if the airport could not be found - so callers can assume
       * the result is non-NULL.
       */
-     static FGAirport* getByIdent(const std::string& aIdent);
+     static FGAirportRef getByIdent(const std::string& aIdent);
      
      /**
       * Helper to look up an FGAirport instance by unique ident. Returns NULL
       * if the airport could not be found.
       */
-     static FGAirport* findByIdent(const std::string& aIdent);
+     static FGAirportRef findByIdent(const std::string& aIdent);
      
      /**
       * Specialised helper to implement the AirportList dialog. Performs a
diff --git a/src/Airports/airports_fwd.hxx b/src/Airports/airports_fwd.hxx
index 679587a4c..6b89c0e82 100644
--- a/src/Airports/airports_fwd.hxx
+++ b/src/Airports/airports_fwd.hxx
@@ -29,6 +29,7 @@
 // forward decls
 class FGAirport;
 class FGAirportDynamics;
+class FGRunwayBase;
 class FGRunway;
 class FGHelipad;
 class FGTaxiway;
@@ -66,21 +67,25 @@ namespace flightgear {
   typedef std::vector<WayptRef> WayptVec;
 
   typedef SGSharedPtr<CommStation> CommStationRef;
-  typedef std::vector<CommStation*> CommStationList;
+  typedef std::vector<CommStationRef> CommStationList;
   typedef std::map<std::string, FGAirport*> AirportCache;
 }
 
 typedef SGSharedPtr<FGAirport> FGAirportRef;
+typedef SGSharedPtr<FGRunwayBase> FGRunwayBaseRef;
 typedef SGSharedPtr<FGRunway> FGRunwayRef;
+typedef SGSharedPtr<FGHelipad> FGHelipadRef;
+typedef SGSharedPtr<FGTaxiway> FGTaxiwayRef;
+typedef SGSharedPtr<FGPavement> FGPavementRef;
 typedef SGSharedPtr<FGParking> FGParkingRef;
 
-typedef std::vector<FGRunway*> FGRunwayList;
-typedef std::map<std::string, FGRunway*> FGRunwayMap;
-typedef std::map<std::string, FGHelipad*> FGHelipadMap;
+typedef std::vector<FGRunwayRef> FGRunwayList;
+typedef std::map<std::string, FGRunwayRef> FGRunwayMap;
+typedef std::map<std::string, FGHelipadRef> FGHelipadMap;
 
-typedef std::vector<FGTaxiway*> FGTaxiwayList;
-typedef std::vector<FGPavement*> FGPavementList;
-typedef std::vector<FGParking*> FGParkingList;
+typedef std::vector<FGTaxiwayRef> FGTaxiwayList;
+typedef std::vector<FGPavementRef> FGPavementList;
+typedef std::vector<FGParkingRef> FGParkingList;
 
 typedef std::vector<FGTaxiSegment*>  FGTaxiSegmentVector;
 typedef FGTaxiSegmentVector::iterator FGTaxiSegmentVectorIterator;
diff --git a/src/Airports/dynamics.cxx b/src/Airports/dynamics.cxx
index 3c45a1c45..a88a44149 100644
--- a/src/Airports/dynamics.cxx
+++ b/src/Airports/dynamics.cxx
@@ -226,9 +226,9 @@ ParkingAssignment FGAirportDynamics::getAvailableParking(double radius, const st
   return result ? ParkingAssignment(result, _ap) : ParkingAssignment();
 }
 
-FGParking *FGAirportDynamics::getParking(PositionedID id) const
+FGParkingRef FGAirportDynamics::getParking(PositionedID id) const
 {
-  return static_cast<FGParking*>(flightgear::NavDataCache::instance()->loadById(id));
+  return FGPositioned::loadById<FGParking>(id);
 }
 
 string FGAirportDynamics::getParkingName(PositionedID id) const
diff --git a/src/Airports/dynamics.hxx b/src/Airports/dynamics.hxx
index b2ee16fdd..1368570da 100644
--- a/src/Airports/dynamics.hxx
+++ b/src/Airports/dynamics.hxx
@@ -138,7 +138,7 @@ public:
   
     bool isParkingAvailable(PositionedID parking) const;
   
-    FGParking *getParking(PositionedID i) const;
+    FGParkingRef getParking(PositionedID i) const;
     void releaseParking(PositionedID id);
     std::string getParkingName(PositionedID i) const;
 
diff --git a/src/Airports/groundnetwork.cxx b/src/Airports/groundnetwork.cxx
index 344161172..7bb7ce3bb 100644
--- a/src/Airports/groundnetwork.cxx
+++ b/src/Airports/groundnetwork.cxx
@@ -82,14 +82,14 @@ SGGeod FGTaxiSegment::getCenter() const
   return SGGeodesy::direct(start->geod(), heading, length * 0.5);
 }
 
-FGTaxiNode* FGTaxiSegment::getEnd() const
+FGTaxiNodeRef FGTaxiSegment::getEnd() const
 {
-  return static_cast<FGTaxiNode*>(NavDataCache::instance()->loadById(endNode));
+  return FGPositioned::loadById<FGTaxiNode>(endNode);
 }
 
-FGTaxiNode* FGTaxiSegment::getStart() const
+FGTaxiNodeRef FGTaxiSegment::getStart() const
 {
-  return static_cast<FGTaxiNode*>(NavDataCache::instance()->loadById(startNode));
+  return FGPositioned::loadById<FGTaxiNode>(startNode);
 }
 
 double FGTaxiSegment::getLength() const
@@ -343,10 +343,9 @@ int FGGroundNetwork::findNearestNodeOnRunway(const SGGeod & aGeod, FGRunway* aRu
   return NavDataCache::instance()->findGroundNetNode(parent->guid(), aGeod, onRunway, aRunway);
 }
 
-FGTaxiNode* FGGroundNetwork::findNode(PositionedID idx) const
+FGTaxiNodeRef FGGroundNetwork::findNode(PositionedID idx) const
 {
-
-  return static_cast<FGTaxiNode*>(NavDataCache::instance()->loadById(idx));
+  return FGPositioned::loadById<FGTaxiNode>(idx);
 }
 
 FGTaxiSegment *FGGroundNetwork::findSegment(unsigned idx) const
@@ -447,7 +446,7 @@ FGTaxiRoute FGGroundNetwork::findShortestRoute(PositionedID start, PositionedID
         }
       
         BOOST_FOREACH(PositionedID targetId, cache->groundNetEdgesFrom(best->guid(), !fullSearch)) {
-            FGTaxiNode* tgt = (FGTaxiNode*) cache->loadById(targetId);
+            FGTaxiNodeRef tgt = FGPositioned::loadById<FGTaxiNode>(targetId);
             double edgeLength = dist(best->cart(), tgt->cart());          
             double alt = searchData[best].score + edgeLength + edgePenalty(tgt);
             if (alt < searchData[tgt].score) {    // Relax (u,v)
diff --git a/src/Airports/groundnetwork.hxx b/src/Airports/groundnetwork.hxx
index 2c7884bf2..342cdbe8d 100644
--- a/src/Airports/groundnetwork.hxx
+++ b/src/Airports/groundnetwork.hxx
@@ -76,8 +76,8 @@ public:
     void unblock(time_t now); 
     bool hasBlock(time_t now);
 
-    FGTaxiNode * getEnd() const;
-    FGTaxiNode * getStart() const;
+    FGTaxiNodeRef getEnd() const;
+    FGTaxiNodeRef getStart() const;
   
     double getLength() const;
   
@@ -208,7 +208,7 @@ public:
     int findNearestNode(const SGGeod& aGeod) const;
     int findNearestNodeOnRunway(const SGGeod& aGeod, FGRunway* aRunway = NULL) const;
 
-    FGTaxiNode *findNode(PositionedID idx) const;
+    FGTaxiNodeRef findNode(PositionedID idx) const;
     FGTaxiSegment *findSegment(unsigned idx) const;
   
     /**
diff --git a/src/Airports/runways.cxx b/src/Airports/runways.cxx
index e63fb9d73..84205a276 100644
--- a/src/Airports/runways.cxx
+++ b/src/Airports/runways.cxx
@@ -155,7 +155,7 @@ FGNavRecord* FGRunway::glideslope() const
     return NULL;
   }
   
-  return (FGNavRecord*) cache->loadById(gsId);
+  return loadById<FGNavRecord>(gsId);
 }
 
 flightgear::SIDList FGRunway::getSIDs() const
diff --git a/src/Cockpit/NavDisplay.hxx b/src/Cockpit/NavDisplay.hxx
index 62e9d45a7..8a24eece7 100644
--- a/src/Cockpit/NavDisplay.hxx
+++ b/src/Cockpit/NavDisplay.hxx
@@ -192,7 +192,7 @@ private:
     
     bool _cachedItemsValid;
     SGVec3d _cachedPos;
-    FGPositioned::List _itemsInRange;
+    FGPositionedList _itemsInRange;
     SGPropertyNode_ptr _excessDataNode;
     int _maxSymbols;
     SGPropertyNode_ptr _customSymbols;
diff --git a/src/GUI/MapWidget.cxx b/src/GUI/MapWidget.cxx
index c0d1c0376..4f1d952c0 100644
--- a/src/GUI/MapWidget.cxx
+++ b/src/GUI/MapWidget.cxx
@@ -938,7 +938,7 @@ void MapWidget::drawAirports()
 {
   MapAirportFilter af(_root);
   bool partial = false;
-  FGPositioned::List apts = FGPositioned::findWithinRangePartial(_projectionCenter, _drawRangeNm, &af, partial);
+  FGPositionedList apts = FGPositioned::findWithinRangePartial(_projectionCenter, _drawRangeNm, &af, partial);
   for (unsigned int i=0; i<apts.size(); ++i) {
     drawAirport((FGAirport*) apts[i].get());
   }
@@ -981,7 +981,7 @@ void MapWidget::drawNavaids()
   NavaidFilter f(fixes, _root->getBoolValue("draw-navaids"));
 
   if (f.minType() <= f.maxType()) {
-    FGPositioned::List navs = FGPositioned::findWithinRange(_projectionCenter, _drawRangeNm, &f);
+    FGPositionedList navs = FGPositioned::findWithinRange(_projectionCenter, _drawRangeNm, &f);
 
     glLineWidth(1.0);
     for (unsigned int i=0; i<navs.size(); ++i) {
@@ -1002,7 +1002,7 @@ void MapWidget::drawPOIs()
   FGPositioned::TypeFilter f(FGPositioned::COUNTRY);
   f.addType(FGPositioned::CITY);
   f.addType(FGPositioned::TOWN);
-  FGPositioned::List poi = FGPositioned::findWithinRange(_projectionCenter, _drawRangeNm, &f);
+  FGPositionedList poi = FGPositioned::findWithinRange(_projectionCenter, _drawRangeNm, &f);
 
     glLineWidth(1.0);
     for (unsigned int i=0; i<poi.size(); ++i) {
diff --git a/src/Instrumentation/dclgps.cxx b/src/Instrumentation/dclgps.cxx
index 24fba0040..426f33835 100644
--- a/src/Instrumentation/dclgps.cxx
+++ b/src/Instrumentation/dclgps.cxx
@@ -1368,7 +1368,7 @@ public:
 GPSWaypoint* DCLGPS::FindFirstById(const string& id) const
 {
   DCLGPSFilter filter;  
-  FGPositioned::List matches = FGPositioned::findAllWithIdent(id, &filter, false);
+  FGPositionedList matches = FGPositioned::findAllWithIdent(id, &filter, false);
   if (matches.empty()) {
     return NULL;
   }
@@ -1390,7 +1390,7 @@ FGPositioned* DCLGPS::FindTypedFirstById(const string& id, FGPositioned::Type ty
   multi = false;
   FGPositioned::TypeFilter filter(ty);
   
-  FGPositioned::List matches =
+  FGPositionedList matches =
     FGPositioned::findAllWithIdent(id, &filter, exact);
   if (matches.empty()) {
     return NULL;
diff --git a/src/Instrumentation/gps.cxx b/src/Instrumentation/gps.cxx
index 22094602b..cb9ef1a89 100644
--- a/src/Instrumentation/gps.cxx
+++ b/src/Instrumentation/gps.cxx
@@ -1596,7 +1596,7 @@ void GPS::defineWaypoint()
     
 // check for duplicate idents
   FGPositioned::TypeFilter f(FGPositioned::WAYPOINT);
-  FGPositioned::List dups = FGPositioned::findAllWithIdent(ident, &f);
+  FGPositionedList dups = FGPositioned::findAllWithIdent(ident, &f);
   if (!dups.empty()) {
     SG_LOG(SG_INSTR, SG_WARN, "GPS:defineWaypoint: non-unique waypoint identifier, ho-hum");
   }
diff --git a/src/Instrumentation/gps.hxx b/src/Instrumentation/gps.hxx
index bde58dd55..c284d87b8 100644
--- a/src/Instrumentation/gps.hxx
+++ b/src/Instrumentation/gps.hxx
@@ -20,7 +20,6 @@
 // forward decls
 class SGRoute;
 class FGRouteMgr;
-class FGAirport;
 class GPSListener;
 
 /**
@@ -363,7 +362,7 @@ private:
     std::string _searchQuery;
     FGPositioned::Type _searchType;
     bool _searchExact;
-    FGPositioned::List _searchResults;
+    FGPositionedList _searchResults;
     bool _searchIsRoute; ///< set if 'search' is actually the current route
     bool _searchHasNext; ///< is there a result after this one?
     bool _searchNames; ///< set if we're searching names instead of idents
diff --git a/src/Navaids/NavDataCache.cxx b/src/Navaids/NavDataCache.cxx
index 2010743cd..d2ac4290e 100644
--- a/src/Navaids/NavDataCache.cxx
+++ b/src/Navaids/NavDataCache.cxx
@@ -853,7 +853,7 @@ public:
     return r;
   }
   
-  FGPositioned::List findAllByString(const string& s, const string& column,
+  FGPositionedList findAllByString(const string& s, const string& column,
                                      FGPositioned::Filter* filter, bool exact)
   {
     string query = s;
@@ -879,7 +879,7 @@ public:
       sqlite3_bind_int(stmt, 3, filter->maxType());
     }
     
-    FGPositioned::List result;
+    FGPositionedList result;
   // run the prepared SQL
     while (stepSelect(stmt))
     {
@@ -1052,7 +1052,7 @@ FGPositioned* NavDataCache::NavDataCachePrivate::loadById(sqlite3_int64 rowid)
     case FGPositioned::MOBILE_TACAN:
     {
       if (aptId > 0) {
-        FGAirport* apt = (FGAirport*) outer->loadById(aptId);
+        FGAirport* apt = FGPositioned::loadById<FGAirport>(aptId);
         if (apt->validateILSData()) {
           SG_LOG(SG_NAVCACHE, SG_INFO, "re-loaded ILS data for " << apt->ident());
           // queried data above is probably invalid, force us to go around again
@@ -1473,7 +1473,7 @@ void NavDataCache::abortTransaction()
   d->transactionAborted = true;
 }
 
-FGPositioned* NavDataCache::loadById(PositionedID rowid)
+FGPositionedRef NavDataCache::loadById(PositionedID rowid)
 {
   if (rowid == 0) {
     return NULL;
@@ -1673,20 +1673,26 @@ void NavDataCache::setAirportMetar(const string& icao, bool hasMetar)
   d->execUpdate(d->setAirportMetar);
 }
 
-FGPositioned::List NavDataCache::findAllWithIdent(const string& s,
-                                                  FGPositioned::Filter* filter, bool exact)
+//------------------------------------------------------------------------------
+FGPositionedList NavDataCache::findAllWithIdent( const string& s,
+                                                 FGPositioned::Filter* filter,
+                                                 bool exact )
 {
   return d->findAllByString(s, "ident", filter, exact);
 }
 
-FGPositioned::List NavDataCache::findAllWithName(const string& s,
-                                                  FGPositioned::Filter* filter, bool exact)
+//------------------------------------------------------------------------------
+FGPositionedList NavDataCache::findAllWithName( const string& s,
+                                                FGPositioned::Filter* filter,
+                                                bool exact )
 {
   return d->findAllByString(s, "name", filter, exact);
 }
-  
-FGPositionedRef NavDataCache::findClosestWithIdent(const string& aIdent,
-                                                   const SGGeod& aPos, FGPositioned::Filter* aFilter)
+
+//------------------------------------------------------------------------------
+FGPositionedRef NavDataCache::findClosestWithIdent( const string& aIdent,
+                                                    const SGGeod& aPos,
+                                                    FGPositioned::Filter* aFilter )
 {
   sqlite_bind_stdstring(d->findClosestWithIdent, 1, aIdent);
   if (aFilter) {
diff --git a/src/Navaids/NavDataCache.hxx b/src/Navaids/NavDataCache.hxx
index 93ef318c7..e0f8ed84c 100644
--- a/src/Navaids/NavDataCache.hxx
+++ b/src/Navaids/NavDataCache.hxx
@@ -90,7 +90,7 @@ public:
    * This may be trivial if the object is previously loaded, or require actual
    * disk IO.
    */
-  FGPositioned* loadById(PositionedID guid);
+  FGPositionedRef loadById(PositionedID guid);
   
   PositionedID insertAirport(FGPositioned::Type ty, const std::string& ident,
                              const std::string& name);
@@ -141,13 +141,16 @@ public:
    */
   void updatePosition(PositionedID item, const SGGeod &pos);
   
-  FGPositioned::List findAllWithIdent(const std::string& ident,
-                                      FGPositioned::Filter* filter, bool exact);
-  FGPositioned::List findAllWithName(const std::string& ident,
-                                      FGPositioned::Filter* filter, bool exact);
+  FGPositionedList findAllWithIdent( const std::string& ident,
+                                     FGPositioned::Filter* filter,
+                                     bool exact );
+  FGPositionedList findAllWithName( const std::string& ident,
+                                    FGPositioned::Filter* filter,
+                                    bool exact );
   
-  FGPositionedRef findClosestWithIdent(const std::string& aIdent,
-                                      const SGGeod& aPos, FGPositioned::Filter* aFilter);
+  FGPositionedRef findClosestWithIdent( const std::string& aIdent,
+                                        const SGGeod& aPos,
+                                        FGPositioned::Filter* aFilter );
   
 
   /**
diff --git a/src/Navaids/PositionedOctree.cxx b/src/Navaids/PositionedOctree.cxx
index 2dbae4089..ae6ee5ec4 100644
--- a/src/Navaids/PositionedOctree.cxx
+++ b/src/Navaids/PositionedOctree.cxx
@@ -255,7 +255,7 @@ int Branch::childMask() const
   return result;
 }
 
-bool findNearestN(const SGVec3d& aPos, unsigned int aN, double aCutoffM, FGPositioned::Filter* aFilter, FGPositioned::List& aResults, int aCutoffMsec)
+bool findNearestN(const SGVec3d& aPos, unsigned int aN, double aCutoffM, FGPositioned::Filter* aFilter, FGPositionedList& aResults, int aCutoffMsec)
 {
   aResults.clear();
   FindNearestPQueue pq;
@@ -296,7 +296,7 @@ bool findNearestN(const SGVec3d& aPos, unsigned int aN, double aCutoffM, FGPosit
   return !pq.empty();
 }
 
-bool findAllWithinRange(const SGVec3d& aPos, double aRangeM, FGPositioned::Filter* aFilter, FGPositioned::List& aResults, int aCutoffMsec)
+bool findAllWithinRange(const SGVec3d& aPos, double aRangeM, FGPositioned::Filter* aFilter, FGPositionedList& aResults, int aCutoffMsec)
 {
   aResults.clear();
   FindNearestPQueue pq;
diff --git a/src/Navaids/PositionedOctree.hxx b/src/Navaids/PositionedOctree.hxx
index b2100718b..167f37a0d 100644
--- a/src/Navaids/PositionedOctree.hxx
+++ b/src/Navaids/PositionedOctree.hxx
@@ -236,8 +236,8 @@ namespace Octree
     mutable bool childrenLoaded;
   };
 
-  bool findNearestN(const SGVec3d& aPos, unsigned int aN, double aCutoffM, FGPositioned::Filter* aFilter, FGPositioned::List& aResults, int aCutoffMsec);
-  bool findAllWithinRange(const SGVec3d& aPos, double aRangeM, FGPositioned::Filter* aFilter, FGPositioned::List& aResults, int aCutoffMsec);
+  bool findNearestN(const SGVec3d& aPos, unsigned int aN, double aCutoffM, FGPositioned::Filter* aFilter, FGPositionedList& aResults, int aCutoffMsec);
+  bool findAllWithinRange(const SGVec3d& aPos, double aRangeM, FGPositioned::Filter* aFilter, FGPositionedList& aResults, int aCutoffMsec);
 } // of namespace Octree
 
   
diff --git a/src/Navaids/navdb.cxx b/src/Navaids/navdb.cxx
index 6a1961ae0..1a3613c15 100644
--- a/src/Navaids/navdb.cxx
+++ b/src/Navaids/navdb.cxx
@@ -181,7 +181,7 @@ static PositionedID readNavFromStream(std::istream& aStream,
   if ((type >= FGPositioned::ILS) && (type <= FGPositioned::GS)) {
     arp = cache->findAirportRunway(name);
     if (arp.second) {
-      runway = static_cast<FGRunway*>(cache->loadById(arp.second));
+      runway = FGPositioned::loadById<FGRunway>(arp.second);
       assert(runway);
 #if 0
       // code is disabled since it's causing some problems, see
diff --git a/src/Navaids/navlist.cxx b/src/Navaids/navlist.cxx
index 7d5e8c123..822391e04 100644
--- a/src/Navaids/navlist.cxx
+++ b/src/Navaids/navlist.cxx
@@ -37,6 +37,7 @@
 
 #include <Airports/runways.hxx>
 #include <Navaids/NavDataCache.hxx>
+#include <Navaids/navrecord.hxx>
 
 using std::string;
 
@@ -184,8 +185,9 @@ FGNavList::TypeFilter* FGNavList::carrierFilter()
   return &tf;
 }
 
-FGNavRecord *FGNavList::findByFreq( double freq, const SGGeod& position,
-                                   TypeFilter* filter)
+FGNavRecordRef FGNavList::findByFreq( double freq,
+                                      const SGGeod& position,
+                                      TypeFilter* filter )
 {
   flightgear::NavDataCache* cache = flightgear::NavDataCache::instance();
   int freqKhz = static_cast<int>(freq * 100 + 0.5);
@@ -200,7 +202,7 @@ FGNavRecord *FGNavList::findByFreq( double freq, const SGGeod& position,
     = FG_NAV_MAX_RANGE*SG_NM_TO_METER*FG_NAV_MAX_RANGE*SG_NM_TO_METER;
     
   BOOST_FOREACH(PositionedID id, stations) {
-    FGNavRecord* station = (FGNavRecord*) cache->loadById(id);
+    FGNavRecordRef station = FGPositioned::loadById<FGNavRecord>(id);
     if (!filter->pass(station)) {
       continue;
     }
@@ -221,7 +223,7 @@ FGNavRecord *FGNavList::findByFreq( double freq, const SGGeod& position,
   return NULL;
 }
 
-FGNavRecord *FGNavList::findByFreq( double freq, TypeFilter* filter)
+FGNavRecordRef FGNavList::findByFreq(double freq, TypeFilter* filter)
 {
   flightgear::NavDataCache* cache = flightgear::NavDataCache::instance();
   int freqKhz = static_cast<int>(freq * 100 + 0.5);
@@ -231,7 +233,7 @@ FGNavRecord *FGNavList::findByFreq( double freq, TypeFilter* filter)
   }
 
   BOOST_FOREACH(PositionedID id, stations) {
-    FGNavRecord* station = (FGNavRecord*) cache->loadById(id);
+    FGNavRecordRef station = FGPositioned::loadById<FGNavRecord>(id);
     if (filter->pass(station)) {
       return station;
     }
@@ -250,7 +252,7 @@ nav_list_type FGNavList::findAllByFreq( double freq, const SGGeod& position,
   PositionedIDVec ids(cache->findNavaidsByFreq(freqKhz, position, filter));
   
   BOOST_FOREACH(PositionedID id, ids) {
-    FGNavRecord* station = (FGNavRecord*) cache->loadById(id);
+    FGNavRecordRef station = FGPositioned::loadById<FGNavRecord>(id);
     if (!filter->pass(station)) {
       continue;
     }
@@ -267,7 +269,7 @@ nav_list_type FGNavList::findByIdentAndFreq(const string& ident, const double fr
   nav_list_type reply;
   int f = (int)(freq*100.0 + 0.5);
   
-  FGPositioned::List stations = FGPositioned::findAllWithIdent(ident, filter);
+  FGPositionedList stations = FGPositioned::findAllWithIdent(ident, filter);
   BOOST_FOREACH(FGPositionedRef ref, stations) {
     FGNavRecord* nav = static_cast<FGNavRecord*>(ref.ptr());
     if ( f <= 0.0 || nav->get_freq() == f) {
diff --git a/src/Navaids/navlist.hxx b/src/Navaids/navlist.hxx
index 8f9204b71..d2db76cbf 100644
--- a/src/Navaids/navlist.hxx
+++ b/src/Navaids/navlist.hxx
@@ -92,7 +92,7 @@ public:
       * that there will be multiple stations with matching frequencies
       * so a position must be specified.
       */
-    static FGNavRecord *findByFreq( double freq, const SGGeod& position,
+    static FGNavRecordRef findByFreq( double freq, const SGGeod& position,
                                    TypeFilter* filter = NULL);
 
     /**
@@ -100,7 +100,7 @@ public:
      * mobile TACANs which have no valid position. The first match is
      * returned only.
      */
-    static FGNavRecord *findByFreq( double freq, TypeFilter* filter = NULL);
+    static FGNavRecordRef findByFreq( double freq, TypeFilter* filter = NULL);
   
     static nav_list_type findAllByFreq( double freq, const SGGeod& position,
                                        TypeFilter* filter = NULL);
diff --git a/src/Navaids/navrecord.cxx b/src/Navaids/navrecord.cxx
index dc5cf7ab2..d9b3a18d6 100644
--- a/src/Navaids/navrecord.cxx
+++ b/src/Navaids/navrecord.cxx
@@ -40,7 +40,6 @@
 #include <Airports/airport.hxx>
 #include <Airports/xmlloader.hxx>
 #include <Main/fg_props.hxx>
-#include <Navaids/NavDataCache.hxx>
 
 FGNavRecord::FGNavRecord(PositionedID aGuid, Type aTy, const std::string& aIdent,
   const std::string& aName, const SGGeod& aPos,
@@ -55,9 +54,9 @@ FGNavRecord::FGNavRecord(PositionedID aGuid, Type aTy, const std::string& aIdent
 { 
 }
 
-FGRunway* FGNavRecord::runway() const
+FGRunwayRef FGNavRecord::runway() const
 {
-  return (FGRunway*) flightgear::NavDataCache::instance()->loadById(mRunway);
+  return loadById<FGRunway>(mRunway);
 }
 
 double FGNavRecord::localizerWidth() const
diff --git a/src/Navaids/navrecord.hxx b/src/Navaids/navrecord.hxx
index 8710b9aa3..cf9e69579 100644
--- a/src/Navaids/navrecord.hxx
+++ b/src/Navaids/navrecord.hxx
@@ -76,7 +76,7 @@ public:
   /**
    * Retrieve the runway this navaid is associated with (for ILS/LOC/GS)
    */
-  FGRunway* runway() const;
+  FGRunwayRef runway() const;
   
   /**
    * return the localizer width, in degrees
diff --git a/src/Navaids/positioned.cxx b/src/Navaids/positioned.cxx
index e5227a2cc..bdc7d17a5 100644
--- a/src/Navaids/positioned.cxx
+++ b/src/Navaids/positioned.cxx
@@ -75,7 +75,7 @@ FGPositioned::createUserWaypoint(const std::string& aIdent, const SGGeod& aPos)
 {
   NavDataCache* cache = NavDataCache::instance();
   TypeFilter filter(WAYPOINT);
-  FGPositioned::List existing = cache->findAllWithIdent(aIdent, &filter, true);
+  FGPositionedList existing = cache->findAllWithIdent(aIdent, &filter, true);
   if (!existing.empty()) {
     SG_LOG(SG_NAVAID, SG_WARN, "attempt to insert duplicate WAYPOINT:" << aIdent);
     return existing.front().ptr();
@@ -216,7 +216,8 @@ FGPositioned::findFirstWithIdent(const std::string& aIdent, Filter* aFilter)
     return NULL;
   }
   
-  List r = NavDataCache::instance()->findAllWithIdent(aIdent, aFilter, true);
+  FGPositionedList r =
+    NavDataCache::instance()->findAllWithIdent(aIdent, aFilter, true);
   if (r.empty()) {
     return NULL;
   }
@@ -224,37 +225,37 @@ FGPositioned::findFirstWithIdent(const std::string& aIdent, Filter* aFilter)
   return r.front();
 }
 
-FGPositioned::List
+FGPositionedList
 FGPositioned::findWithinRange(const SGGeod& aPos, double aRangeNm, Filter* aFilter)
 {
   validateSGGeod(aPos);
 
-  List result;
+  FGPositionedList result;
   Octree::findAllWithinRange(SGVec3d::fromGeod(aPos), 
     aRangeNm * SG_NM_TO_METER, aFilter, result, 0xffffff);
   return result;
 }
 
-FGPositioned::List
+FGPositionedList
 FGPositioned::findWithinRangePartial(const SGGeod& aPos, double aRangeNm, Filter* aFilter, bool& aPartial)
 {
   validateSGGeod(aPos);
   
   int limitMsec = 32;
-  List result;
+  FGPositionedList result;
   aPartial = Octree::findAllWithinRange(SGVec3d::fromGeod(aPos),
                              aRangeNm * SG_NM_TO_METER, aFilter, result,
                                         limitMsec);
   return result;
 }
 
-FGPositioned::List
+FGPositionedList
 FGPositioned::findAllWithIdent(const std::string& aIdent, Filter* aFilter, bool aExact)
 {
   return NavDataCache::instance()->findAllWithIdent(aIdent, aFilter, aExact);
 }
 
-FGPositioned::List
+FGPositionedList
 FGPositioned::findAllWithName(const std::string& aName, Filter* aFilter, bool aExact)
 {
   return NavDataCache::instance()->findAllWithName(aName, aFilter, aExact);
@@ -265,7 +266,7 @@ FGPositioned::findClosest(const SGGeod& aPos, double aCutoffNm, Filter* aFilter)
 {
   validateSGGeod(aPos);
   
-  List l(findClosestN(aPos, 1, aCutoffNm, aFilter));
+  FGPositionedList l(findClosestN(aPos, 1, aCutoffNm, aFilter));
   if (l.empty()) {
     return NULL;
   }
@@ -274,23 +275,23 @@ FGPositioned::findClosest(const SGGeod& aPos, double aCutoffNm, Filter* aFilter)
   return l.front();
 }
 
-FGPositioned::List
+FGPositionedList
 FGPositioned::findClosestN(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter)
 {
   validateSGGeod(aPos);
   
-  List result;
+  FGPositionedList result;
   int limitMsec = 0xffff;
   Octree::findNearestN(SGVec3d::fromGeod(aPos), aN, aCutoffNm * SG_NM_TO_METER, aFilter, result, limitMsec);
   return result;
 }
 
-FGPositioned::List
+FGPositionedList
 FGPositioned::findClosestNPartial(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter, bool &aPartial)
 {
     validateSGGeod(aPos);
     
-    List result;
+    FGPositionedList result;
     int limitMsec = 32;
     aPartial = Octree::findNearestN(SGVec3d::fromGeod(aPos), aN, aCutoffNm * SG_NM_TO_METER, aFilter, result,
                         limitMsec);
@@ -298,14 +299,14 @@ FGPositioned::findClosestNPartial(const SGGeod& aPos, unsigned int aN, double aC
 }
 
 void
-FGPositioned::sortByRange(List& aResult, const SGGeod& aPos)
+FGPositioned::sortByRange(FGPositionedList& aResult, const SGGeod& aPos)
 {
   validateSGGeod(aPos);
   
   SGVec3d cartPos(SGVec3d::fromGeod(aPos));
 // computer ordering values
   Octree::FindNearestResults r;
-  List::iterator it = aResult.begin(), lend = aResult.end();
+  FGPositionedList::iterator it = aResult.begin(), lend = aResult.end();
   for (; it != lend; ++it) {
     double d2 = distSqr((*it)->cart(), cartPos);
     r.push_back(Octree::OrderedPositioned(*it, d2));
@@ -328,7 +329,7 @@ void FGPositioned::modifyPosition(const SGGeod& newPos)
 }
 
 //------------------------------------------------------------------------------
-FGPositioned* FGPositioned::loadByIdImpl(PositionedID id)
+FGPositionedRef FGPositioned::loadByIdImpl(PositionedID id)
 {
   return flightgear::NavDataCache::instance()->loadById(id);
 }
diff --git a/src/Navaids/positioned.hxx b/src/Navaids/positioned.hxx
index 42476d854..7f852a2b8 100644
--- a/src/Navaids/positioned.hxx
+++ b/src/Navaids/positioned.hxx
@@ -32,6 +32,7 @@
 
 class FGPositioned;
 typedef SGSharedPtr<FGPositioned> FGPositionedRef;
+typedef std::vector<FGPositionedRef> FGPositionedList;
 
 typedef int64_t PositionedID;
 typedef std::vector<PositionedID> PositionedIDVec;
@@ -91,8 +92,6 @@ public:
     LAST_TYPE
   } Type;
 
-  typedef std::vector<FGPositionedRef> List;
-  
   virtual ~FGPositioned();
   
   Type type() const
@@ -179,9 +178,9 @@ public:
     Type mMinType, mMaxType;
   };
   
-  static List findWithinRange(const SGGeod& aPos, double aRangeNm, Filter* aFilter = NULL);
+  static FGPositionedList findWithinRange(const SGGeod& aPos, double aRangeNm, Filter* aFilter = NULL);
   
-  static List findWithinRangePartial(const SGGeod& aPos, double aRangeNm, Filter* aFilter, bool& aPartial);
+  static FGPositionedList findWithinRangePartial(const SGGeod& aPos, double aRangeNm, Filter* aFilter, bool& aPartial);
         
   static FGPositionedRef findClosestWithIdent(const std::string& aIdent, const SGGeod& aPos, Filter* aFilter = NULL);
 
@@ -191,17 +190,17 @@ public:
    * Find all items with the specified ident
    * @param aFilter - optional filter on items
    */
-  static List findAllWithIdent(const std::string& aIdent, Filter* aFilter = NULL, bool aExact = true);
+  static FGPositionedList findAllWithIdent(const std::string& aIdent, Filter* aFilter = NULL, bool aExact = true);
   
   /**
    * As above, but searches names instead of idents
    */
-  static List findAllWithName(const std::string& aName, Filter* aFilter = NULL, bool aExact = true);
+  static FGPositionedList findAllWithName(const std::string& aName, Filter* aFilter = NULL, bool aExact = true);
   
   /**
    * Sort an FGPositionedList by distance from a position
    */
-  static void sortByRange(List&, const SGGeod& aPos);
+  static void sortByRange(FGPositionedList&, const SGGeod& aPos);
   
   /**
    * Find the closest item to a position, which pass the specified filter
@@ -223,53 +222,31 @@ public:
    * @param aN - number of matches to find
    * @param aCutoffNm - maximum distance to search within, in nautical miles
    */
-  static List findClosestN(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter = NULL);
+  static FGPositionedList findClosestN(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter = NULL);
     
   /**
    * Same as above, but with a time-bound in msec too.
    */
-  static List findClosestNPartial(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter,
+  static FGPositionedList findClosestNPartial(const SGGeod& aPos, unsigned int aN, double aCutoffNm, Filter* aFilter,
                            bool& aPartial);
-    
-  /**
-   * Map a candidate type string to a real type. Returns INVALID if the string
-   * does not correspond to a defined type.
-   */
-  static Type typeFromName(const std::string& aName);
-  
-  /**
-   * Map a type to a human-readable string
-   */
-  static const char* nameForType(Type aTy);
-  
-  static FGPositioned* createUserWaypoint(const std::string& aIdent, const SGGeod& aPos);
-  static void deleteUserWaypoint(const std::string& aIdent);
-protected:
-  friend class flightgear::NavDataCache;
   
-  FGPositioned(PositionedID aGuid, Type ty, const std::string& aIdent, const SGGeod& aPos);
-    
-  void modifyPosition(const SGGeod& newPos);
-
-  static FGPositioned* loadByIdImpl(PositionedID id);
-
   template<class T>
-  static T* loadById(PositionedID id)
+  static SGSharedPtr<T> loadById(PositionedID id)
   {
-    return static_cast<T*>( loadByIdImpl(id) );
+    return static_pointer_cast<T>( loadByIdImpl(id) );
   }
 
   template<class T>
-  static T* loadById(const PositionedIDVec& id_vec, size_t index)
+  static SGSharedPtr<T> loadById(const PositionedIDVec& id_vec, size_t index)
   {
     assert(index >= 0 && index < id_vec.size());
     return loadById<T>(id_vec[index]);
   }
 
   template<class T>
-  static std::vector<T*> loadAllById(const PositionedIDVec& id_vec)
+  static std::vector<SGSharedPtr<T> > loadAllById(const PositionedIDVec& id_vec)
   {
-    std::vector<T*> vec(id_vec.size());
+    std::vector<SGSharedPtr<T> > vec(id_vec.size());
 
     for(size_t i = 0; i < id_vec.size(); ++i)
       vec[i] = loadById<T>(id_vec[i]);
@@ -277,6 +254,28 @@ protected:
     return vec;
   }
 
+  /**
+   * Map a candidate type string to a real type. Returns INVALID if the string
+   * does not correspond to a defined type.
+   */
+  static Type typeFromName(const std::string& aName);
+
+  /**
+   * Map a type to a human-readable string
+   */
+  static const char* nameForType(Type aTy);
+
+  static FGPositioned* createUserWaypoint(const std::string& aIdent, const SGGeod& aPos);
+  static void deleteUserWaypoint(const std::string& aIdent);
+protected:
+  friend class flightgear::NavDataCache;
+
+  FGPositioned(PositionedID aGuid, Type ty, const std::string& aIdent, const SGGeod& aPos);
+
+  void modifyPosition(const SGGeod& newPos);
+
+  static FGPositionedRef loadByIdImpl(PositionedID id);
+
   const PositionedID mGuid;
   const SGGeod mPosition;
   const SGVec3d mCart;
diff --git a/src/Scripting/NasalPositioned.cxx b/src/Scripting/NasalPositioned.cxx
index eb572973e..d50ca083f 100644
--- a/src/Scripting/NasalPositioned.cxx
+++ b/src/Scripting/NasalPositioned.cxx
@@ -1051,7 +1051,7 @@ static naRef f_findAirportsWithinRange(naContext c, naRef me, int argc, naRef* a
   
   naRef r = naNewVector(c);
   
-  FGPositioned::List apts = FGPositioned::findWithinRange(pos, rangeNm, &filter);
+  FGPositionedList apts = FGPositioned::findWithinRange(pos, rangeNm, &filter);
   FGPositioned::sortByRange(apts, pos);
   
   BOOST_FOREACH(FGPositionedRef a, apts) {
@@ -1077,7 +1077,7 @@ static naRef f_findAirportsByICAO(naContext c, naRef me, int argc, naRef* args)
   
   naRef r = naNewVector(c);
   
-  FGPositioned::List apts = FGPositioned::findAllWithIdent(prefix, &filter, false);
+  FGPositionedList apts = FGPositioned::findAllWithIdent(prefix, &filter, false);
   
   BOOST_FOREACH(FGPositionedRef a, apts) {
     FGAirport* apt = (FGAirport*) a.get();
@@ -1483,7 +1483,7 @@ static naRef f_findNavaidsWithinRange(naContext c, naRef me, int argc, naRef* ar
   
   naRef r = naNewVector(c);
   FGNavList::TypeFilter filter(type);
-  FGPositioned::List navs = FGPositioned::findWithinRange(pos, rangeNm, &filter);
+  FGPositionedList navs = FGPositioned::findWithinRange(pos, rangeNm, &filter);
   FGPositioned::sortByRange(navs, pos);
   
   BOOST_FOREACH(FGPositionedRef a, navs) {
@@ -1588,7 +1588,7 @@ static naRef f_findFixesByIdent(naContext c, naRef me, int argc, naRef* args)
   naRef r = naNewVector(c);
   
   FGPositioned::TypeFilter filter(FGPositioned::FIX);
-  FGPositioned::List fixes = FGPositioned::findAllWithIdent(ident, &filter);
+  FGPositionedList fixes = FGPositioned::findAllWithIdent(ident, &filter);
   FGPositioned::sortByRange(fixes, pos);
   
   BOOST_FOREACH(FGPositionedRef f, fixes) {
diff --git a/src/Scripting/NasalPositioned_cppbind.cxx b/src/Scripting/NasalPositioned_cppbind.cxx
index aab7489ea..2191ecd30 100644
--- a/src/Scripting/NasalPositioned_cppbind.cxx
+++ b/src/Scripting/NasalPositioned_cppbind.cxx
@@ -38,6 +38,7 @@
 
 #include <Airports/airport.hxx>
 #include <Airports/dynamics.hxx>
+#include <Airports/pavement.hxx>
 #include <ATC/CommStation.hxx>
 #include <Main/globals.hxx>
 #include <Navaids/NavDataCache.hxx>
@@ -51,30 +52,6 @@ typedef nasal::Ghost<FGAirportRef> NasalAirport;
 typedef nasal::Ghost<flightgear::CommStationRef> NasalCommStation;
 typedef nasal::Ghost<FGNavRecordRef> NasalNavRecord;
 
-//------------------------------------------------------------------------------
-naRef to_nasal_helper(naContext c, FGPositioned* positioned)
-{
-  return NasalPositioned::create(c, positioned);
-}
-
-//------------------------------------------------------------------------------
-naRef to_nasal_helper(naContext c, FGPavement* rwy)
-{
-  return NasalPositioned::create(c, (FGPositioned*)rwy);
-}
-
-//------------------------------------------------------------------------------
-naRef to_nasal_helper(naContext c, FGRunwayBase* rwy)
-{
-  return NasalPositioned::create(c, (FGPositioned*)rwy);
-}
-
-//------------------------------------------------------------------------------
-naRef to_nasal_helper(naContext c, FGParking* parking)
-{
-  return NasalParking::create(c, parking);
-}
-
 //------------------------------------------------------------------------------
 naRef to_nasal_helper(naContext c, flightgear::SID* sid)
 {
@@ -96,12 +73,6 @@ naRef to_nasal_helper(naContext c, flightgear::Approach* iap)
   return nasal::to_nasal(c, iap->ident());
 }
 
-//------------------------------------------------------------------------------
-naRef to_nasal_helper(naContext c, FGAirport* apt)
-{
-  return NasalAirport::create(c, apt);
-}
-
 //------------------------------------------------------------------------------
 naRef to_nasal_helper(naContext c, const SGGeod& pos)
 {
@@ -125,7 +96,7 @@ static naRef f_navaid_course(naContext, FGNavRecord& nav)
 }
 
 //------------------------------------------------------------------------------
-static FGRunwayBase* f_airport_runway(FGAirport& apt, std::string ident)
+static FGRunwayBaseRef f_airport_runway(FGAirport& apt, std::string ident)
 {
   boost::to_upper(ident);
 
@@ -139,7 +110,7 @@ static FGRunwayBase* f_airport_runway(FGAirport& apt, std::string ident)
 
 //------------------------------------------------------------------------------
 template<class T, class C1, class C2>
-std::vector<T> extract( const std::vector<C1*>& in,
+std::vector<T> extract( const std::vector<C1>& in,
                         T (C2::*getter)() const )
 {
   std::vector<T> ret(in.size());
@@ -349,10 +320,8 @@ static SGGeod getPosition(nasal::CallContext& ctx)
 // airportinfo(<type>);                 type := ("airport"|"seaport"|"heliport")
 // airportinfo()                        same as  airportinfo("airport")
 // airportinfo(<lat>, <lon> [, <type>]);
-static naRef f_airportinfo(naContext c, naRef me, int argc, naRef* args)
+static naRef f_airportinfo(nasal::CallContext ctx)
 {
-  nasal::CallContext ctx(c, argc, args);
-
   SGGeod pos = getPosition(ctx);
 
   if( ctx.argc > 1 )
@@ -375,18 +344,15 @@ static naRef f_airportinfo(naContext c, naRef me, int argc, naRef* args)
 /**
  * findAirportsWithinRange([<position>,] <range-nm> [, type])
  */
-static naRef f_findAirportsWithinRange(naContext c, naRef me, int argc, naRef* args)
+static naRef f_findAirportsWithinRange(nasal::CallContext ctx)
 {
-  nasal::CallContext ctx(c, argc, args);
-
   SGGeod pos = getPosition(ctx);
   double range_nm = ctx.requireArg<double>(0);
 
   FGAirport::TypeRunwayFilter filter; // defaults to airports only
   filter.fromTypeString( ctx.getArg<std::string>(1) );
 
-  FGPositioned::List apts =
-    FGPositioned::findWithinRange(pos, range_nm, &filter);
+  FGPositionedList apts = FGPositioned::findWithinRange(pos, range_nm, &filter);
   FGPositioned::sortByRange(apts, pos);
 
   return ctx.to_nasal(apts);
@@ -395,9 +361,8 @@ static naRef f_findAirportsWithinRange(naContext c, naRef me, int argc, naRef* a
 /**
  * findAirportsByICAO(<ident/prefix> [, type])
  */
-static naRef f_findAirportsByICAO(naContext c, naRef me, int argc, naRef* args)
+static naRef f_findAirportsByICAO(nasal::CallContext ctx)
 {
-  nasal::CallContext ctx(c, argc, args);
   std::string prefix = ctx.requireArg<std::string>(0);
 
   FGAirport::TypeRunwayFilter filter; // defaults to airports only
@@ -418,10 +383,8 @@ static naRef f_findAirportsByICAO(naContext c, naRef me, int argc, naRef* args)
 // navinfo("vor", "HAM") return all vor who's name start with "HAM"
 //navinfo(34,48,"vor","HAM") return all vor who's name start with "HAM"
 //                           sorted by distance relative to lat=34, lon=48
-static naRef f_navinfo(naContext c, naRef me, int argc, naRef* args)
+static naRef f_navinfo(nasal::CallContext ctx)
 {
-  nasal::CallContext ctx(c, argc, args);
-
   SGGeod pos = getPosition(ctx);
   std::string id = ctx.getArg<std::string>(0);
 
@@ -429,24 +392,21 @@ static naRef f_navinfo(naContext c, naRef me, int argc, naRef* args)
   if( filter.fromTypeString(id) )
     id = ctx.getArg<std::string>(1);
   else if( ctx.argc > 1 )
-    naRuntimeError(c, "navinfo() already got an ident");
+    naRuntimeError(ctx.c, "navinfo() already got an ident");
 
   return ctx.to_nasal( FGNavList::findByIdentAndFreq(pos, id, 0.0, &filter) );
 }
 
 //------------------------------------------------------------------------------
-static naRef f_findNavaidsWithinRange(naContext c, naRef me, int argc, naRef* args)
+static naRef f_findNavaidsWithinRange(nasal::CallContext ctx)
 {
-  nasal::CallContext ctx(c, argc, args);
-
   SGGeod pos = getPosition(ctx);
   double range_nm = ctx.requireArg<double>(0);
 
   FGNavList::TypeFilter filter;
   filter.fromTypeString(ctx.getArg<std::string>(0));
 
-  FGPositioned::List navs =
-    FGPositioned::findWithinRange(pos, range_nm, &filter);
+  FGPositionedList navs = FGPositioned::findWithinRange(pos, range_nm, &filter);
   FGPositioned::sortByRange(navs, pos);
 
   return ctx.to_nasal(navs);