featureContext.h

Go to the documentation of this file.

#pragma once

#include <features/attributeConfigParser.h>
#include <features/featureContext.h>
#include <features/featureSet.h>
#include <features/feature.h>
#include <features/pathFeature.h>
#include <features/pathFinder.h>
#include <features/obstacleFeature.h>

#include <vrfutil/consoleCommandManager.h>
#include <vrfutil/terrainInterfaceConfig.h>

#include <boost/scoped_ptr.hpp>
#include <boost/ptr_container/ptr_map.hpp>

#include <tbb/mutex.h>

#include <map>
#include <string>

namespace osg
{
   template<typename T>
   class ref_ptr;
}

namespace osgEarth
{
   class Map;
}

namespace MAKVRinTerra
{
   class DtSharedMemoryFeaturesDebugDrawer;
   class DtFeatureContext;
   class DtFeaturesDebugger;
   class DtUnusedFeatureTileTracker;

   class DT_DLL_features DtFeatureLoader
   {
   public:
      typedef boost::function<DtFeatureSet* (std::string)> FeatureSetCreatorFcn;

      DtFeatureLoader(boost::shared_ptr<DtTerrainInterfaceConfig> config, DtConsoleCommandManager* manager = 0);

      virtual ~DtFeatureLoader();

      static void AddFeatureSetCreator(const std::string& extension, FeatureSetCreatorFcn);
      static DtFeatureSet* CreateFeatureSetFromFile(const std::string& forFile);

      virtual bool loadConfig(std::string file);

      virtual bool loadConfig(std::string file, const DtQuery& schema);

      virtual std::auto_ptr<DtFeatureSet> addFeatureSource(std::string file, bool page=true, 
         std::string makLayerName = "");

      virtual std::auto_ptr<DtFeatureSet> addFeatureSource(
         osg::ref_ptr<osgEarth::Map> map, std::string earthfile, bool page=true);

      virtual std::auto_ptr<DtFeatureSet> addFeatureSource(
         DtFeatureSet* fs, std::string label="", bool page=true);

      void addToDebugger(std::string label, DtFeatureSet*, bool draw = false);

      virtual DtFeatureContext* makeContext(const DtProj& proj);

   private:
      struct Record
      {
         typedef boost::shared_ptr<Record> Ptr;
         typedef std::vector<Ptr> Vector;

         std::auto_ptr<DtFeatureSet> featureSet;
         std::string label;
         bool page;

         Record(DtFeatureSet*, std::string label, bool page);
      };

      boost::shared_ptr<DtTerrainInterfaceConfig> myTerrainInterfaceConfig;
      DtConsoleCommandManager* myConsoleManager;
      boost::shared_ptr<DtAttributeConfigParser> myParser;
      boost::shared_ptr<DtUnusedFeatureTileTracker> myUnusedTracker;
      boost::shared_ptr<DtFeaturesDebugger> myDebugger;
      Record::Vector myRecords;
   };

   class DT_DLL_features DtFeatureContext
   {
   public:
      typedef boost::ptr_map<std::string, DtObstacleFeatureSet>   ObstacleFeatureSetMap;
      typedef boost::ptr_map<std::string, DtPathFinder>           PathFinderMap;

      DtFeatureContext(
         DtFeatureSet*,
         const DtProj&,
         boost::shared_ptr<DtAttributeConfigParser>,
         boost::shared_ptr<DtTerrainInterfaceConfig> config,
         boost::shared_ptr<DtUnusedFeatureTileTracker> = boost::shared_ptr<DtUnusedFeatureTileTracker>(),
         boost::shared_ptr<DtFeaturesDebugger> = boost::shared_ptr<DtFeaturesDebugger>());

      ~DtFeatureContext();

      std::auto_ptr<DtFeatureSet> features();

      std::auto_ptr<DtObstacleFeatureSet> obstacles(const std::string& type);
      std::auto_ptr<DtPathFeatureSet> paths(const std::string& type);
      DtPathFinder& pathFinder(const std::string& type);

      DtFeaturesDebugger& debugger();

      DtQuery findQuery(const std::string& name) const;

      DtProj::CPtr projection() const;

      void cleanUpPathFinders();

   private:
      DtProj::CPtr myProjection;

      boost::scoped_ptr<DtFeatureSet> myFeatures;

      ObstacleFeatureSetMap myObstacleFeatureSets;
      mutable tbb::mutex myObstaclesMutex;

      PathFinderMap myPathFinders;
      mutable tbb::mutex myPathFindersMutex;

      boost::shared_ptr<DtAttributeConfigParser> myAttributeParser;
      boost::shared_ptr<DtTerrainInterfaceConfig> myTerrainInterfaceConfig;

      boost::shared_ptr<DtFeaturesDebugger> myDebugger;
      boost::shared_ptr<DtUnusedFeatureTileTracker> myUnusedTracker;
   };
}