asyncLoadingFeatureSet.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrfutil/vrfCallbackQueue.h>

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

#include <boost/signals2.hpp>

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;
      typedef typename FeatureSet::LoadedCallback         LoadedCallback;
      typedef typename FeatureSet::DetachCallback         DetachCallback;

      class Empty;
      class DT_DLL_features LoadingFeatureSet;

      ~DtAsyncLoadingFeatureSet();

      virtual void start();

      virtual void start(bool wait);

      std::string label() const;
      void forEachFeatureParallel(const ForEachFunction&) const;
      DetachCallback forEachFeatureAsync(const ForEachFunction&) const;
      FeatureSet* filter(const DtQuery&, const boost::optional<DtFeatureGeometry>&, DtLoadType) const;
      FeatureSet* clone() const;
      bool loaded(double) const;
      DetachCallback addLoadedCallback(const LoadedCallback&) const;
      unsigned numberOfFeatures() const;
      bool elided() const;
      bool empty() const;

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

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

   protected:
      typedef tbb::mutex Mutex;
      typedef tbb::interface5::condition_variable ConditionVariable;
      typedef tbb::interface5::unique_lock<Mutex> ScopedLock;

      typedef boost::signals2::signal_type<
         void (),
         boost::signals2::keywords::mutex_type<tbb::spin_mutex> >::type LoadedSignal;
      
      class Caller;
      struct SizeCalculator;

      static bool Run(DtAsyncLoadingFeatureSet&, bool wait);

      virtual bool run(bool wait);

      virtual FeatureSet* createFeatureSet(FeatureSet* fs) const;

      virtual void inputLoadedCallback();

      struct InputLoadedCaller;

      explicit DtAsyncLoadingFeatureSet(
         FeatureSet* input, const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geom,
         const DtUnusedFeatureTileTracker::Ptr&);

      mutable Mutex myConditionMutex;
      mutable ConditionVariable myWaitCondition;

      tbb::atomic<bool> myLoadingFlag;     
      tbb::atomic<bool> myRunningFlag;     
      tbb::atomic<bool> myInputLoadedFlag; 
      bool myLoadedFlag;                   

      mutable LoadedSignal myLoadedSignal;

      std::auto_ptr<FeatureSet> myInputFeatureSet;
      DtQuery myQuery;
      boost::optional<DtFeatureGeometry> myGeometry;
      DtFeatureSetWrapper<FeatureSet, boost::shared_ptr> myFeatureSet;
   };

   template <typename FS>
   class DtAsyncLoadingFeatureSet<FS>::LoadingFeatureSet
      : public DtFeatureSetWrapper<FS, boost::shared_ptr>
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger<typename DtAsyncLoadingFeatureSet<FS>::LoadingFeatureSet>
#endif
   {
   public:
      typedef DtFeatureSetWrapper<FS, boost::shared_ptr> Base;

      class DT_DLL_features LoadingFeatureRef;
      class DT_DLL_features LoadingFeature;

      explicit LoadingFeatureSet(const typename DtAsyncLoadingFeatureSet<FS>::Ptr&);

      explicit LoadingFeatureSet(
         const boost::shared_ptr<FS>&,
         const DtUnusedFeatureTileTracker::Trackable&);

      explicit LoadingFeatureSet(
         FS* fs,
         const DtUnusedFeatureTileTracker::Sentinel::Ptr&);

      std::string label() const;
      FS* filter(const DtQuery&, const boost::optional<DtFeatureGeometry>&, DtLoadType) const;
      void forEachFeatureParallel(const ForEachFunction&) const;
      typename FS::DetachCallback forEachFeatureAsync(const ForEachFunction&) const;
      LoadingFeatureSet* clone() const;

   private:
      struct WrapWithLoadingFeatureRef;

      explicit LoadingFeatureSet(const LoadingFeatureSet&);

      DtUnusedFeatureTileTracker::Sentinel::Ptr mySentinel;
   };

   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 DtVrfCallbackQueue Queue;
      class QueueCallback;

      using DtAsyncLoadingFeatureSet<FS>::start;

      void start(bool wait);

      DtQueueLoadingFeatureSet(
         FeatureSet* input, const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geom,
         const boost::shared_ptr<Queue>& queue,
         const DtUnusedFeatureTileTracker::Ptr& = DtUnusedFeatureTileTracker::Ptr());

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