asyncLoadingFeatureSet.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <features/featureSet.h>
#include <features/unusedFeatureTileTracker.h>

#include <vrfutil/callbackQueue.h>

#include <tbb/mutex.h>
#include <tbb/spin_mutex.h>
#include <tbb/tbb_thread.h>
#include <tbb/compat/condition_variable>

namespace MAKVRinTerra
{
   template <typename FS>
   class DT_DLL_features DtAsyncLoadingFeatureSet
      : virtual public FS
      , public DtUnusedFeatureTileTracker::Trackable
      , public boost::enable_shared_from_this<DtAsyncLoadingFeatureSet<FS> >
   {
   public:
      typedef boost::shared_ptr<DtAsyncLoadingFeatureSet> Ptr;

      typedef boost::weak_ptr<DtAsyncLoadingFeatureSet>   WPtr;

      typedef FS                                          FeatureSet;
      typedef typename FS::Feature                        Feature;
      typedef typename FeatureSet::ForEachFunction        ForEachFunction;

      class Empty;


      static bool Run(const Ptr&);
      static bool Run(WPtr);

      virtual void start() = 0;

      std::string label() const;
      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction, DtWaitType) const;
      FeatureSet* filter(const DtQuery&, DtLoadType) const;
      FeatureSet* clone() const;
      bool loaded(double) const;
      unsigned numberOfFeatures() const;
      bool empty() const;

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

      void load();
      void unload();
      bool loading() const;
      bool loaded() const;

   protected:
      typedef tbb::spin_rw_mutex RWMutex;
      typedef tbb::mutex Mutex;
      typedef tbb::interface5::condition_variable ConditionVariable;
      typedef tbb::interface5::unique_lock<Mutex> ScopedLock;
      
      struct Caller;

      virtual bool run(const Ptr&);

      virtual FeatureSet* createFeatureSet(FeatureSet* fs) const;

      explicit DtAsyncLoadingFeatureSet(
         FeatureSet* input, DtQuery query, DtUnusedFeatureTileTracker::Ptr);

      mutable RWMutex myRWMutex;
      mutable Mutex myMutex;
      mutable ConditionVariable myWaitCondition;

      std::auto_ptr<FeatureSet> myInputFeatureSet;
      DtQuery myQuery;
      std::auto_ptr<FeatureSet> myFeatureSet;
      bool myLoadingFlag;  
      bool myRunningFlag;  
   };

   template <typename FS>
   class DT_DLL_features DtAsyncLoadingFeatureSet<FS>::Empty
      : public DtAsyncLoadingFeatureSet<FS>
   {
   public:
      explicit Empty(DtUnusedFeatureTileTracker::Ptr);

      void start();

      void load();
      void unload();
      bool loading() const;

   protected:
   };

   template <typename FS>
   class DT_DLL_features DtQueueLoadingFeatureSet
      : public DtAsyncLoadingFeatureSet<FS>
   {
   public:
      typedef boost::shared_ptr<DtQueueLoadingFeatureSet>         Ptr;
      typedef boost::shared_ptr<DtQueueLoadingFeatureSet>         WPtr;
      typedef typename DtAsyncLoadingFeatureSet<FS>::Ptr          BasePtr;
      typedef typename DtAsyncLoadingFeatureSet<FS>::WPtr         BaseWPtr;
      typedef typename DtAsyncLoadingFeatureSet<FS>::FeatureSet   FeatureSet;
      typedef typename FeatureSet::ForEachFunction                ForEachFunction;

      typedef DtCallbackQueue Queue;

      void start();
      
      FS* createFeatureSet(FS* fs) const;

      DtQueueLoadingFeatureSet(
         FeatureSet* input, DtQuery query,
         boost::weak_ptr<Queue> queue,
         DtUnusedFeatureTileTracker::Ptr);

      boost::weak_ptr<Queue> myQueue;
   };
}