asyncLoadingFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/featureSet.h>

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

namespace MAKVRinTerra
{
   template <typename F>
   class DT_DLL_features DtAsyncLoadingFeatureSet
      : public DtFeatureSetTemplate<F>
      , public boost::enable_shared_from_this<DtAsyncLoadingFeatureSet<F> >
   {
   public:
      typedef boost::shared_ptr<DtAsyncLoadingFeatureSet> Ptr;
      typedef boost::weak_ptr<DtAsyncLoadingFeatureSet>   WPtr;
      typedef DtFeatureSetTemplate<F>                     FeatureSet;
      typedef typename FeatureSet::ForEachFunction        ForEachFunction;
      typedef boost::function<FeatureSet* (FeatureSet*)>  TileFactory;
      typedef boost::function<void (const FeatureSet&)>   Callback;
      typedef typename FeatureSet::Empty                  Empty;

      virtual void start() = 0;

      virtual bool loading() const;

      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction, DtWaitType) const;
      DtQuery schema() const;
      FeatureSet* filter(const DtQuery&, DtLoadType) const;
      FeatureSet* clone() const;
      bool loaded(double) const;
      unsigned numberOfFeatures() 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;

      static void Run(WPtr);

      virtual void run(const Ptr&);

      DtAsyncLoadingFeatureSet(
         FeatureSet* input, DtQuery query, Callback callback, TileFactory factory);

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

      std::auto_ptr<FeatureSet> myInputFeatureSet;
      DtQuery myQuery;
      DtQuery mySchema;
      boost::scoped_ptr<FeatureSet> myFeatureSet;
      TileFactory myTileFactory;
      Callback myCallback;
      bool myRunningFlag;
   };

   template <typename F>
   class DT_DLL_features DtThreadLoadingFeatureSet
      : public DtAsyncLoadingFeatureSet<F>
   {
   public:
      typedef boost::shared_ptr<DtThreadLoadingFeatureSet>      Ptr;
      typedef typename DtAsyncLoadingFeatureSet<F>::FeatureSet  FeatureSet;
      typedef typename DtAsyncLoadingFeatureSet<F>::Callback    Callback;
      typedef typename DtAsyncLoadingFeatureSet<F>::TileFactory TileFactory;

      static Ptr Make(
         FeatureSet* input,
         DtQuery query = true,
         Callback callback = Callback(),
         TileFactory factory = &FeatureSet::Storage::Make);

      void start();

   protected:
      typedef typename DtAsyncLoadingFeatureSet<F>::Caller Caller;
      typedef typename DtAsyncLoadingFeatureSet<F>::ScopedLock ScopedLock;

      DtThreadLoadingFeatureSet(
         FeatureSet* input, DtQuery query, Callback callback, TileFactory factory);

      boost::scoped_ptr<tbb::tbb_thread> myThread;
   };

   template <typename F>
   class DT_DLL_features DtTaskLoadingFeatureSet
      : public DtAsyncLoadingFeatureSet<F>
   {
   public:
      typedef boost::shared_ptr<DtTaskLoadingFeatureSet>        Ptr;
      typedef boost::shared_ptr<DtTaskLoadingFeatureSet>        WPtr;
      typedef typename DtAsyncLoadingFeatureSet<F>::WPtr        BaseWPtr;
      typedef typename DtAsyncLoadingFeatureSet<F>::FeatureSet  FeatureSet;
      typedef typename DtAsyncLoadingFeatureSet<F>::Callback    Callback;
      typedef typename DtAsyncLoadingFeatureSet<F>::TileFactory TileFactory;

      static Ptr Make(
         FeatureSet* input,
         DtQuery query = true,
         Callback callback = Callback(),
         TileFactory factory = &FeatureSet::Storage::Make);

      void start();

   protected:
      class Task : public tbb::task
      {
      public:
         explicit Task(BaseWPtr);

         tbb::task* execute();

      private:
         BaseWPtr myPtr;
      };

      friend class Task;

      DtTaskLoadingFeatureSet(
         FeatureSet* input, DtQuery query, Callback callback, TileFactory factory);

      typedef tbb::spin_mutex Mutex;

      mutable Mutex myFlagMutex;
      bool myStartedFlag;
   };

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

      class Task;

      class Queue : public boost::enable_shared_from_this<Queue>
      {
      public:
         explicit Queue(unsigned maxTasks);

         void add(BasePtr);
         bool pop(BaseWPtr&);

         friend class Task;
        
      private:
         void taskDestroyed();

         typedef tbb::spin_mutex Mutex;
         typedef std::list<typename DtAsyncLoadingFeatureSet<F>::WPtr> WPtrList;

         mutable Mutex myMutex;
         WPtrList myWeakPtrs;
         unsigned myMaxTasks;
         unsigned myTasks;
      };

      static Ptr Make(
         boost::shared_ptr<Queue> queue,
         FeatureSet* input,
         DtQuery query = true,
         Callback callback = Callback(),
         TileFactory factory = &FeatureSet::Storage::Make);

      void start();

      class Task : public tbb::task
      {
      public:
         explicit Task(boost::shared_ptr<Queue>);

         ~Task();

         tbb::task* execute();

      private:
         boost::shared_ptr<Queue> myQueue;
      };

      friend class Task;

      DtQueueLoadingFeatureSet(
         boost::shared_ptr<Queue> queue,
         FeatureSet* input, DtQuery query, Callback callback, TileFactory factory);

      typedef tbb::spin_mutex Mutex;

      mutable Mutex myFlagMutex;
      bool myStartedFlag;
      boost::shared_ptr<Queue> myQueue;
   };
}