featureSet.h

Go to the documentation of this file.

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


#pragma once

#include <features/featuresDefines.h>

#include <memory>
#include <string>

#include <boost/function.hpp>

#include <boost/optional.hpp>
#include <boost/noncopyable.hpp>

#include <vrfutil/objectCounter.h>
#include <vrfutil/taggedException.h>

namespace MAKVRinTerra
{
   class DtFeature;
   class DtQuery;
   class DtFeatureGeometry;

   enum DtLoadType
   {
      LOAD,
      LOAD_ASYNC,
      DO_NOT_LOAD
   };

   class DT_DLL_features DtFeatureCacheProgressCallback
   {
   public:
      virtual void layerName(const std::string&) = 0;
      virtual void percent(double) = 0;
      virtual bool isCancelled() = 0;
   };

   template <typename T>
   using DtUniquePtr = std::unique_ptr<T, std::default_delete<T> >;

   template <
      typename FS,
      template <typename> class PtrTemplate = DtUniquePtr,
      typename InnerFS = FS>
   class DtFeatureSetWrapper;

   class DT_DLL_features DtFeatureSetLoadingException : public DtException
   {
   public:
      explicit DtFeatureSetLoadingException();
   };

   template <typename FS, typename InnerFS = FS>
   class DT_DLL_features DtFeatureSetList;

   template <size_t N, typename FS, typename InnerFS = FS>
   class DT_DLL_features DtFeatureSetArray;

   template <typename FS>
   class DT_DLL_features DtFilteredFeatureSet;

   template <typename FS>
   class DT_DLL_features DtEmptyFeatureSet;

   template <typename FS, typename F = typename FS::Feature>
   class DT_DLL_features DtSinkFeatureSet;

   template <typename FS>
   class DT_DLL_features DtSourceFeatureSet;

   template <typename F>
   class DT_DLL_features DtFeatureSetTemplate
      : private boost::noncopyable
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger< DtFeatureSetTemplate<F> >
#endif
   {
   public:

      DtFeatureSetTemplate() : myBlockOnAsynchronousOperations(false) {};

      typedef F Feature;

      typedef DtFeatureSetTemplate FeatureSet;

      typedef boost::function<void ()> DetachCallback;

      class DetachScopeGuard : boost::noncopyable
      {
         DetachCallback callback;

      public:
         explicit DetachScopeGuard(const DetachCallback& cb = DetachCallback()):
            callback(cb) {};
         ~DetachScopeGuard()
         {
            if (callback)
            {
               callback();
            }
         };
         
         void reset(const DetachCallback& cb = DetachCallback())
         {
            if (callback)
               callback();

            callback = cb;
         };
      };

      typedef boost::function<void (const Feature&)> ForEachFunction;

      typedef boost::function<void ()> LoadedCallback;

      typedef DtFeatureSetWrapper<FeatureSet, DtUniquePtr> ScopedWrapper;

      typedef DtFeatureSetWrapper<FeatureSet, std::shared_ptr> SharedWrapper;


      typedef DtFeatureSetList<FeatureSet>      List;
      typedef DtFilteredFeatureSet<FeatureSet>  Filtered;
      typedef DtEmptyFeatureSet<FeatureSet>     Empty;
      typedef DtSinkFeatureSet<FeatureSet>      Sink;
      typedef DtSourceFeatureSet<FeatureSet>    Source;

      template <typename FS>
      static FeatureSet* Wrap(FS* fs)
      {
         std::unique_ptr<FS> set(fs);
         return Wrap(std::move(set));
      }

      static DtFeatureSetTemplate* Wrap(DtFeatureSetTemplate* fs)
      {
         return fs;
      }

      static DtFeatureSetTemplate* Wrap(std::unique_ptr<FeatureSet> fs)
      {
         return fs.release();
      }

      template <typename FS>
      static FeatureSet* Wrap(std::unique_ptr<FS> fs)
      {
         if (!fs.get() || fs->elided())
            return 0;

         return new DtFeatureSetWrapper<FeatureSet, DtUniquePtr, FS>(std::move(fs));
      }

      template <typename FS>
      static FeatureSet* Wrap(const std::shared_ptr<FS>& fs)
      {
         if (!fs || fs->elided())
            return 0;

         return new DtFeatureSetWrapper<FeatureSet, std::shared_ptr, FS>(fs);
      }

      template <typename FS>
      static FeatureSet* Wrap(const std::weak_ptr<FS>& fs)
      {
         std::shared_ptr<FS> ptr(fs.lock());
         if (!ptr || ptr->elided())
            return 0;

         return new DtFeatureSetWrapper<FeatureSet, std::weak_ptr, FS>(fs);
      }

      virtual ~DtFeatureSetTemplate();

      virtual DtFeatureSetTemplate* setBlockOnAsynchronousOperations(bool block);

      virtual bool blockOnAsynchronousOperations() const;

      virtual std::string label() const = 0;

      virtual void forEachFeatureParallel(const ForEachFunction& func) const = 0;

      void forEachFeature(const ForEachFunction& func) const;


      bool forEachFeatureParallelBlock(const ForEachFunction& func, double timeout = 60) const;
      bool forEachFeatureBlock(const ForEachFunction& func, double timeout = 60) const;

      virtual DetachCallback forEachFeatureAsync(const ForEachFunction& func) const = 0;


      virtual DtFeatureSetTemplate* filter(
         const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geometry,
         DtLoadType load) const;

      DtFeatureSetTemplate* filter(
         const DtQuery& query, DtLoadType load) const;

      DtFeatureSetTemplate* filter(
         const boost::optional<DtFeatureGeometry>& geometry, DtLoadType load) const;


      virtual bool load(
         const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geometry) const;

      bool load(const DtQuery& query) const;
      bool load(const boost::optional<DtFeatureGeometry>& geometry) const;

      virtual DtFeatureSetTemplate* clone() const = 0;

      virtual bool loaded(double timeout=0.0) const = 0;

      virtual DetachCallback addLoadedCallback(const LoadedCallback&) const = 0;

      virtual bool elided() const = 0;

      virtual bool empty() const = 0;

      virtual bool isIndexed() const;

      virtual bool isCacheable(const boost::optional<DtFeatureGeometry>& area = boost::none_t()) const;

      virtual void cacheEstimate(
         double& time, double& size,
         const boost::optional<DtFeatureGeometry>& area = boost::none_t()) const;

      virtual void cacheData(
         const boost::optional<DtFeatureGeometry>& area = boost::none_t(),
         DtFeatureCacheProgressCallback* progress = 0) const;

      virtual unsigned numberOfFeatures() const;


      class DT_DLL_features Visitor
      {
      public:
         virtual ~Visitor();
         virtual void visit(FeatureSet&) = 0;
      };

      class DT_DLL_features ConstVisitor
      {
      public:
         virtual ~ConstVisitor();
         virtual void visit(const FeatureSet&) = 0;
      };


      virtual void accept(Visitor&);
      virtual void accept(ConstVisitor&) const;

   protected:
      class SynchronizedFunction;
      struct FeatureCounter;

      bool myBlockOnAsynchronousOperations;
   };

   template <typename F>
   inline DtFeatureSetTemplate<F>* new_clone(const DtFeatureSetTemplate<F>& from)
   {
      return from.clone();
   }


   template <typename FS>
   inline bool DtIsElided(const FS& fs)
   {
      return fs.elided();
   }

   template <typename FS>
   inline bool DtIsElided(FS* fs)
   {
      if (!fs)
         return true;

      return DtIsElided(*fs);
   }

   typedef DtFeatureSetTemplate<DtFeature> DtFeatureSet;
}

#define DT_INSTANTIATE_FEATURE_SETS(F)                                                             \
   template class MAKVRinTerra::DtFeatureSetTemplate<F>;                                           \
   template class MAKVRinTerra::DtFeatureSetList< MAKVRinTerra::DtFeatureSetTemplate<F> >;         \
   template class MAKVRinTerra::DtFeatureSetArray<4, MAKVRinTerra::DtFeatureSetTemplate<F> >;      \
   template class MAKVRinTerra::DtFilteredFeatureSet< MAKVRinTerra::DtFeatureSetTemplate<F> >;     \
   template class MAKVRinTerra::DtEmptyFeatureSet< MAKVRinTerra::DtFeatureSetTemplate<F> >;        \
   template class MAKVRinTerra::DtSinkFeatureSet< MAKVRinTerra::DtFeatureSetTemplate<F> >;         \
   template class MAKVRinTerra::DtSourceFeatureSet< MAKVRinTerra::DtFeatureSetTemplate<F> >;       \
   template class MAKVRinTerra::DtAsyncLoadingFeatureSet< MAKVRinTerra::DtFeatureSetTemplate<F> >; \
   template class MAKVRinTerra::DtPagingFeatureSet< MAKVRinTerra::DtFeatureSetTemplate<F> >;       \

DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtFeatureSetTemplate);
DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtFeatureSet);