pagingFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/feature.h>
#include <features/featureSet.h>
#include <features/featureGeometry.h>
#include <features/unusedFeatureTileTracker.h>
#include <features/asyncLoadingFeatureSet.h>

#include <tbb/recursive_mutex.h>

namespace MAKVRinTerra
{
   class DtUnusedFeatureTileTracker;

   template <typename F>
   class DT_DLL_features DtPagingFeatureSet : public DtFeatureSetTemplate<F>
   {
   public:
      class DT_DLL_features Tile;
      class DT_DLL_features Grid;
      class DT_DLL_features Leaf;
      class DT_DLL_features LoadingFeatureSet;

      typedef F                                       Feature;
      typedef DtFeatureSetTemplate<F>                 FeatureSet;
      typedef typename FeatureSet::ForEachFunction    ForEachFunction;

      typedef boost::shared_ptr<DtPagingFeatureSet>   Ptr;
      typedef boost::shared_ptr<Tile>                 TilePtr;
      typedef boost::weak_ptr<Tile>                   TileWeakPtr;
      typedef boost::shared_ptr<Grid>                 GridPtr;
      typedef boost::shared_ptr<Leaf>                 LeafPtr;

      typedef std::vector<LeafPtr>                    LeafVector;
      typedef std::vector<TilePtr>                    TileVector;
     
      typedef boost::function<void (const FeatureSet&, DtFeatureGeometry)> Callback;

      explicit DtPagingFeatureSet(TilePtr);

      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      FeatureSet* filter(const DtQuery&, DtLoadType) const;
      DtPagingFeatureSet* clone() const;
      DtQuery schema() const;
      bool loaded(double) const;
      unsigned numberOfFeatures() const;

   protected:
      explicit DtPagingFeatureSet(const DtPagingFeatureSet&);

      TilePtr myTile;
   };

   template <typename F>
   class DtPagingFeatureSet<F>::Tile : private boost::noncopyable
   {
   public:
      virtual void forEachLoadedFeature(
         ForEachFunction, DtWaitType) const = 0;
      virtual void forEachLoadedFeatureParallel(
         ForEachFunction, DtWaitType) const = 0;

      virtual void getAllLoadedTileGeometries(
         DtFeatureGeometry::GeometryVector&) const = 0;

      virtual TilePtr getTiles(
         LeafVector&, boost::optional<DtFeatureGeometry>) = 0;

      virtual bool loaded(double) const = 0;
      virtual unsigned numberOfFeatures() const = 0;

      const DtProj::Bounds& bounds() const;
      DtFeatureGeometry::Area tileGeometry() const;
      const FeatureSet& input() const;

      DtProj::Bounds computeParentBounds() const;

      GridPtr parent() const;

      DtQuery schema() const { return mySchema; }

   protected:
      struct GlobalInfo
      {
         typedef boost::shared_ptr<GlobalInfo> Ptr;
         typedef typename DtQueueLoadingFeatureSet<F>::Queue Queue;
         
         DtUnusedFeatureTileTracker::Ptr myUnusedTileTracker;
         boost::scoped_ptr<FeatureSet> inputFeatureSet;
         Callback loadcallback;
         Callback unloadcallback;
         boost::shared_ptr<Queue> myTaskQueue;

         GlobalInfo(FeatureSet*, DtUnusedFeatureTileTracker::Ptr,
            Callback load, Callback unload, unsigned maxTasks);
      };

      Tile(GridPtr parent, unsigned xindex, unsigned yindex);
      Tile(typename GlobalInfo::Ptr, const DtProj::Bounds&);
      explicit Tile(TilePtr child);

      const typename GlobalInfo::Ptr myInfo;

   protected:
      GridPtr myParent;

      DtProj::Bounds myBounds;
      DtFeatureGeometry::Area myTileGeometry;
      DtQuery mySchema;
   };

   template <typename F>
   class DtPagingFeatureSet<F>::Grid
      : public DtPagingFeatureSet<F>::Tile
      , public boost::enable_shared_from_this<typename DtPagingFeatureSet<F>::Grid>
   {
   public:      
      void forEachLoadedFeature(
         ForEachFunction, DtWaitType) const;
      void forEachLoadedFeatureParallel(
         ForEachFunction, DtWaitType) const;
      void getAllLoadedTileGeometries(DtFeatureGeometry::GeometryVector&) const;
      TilePtr getTiles(
         LeafVector&, boost::optional<DtFeatureGeometry>);

      TilePtr getSubtile(unsigned x, unsigned y);

      bool loaded(double) const;
      unsigned numberOfFeatures() const;

      DtProj::Bounds computeSubtileBounds(unsigned xindex, unsigned yindex) const;

      Grid(FeatureSet* input, const DtProj::Bounds&, unsigned level,
         Callback loadCallback = Callback(),
         Callback unloadCallback = Callback(),
         DtUnusedFeatureTileTracker::Ptr tracker = DtUnusedFeatureTileTracker::Ptr(),
         unsigned maxTasks = 0);

      Grid(TilePtr child, unsigned level);

   private:
      struct ParallelCaller;

      Grid(GridPtr parent, unsigned xindex, unsigned yindex);

      mutable tbb::mutex myMutex;
      const unsigned myLevel;
      TileWeakPtr mySubtiles[3][3];
   };

   template <typename F>
   class DtPagingFeatureSet<F>::Leaf
      : public DtPagingFeatureSet<F>::Tile
      , public DtUnusedFeatureTileTracker::Trackable
      , public boost::enable_shared_from_this<typename DtPagingFeatureSet<F>::Leaf>
   {
   public:
      typedef std::vector<typename Feature::CPtr> FeatureVector;

      ~Leaf();

      void forEachLoadedFeature(
         ForEachFunction, DtWaitType) const;
      void forEachLoadedFeatureParallel(
         ForEachFunction, DtWaitType) const;
      void getAllLoadedTileGeometries(DtFeatureGeometry::GeometryVector&) const;
      TilePtr getTiles(
         LeafVector&, boost::optional<DtFeatureGeometry>);

      bool loaded(double) const;
      unsigned numberOfFeatures() const;

      bool keep() const;
      unsigned size() const;
      boost::shared_ptr<DtUnusedFeatureTileTracker::Trackable> getPtr();

      Leaf(GridPtr parent, unsigned xindex, unsigned yindex);

   private:
      struct CallbackWrapper;

      void load();
      void unload();

      typedef tbb::spin_rw_mutex Mutex;

      mutable Mutex myMutex;
      typename DtAsyncLoadingFeatureSet<F>::Ptr myFeatures;
   };

   template <typename F>
   class DtPagingFeatureSet<F>::LoadingFeatureSet : public DtFeatureSetTemplate<F>
   {
   public:
      explicit LoadingFeatureSet(LeafPtr);

      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      LoadingFeatureSet* clone() const;
      DtQuery schema() const;
      bool loaded(double) const;
      unsigned numberOfFeatures() const;

   private:
      struct WrapWithPagingFeature;
      class PagingFeature;

      explicit LoadingFeatureSet(const LoadingFeatureSet&);

      LeafPtr myLeaf;
      DtUnusedFeatureTileTracker::Sentinel::Ptr mySentinel;
   };
}