featureSetWrappers.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/featureSetUtils.h>

#include <vrfutil/objectCounter.h>

#include <boost/signals2.hpp>

#include <tbb/spin_mutex.h>
#include <tbb/spin_rw_mutex.h>
#include <tbb/null_rw_mutex.h>

struct DtFeatureSetWrapperCallbackRecordTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetWrapperCallbackRecordTag);

struct DtFeatureSetWrapperCallbackRecordDetacherTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetWrapperCallbackRecordDetacherTag);

struct DtFeatureSetWrapperLoadedCallerTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetWrapperLoadedCallerTag);

namespace MAKVRinTerra
{
   template <
      typename Derived,
      typename FS,
      typename Inner = FS>
   class DtFeatureSetWrapperTemplate : public FS
   {
   protected:
      Derived*       This()       { return static_cast<Derived*>(this); }
      const Derived* This() const { return static_cast<const Derived*>(this); }

      DtFeatureSetWrapperTemplate()
         : myLoadedSignal(new LoadedSignal())
      {
      }

   public:
      typedef FS                                   FeatureSet;
      typedef typename FeatureSet::Feature         Feature;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;
      typedef typename FeatureSet::DetachCallback  DetachCallback;
      typedef typename FeatureSet::LoadedCallback  LoadedCallback;

      typedef std::shared_ptr<Inner>       Ptr;
      typedef std::shared_ptr<const Inner> CPtr;

      template <typename Function=ForEachFunction>
      class CallbackRecord;

      std::string label() const 
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->label();

         return "empty feature set wrapper";
      }


      unsigned numberOfFeatures() const 
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->numberOfFeatures();

         return 0;
      }

      bool elided() const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->elided();
         
         return FS::elided();
      }

      bool empty() const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->empty();

         return FS::empty();
      }

      bool isIndexed() const 
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->isIndexed();

         return FS::isIndexed();
      }

      bool isCacheable(const boost::optional<DtFeatureGeometry>& area) const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->isCacheable(area);
         else
            return FS::isCacheable(area);
      }

      void cacheEstimate(double& time, double& size, const boost::optional<DtFeatureGeometry>& area) const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            handle->cacheEstimate(time, size, area);
         else
            return FS::cacheEstimate(time, size, area);
      }

      void cacheData(
         const boost::optional<DtFeatureGeometry>& area,
         DtFeatureCacheProgressCallback* progress) const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            handle->cacheData(area, progress);
         else
            FS::cacheData(area, progress);
      }

      bool loaded(double timeout=0.0) const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->loaded(timeout);

         return false;
      }

      virtual bool loadedThrowIfNotSet(double timeout=0.0) const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return handle->loaded(timeout);

         throw DtFeatureSetLoadingException();
      }

      struct LoadedCounter
#ifdef DtObjectDebugger_Enable
         : public DtObjectDebugger<LoadedCounter>
#endif
      {
         const LoadedCallback callback;
         explicit LoadedCounter(const LoadedCallback& cb) : callback(cb) { }
         void operator()() const { callback(); }
      };

      DetachCallback addLoadedCallback(const LoadedCallback& cb) const
      {
         if (!cb)
            DetachCallback();

         //boost::signals2::connection conn = myLoadedSignal->connect(cb);
         boost::signals2::connection conn = myLoadedSignal->connect(LoadedCounter(cb));

         try
         {
            return boost::bind(&boost::signals2::connection::disconnect, conn);
         }
         catch (...)
         {
            conn.disconnect();
            throw;
         }
      }

      void forEachFeatureParallel(const ForEachFunction& func) const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            handle->forEachFeatureParallel(func);
      }

      DetachCallback forEachFeatureAsync(const ForEachFunction& func) const
      {
         typedef CallbackRecord<ForEachFunction> Record;
         typedef typename Record::Ptr RecordPtr;

         DetachCallback detacher;

         CPtr handle(This()->getPtr());
         if (handle)
            detacher = handle->forEachFeatureAsync(func);

         try
         {
            typename CallbackMutex::scoped_lock headLock(myCallbackMutex);
            RecordPtr newHead(Record::Make(func, myHead, detacher));
            const_cast<RecordPtr&>(myHead) = newHead;
            return typename Record::Detacher(newHead);
         }
         catch (...)
         {
            if (detacher)
               detacher();

            throw;
         }
      }

      FeatureSet* filter(
         const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geometry,
         DtLoadType load) const
      {
         CPtr handle(This()->getPtr());
         if (handle)
            return this->Wrap(handle->filter(query, geometry, load));

         assert(false);
         DtTHROW_NEW(DtException, "filtered empty feature set wrapper");
      }

      FeatureSet* filter(const DtQuery& query, DtLoadType load) const
      {
         return FS::filter(query, load);
      }

      FeatureSet* filter(const boost::optional<DtFeatureGeometry>& geometry, DtLoadType load) const
      {
         return FS::filter(geometry, load);
      }

   public:
      template <typename Function>
      class CallbackRecord
#ifdef DtObjectDebugger_Enable
         : public DtObjectDebugger<DtFeatureSetWrapperCallbackRecordTag>
#endif
      {
      public:
         typedef std::shared_ptr<CallbackRecord> Ptr;
         typedef std::weak_ptr<CallbackRecord>   WPtr;

         struct Detacher
#ifdef DtObjectDebugger_Enable
            : public DtObjectDebugger<DtFeatureSetWrapperCallbackRecordDetacherTag>
#endif
         {
            void operator()() const
            {
               std::shared_ptr<CallbackRecord> callback(callbackWptr.lock());
               if (callback)
                  callback->detach();
            }

            explicit Detacher(const std::shared_ptr<CallbackRecord>& rec)
               : callbackWptr(rec) { }

            std::weak_ptr<CallbackRecord> callbackWptr;
         };

         static Ptr Make(const Function& func, const Ptr& curHead, const DetachCallback& detach)
         {
            Ptr newRec(new CallbackRecord(func, curHead, detach));
            while (newRec->next)
            {
               Mutex::scoped_lock lock(newRec->next->mutex);
               if (newRec->next->func)
                  break;

               newRec->next = newRec->next->next;
            }

            return newRec;
         }

         void addCallbacksTo(const CPtr& fs)
         {
            Mutex::scoped_lock lock(mutex);

            if (detacher)
            {
               detacher();
               detacher = DetachCallback();
            }

            if (func && fs)
            {
               Function f(func);

               lock.release();
               DetachCallback d = fs->forEachFeatureAsync(f);
               lock.acquire(mutex);

               if (func)
                  detacher = d;
               else if (d)
                  d();
            }

            Ptr ne = next;
            lock.release();

            if (ne)
            {
               try
               {
                  ne->addCallbacksTo(fs);
               }
               catch (...)
               {
                  lock.acquire(mutex);
                  if (detacher)
                  {
                     detacher();
                     detacher = DetachCallback();
                  }

                  throw;
               }
            }
         }

         void detach()
         {
            Mutex::scoped_lock lock(mutex);

            if (!func)
               return;

            func = Function();

            if (detacher)
            {
               detacher();
               detacher = DetachCallback();
            }

            Ptr pr = prev.lock();
            Ptr ne = next;

            while (pr)
            {
               lock.release();
               lock.acquire(pr->mutex);

               if (pr->func)
                  break;

               pr = pr->prev.lock();
            }

            while (ne)
            {
               Mutex::scoped_lock endLock(ne->mutex);
               if (ne->func)
               {
                  if (pr)
                     pr->next = ne;

                  return;
               }

               ne = ne->next;
            }

            if (pr)
               pr->next = ne;
         }

         ~CallbackRecord()
         {
            if (detacher)
               detacher();
         }

         typedef tbb::spin_mutex Mutex;

      private:
         explicit CallbackRecord(
            const Function& func,
            const Ptr& next,
            const DetachCallback& detach)
            : func(func)
            , next(next)
            , detacher(detach)
         {
         }

         mutable Mutex mutex;
         Function func;  
         WPtr prev;
         Ptr next;
         DetachCallback detacher;
      };

protected:
      void setupCallbacks(const CPtr& fs)
      {   
         typename CallbackMutex::scoped_lock lock(myCallbackMutex);

         myLoadedSignalDetacher.reset();

         if (myHead)
            myHead->addCallbacksTo(fs);

         if (fs)
         {
            myLoadedSignalDetacher.reset(fs->addLoadedCallback(LoadedCaller(myLoadedSignal)));

            try
            {
               if (fs->loaded(0.0))
                  (*myLoadedSignal)();
            }
            catch (DtFeatureSetLoadingException&) { }
         }
      }

   private:
      typedef tbb::spin_mutex CallbackMutex;
      typedef boost::signals2::signal_type<
         void (),
         boost::signals2::keywords::mutex_type<tbb::spin_mutex> >::type LoadedSignal;

      struct LoadedCaller 
#ifdef DtObjectDebugger_Enable
         : public DtObjectDebugger<DtFeatureSetWrapperLoadedCallerTag>
#endif
      {
         std::weak_ptr<LoadedSignal> sig;
         explicit LoadedCaller(const std::shared_ptr<LoadedSignal>& sig)
            : sig(sig) { }

         void operator()() const
         {
            std::shared_ptr<LoadedSignal> signal(sig.lock());
            if (signal)
               (*signal)();
         }
      };

      mutable CallbackMutex myCallbackMutex;
      typename CallbackRecord<>::Ptr myHead;
      std::shared_ptr<LoadedSignal> myLoadedSignal;
      typename FeatureSet::DetachScopeGuard myLoadedSignalDetacher;
   };

   template <
      typename FS,
      template <typename> class PtrTemplate,
      typename Inner>
   class DtFeatureSetWrapper;

   template <typename FS, typename Inner>
   class DtFeatureSetWrapper<FS, DtUniquePtr,Inner> : public FS
   {
   public:
      typedef typename FS::Feature         Feature;
      typedef typename FS::ForEachFunction ForEachFunction;
      typedef typename FS::LoadedCallback  LoadedCallback;
      typedef typename FS::DetachCallback  DetachCallback;

      explicit DtFeatureSetWrapper(Inner* fs) : mySet(fs)
      {
         assert(mySet);
      }

      template <typename OtherFS>
      explicit DtFeatureSetWrapper(std::unique_ptr<OtherFS> fs)
         : mySet(fs.release())
      {
         assert(mySet);
      }

      Inner* getPtr() { return mySet.get(); }
      const Inner* getPtr() const { return mySet.get(); }

      std::string label() const 
      {
         return mySet->label();
      }

      unsigned numberOfFeatures() const 
      {
         return mySet->numberOfFeatures();
      }

      bool elided() const
      {
         return mySet->elided();
      }

      bool empty() const
      {
         return mySet->empty();
      }

      bool isIndexed() const 
      {
         return mySet->isIndexed();
      }

      bool isCacheable(const boost::optional<DtFeatureGeometry>& area) const
      {
         return mySet->isCacheable(area);
      }

      void cacheEstimate(double& time, double& size, const boost::optional<DtFeatureGeometry>& area) const
      {
         mySet->cacheEstimate(time, size, area);
      }

      void cacheData(
         const boost::optional<DtFeatureGeometry>& area,
         DtFeatureCacheProgressCallback* progress) const
      {
         mySet->cacheData(area, progress);
      }

      bool loaded(double timeout=0.0) const
      {
         return mySet->loaded(timeout);
      }

      DetachCallback addLoadedCallback(const LoadedCallback& cb) const
      {
         return mySet->addLoadedCallback(cb);
      }

      void forEachFeatureParallel(const ForEachFunction& func) const
      {
         mySet->forEachFeatureParallel(func);
      }

      DetachCallback forEachFeatureAsync(const ForEachFunction& func) const
      {
         return mySet->forEachFeatureAsync(func);
      }

      FS* filter(
         const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geometry,
         DtLoadType load) const
      {
         return this->Wrap(mySet->filter(query, geometry, load));
      }

      FS* clone() const
      {
         return this->Wrap(mySet->clone());
      }

   private:
      const std::unique_ptr<Inner> mySet;
   };

   template <typename FS, typename Inner>
   class DtFeatureSetWrapper<FS,std::shared_ptr,Inner>
      : public DtFeatureSetWrapperTemplate<
         DtFeatureSetWrapper<FS,std::shared_ptr,Inner>,
         FS,
         Inner>
   {
   public:
      explicit DtFeatureSetWrapper()
      {
      }

      explicit DtFeatureSetWrapper(Inner* fs)
      {
         assert(fs);
         setPtr(std::shared_ptr<Inner>(fs));
      }

      template <typename OtherFS>
      explicit DtFeatureSetWrapper(std::unique_ptr<OtherFS> fs)
      {
         assert(fs.get());
         setPtr(std::shared_ptr<Inner>(fs.release()));
      }

      template <typename OtherFS>
      explicit DtFeatureSetWrapper(const std::shared_ptr<OtherFS>& fs)
      {
         assert(fs.get());
         setPtr(fs);
      }

      std::shared_ptr<Inner> getPtr()
      {  
         Mutex::scoped_lock lock(myMutex, false);
         return mySet;
      }

      std::shared_ptr<const Inner> getPtr() const
      { 
         Mutex::scoped_lock lock(myMutex, false);
         return mySet;
      }

      std::shared_ptr<Inner> setPtr(const std::shared_ptr<Inner>& p)
      {
         Mutex::scoped_lock lock(myMutex, false);
         if (mySet && p)
            return mySet;

         if (!lock.upgrade_to_writer() && mySet && p)
            return mySet;

         mySet = p;

         lock.downgrade_to_reader();
         this->setupCallbacks(p);

         return mySet;
      }

      std::shared_ptr<Inner> setPtr(Inner* set)
      {
         std::shared_ptr<Inner> fs(set);
         return setPtr(fs);
      }

      FS* clone() const
      {
         return this->Wrap(getPtr());
      }

   protected:
      typedef tbb::spin_rw_mutex Mutex;
      mutable Mutex myMutex;

      std::shared_ptr<Inner> mySet;
   };
         
   template <typename FS, typename Inner>
   class DtFeatureSetWrapper<FS,std::weak_ptr,Inner>
      : public DtFeatureSetWrapperTemplate<
         DtFeatureSetWrapper<FS,std::weak_ptr,Inner>,
         FS,
         Inner>
   {
   public:
      typedef typename FS::Feature         Feature;
      typedef typename FS::ForEachFunction ForEachFunction;
      typedef typename FS::DetachCallback  DetachCallback;

      explicit DtFeatureSetWrapper()
         : mySet() { }

      template <typename T>
      explicit DtFeatureSetWrapper(const std::weak_ptr<T>& fs)
      {
         setPtr(fs.lock());
      }

      template <typename T>
      explicit DtFeatureSetWrapper(const std::shared_ptr<T>& fs)
      {
         assert(fs);
         setPtr(fs);
      }

      std::shared_ptr<Inner> getPtr()
      {
         Mutex::scoped_lock lock(myMutex, false);
         return mySet.lock();
      }

      std::shared_ptr<const Inner> getPtr() const
      {
         Mutex::scoped_lock lock(myMutex, false);
         return mySet.lock();
      }

      std::shared_ptr<Inner> getMutablePtr() const
      {
         return const_cast<DtFeatureSetWrapper*>(this)->getPtr();
      }

      std::shared_ptr<Inner> setPtr(const std::shared_ptr<Inner>& p)
      {
         Mutex::scoped_lock lock(myMutex, false);
         if (p)
         {
            std::shared_ptr<Inner> s(mySet.lock());
            if (s)
               return s;
         }

         if (!lock.upgrade_to_writer() && p)
         {
            std::shared_ptr<Inner> s(mySet.lock());
            if (s)
               return s;
         }

         mySet = p;

         lock.downgrade_to_reader();
         this->setupCallbacks(p);

         return p;
      }

      FS* clone() const
      {
         Mutex::scoped_lock lock(myMutex, false);
         return this->Wrap(mySet);
      }

   private:
      typedef tbb::spin_rw_mutex Mutex;
      mutable Mutex myMutex;

      std::weak_ptr<Inner> mySet;
   };
}