featureSetUtils.h

Go to the documentation of this file.

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


#pragma once

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

#include <vector>

#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>

#include <tbb/spin_rw_mutex.h>

struct DtFeatureSetSinkCallbackRecordTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetSinkCallbackRecordTag);

struct DtFeatureSetSinkRemoveFeatureTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetSinkRemoveFeatureTag);

struct DtFeatureSetSinkAddFeatureTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetSinkAddFeatureTag);

struct DtFeatureSetSinkGeometryFilterAdderTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetSinkGeometryFilterAdderTag);

struct DtFeatureSetSinkAddFeatureFactoryTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetSinkAddFeatureFactoryTag);

struct DtFeatureSetSinkRemoveCallbackTag { };
DT_DEFINE_OBJECT_DEBUGGER_NAME(DtFeatureSetSinkRemoveCallbackTag);

namespace MAKVRinTerra
{
   template <typename FS>
   class DT_DLL_features DtFilteredFeatureSet
      : public FS
      , public DtObjectDebugger< DtFilteredFeatureSet<FS> >
   {
   public:
      using FS::filter;

      typedef FS FeatureSet;
      typedef typename FeatureSet::Feature         Feature;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;
      typedef typename FeatureSet::DetachCallback  DetachCallback;
      typedef typename FeatureSet::LoadedCallback  LoadedCallback;
      typedef typename FS::Visitor                 Visitor;
      typedef typename FS::ConstVisitor            ConstVisitor;

      DtFilteredFeatureSet(FS* fs, const DtQuery&, const boost::optional<DtFeatureGeometry>&);

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

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

   protected:
      explicit DtFilteredFeatureSet(const DtFilteredFeatureSet&);

      struct Caller;

      class Wrapper;
      class ConstWrapper;

      std::auto_ptr<FS> myFeatureSet;
      DtQuery myQuery;
      boost::optional<DtFeatureGeometry> myGeometry;
      bool myEmptyFlag;
   };

   template <typename FS>
   class DT_DLL_features DtEmptyFeatureSet
      : public FS
      , public DtObjectDebugger< DtEmptyFeatureSet<FS> >
   {
   public:
      using FS::filter;

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

      DtEmptyFeatureSet();

      std::string label() const;
      void forEachFeatureParallel(const ForEachFunction&) const;
      DetachCallback forEachFeatureAsync(const ForEachFunction& func) const;
      DtEmptyFeatureSet* filter(const DtQuery&, const boost::optional<DtFeatureGeometry>&, DtLoadType) const;
      DtEmptyFeatureSet* clone() const;
      bool loaded(double = 0.0) const;
      DetachCallback addLoadedCallback(const LoadedCallback&) const;
      unsigned numberOfFeatures() const;
      bool empty() const { return true; }
   };

   template <typename FS, typename F>
   class DT_DLL_features DtSinkFeatureSet
      : public FS
      , public DtObjectDebugger< DtSinkFeatureSet<FS,F> >
      , public boost::enable_shared_from_this< DtSinkFeatureSet<FS,F> >
      , boost::noncopyable
   {
   public:
      using FS::filter;

      typedef DtSinkFeatureSet Base;

      typedef boost::shared_ptr<DtSinkFeatureSet> Ptr;

      typedef FS                                  FeatureSet;
      typedef typename FeatureSet::Feature        Feature;
      typedef typename boost::shared_ptr<F>       FeaturePtr;

      typedef typename FeatureSet::ForEachFunction ForEachFunction;
      typedef typename FeatureSet::DetachCallback  DetachCallback;
      typedef typename FeatureSet::LoadedCallback  LoadedCallback;

      typedef boost::function<void (const typename Feature::Ptr&)> ForEachPtrFunction;


      template <typename Factory>
      static Ptr Make(const DtSinkFeatureSet& fs, const Factory& factory)
      {
         typedef AddFeatureFactory<Factory> FactoryType;

         Ptr sink(new DtSinkFeatureSet(fs.clone()));

         if (sink->input && !sink->input->empty())
            fs.forEachFeaturePtrAsync(FactoryType(sink, factory));

         return sink;
      }

      static Ptr Make(FeatureSet*);

      static Ptr Make(const DtSinkFeatureSet&, const DtFeatureGeometry&);

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

      virtual DetachCallback forEachFeaturePtrAsync(const ForEachPtrFunction&) const;

      struct ParallelCaller;
      struct AddFeature;
      template <typename Function> struct AddFeatureFactory;
      struct GeometryFilterAdder;
      struct RemoveFeature;
      struct ParallelAdder;
      struct RemoveCallback;

   protected:
      explicit DtSinkFeatureSet(FS*);

      struct CallbackRecord;
      typedef boost::shared_ptr<CallbackRecord> CallbackRecordPtr;

      struct RefRecord;
      struct PtrRecord;

      typedef tbb::spin_rw_mutex Mutex;

      typedef std::list<CallbackRecordPtr> FeatureCallbacks;
      typedef std::list<FeaturePtr>        FeatureSequence;

      virtual void addFeatureImpl(const FeaturePtr&);
      virtual void removeFeature(typename FeatureSequence::iterator i);
      virtual DetachCallback addCallback(const CallbackRecordPtr& rec);
      virtual void removeCallback(typename FeatureCallbacks::iterator i);

      mutable Mutex mutex;
      const boost::scoped_ptr<FS> input;  
      FeatureCallbacks featureCallbacks;  
      FeatureSequence features;           
      bool deleted;
   };

   template <typename FS>
   class DT_DLL_features DtDeletingSinkFeatureSet
      : public DtSinkFeatureSet<FS, DtFeatureWrapper<typename FS::Feature> >
      , boost::noncopyable
   {
   public:
      typedef DtSinkFeatureSet<FS, DtFeatureWrapper<typename FS::Feature> > Base;
      typedef typename Base::AddFeature AddFeature;

      typedef typename Base::FeatureSet FeatureSet;
      typedef typename Base::Feature    Feature;
      typedef typename Base::FeaturePtr FeaturePtr;

      typedef boost::shared_ptr<DtDeletingSinkFeatureSet>       Ptr;
      typedef boost::shared_ptr<const DtDeletingSinkFeatureSet> CPtr;

      static Ptr Make(FS*);

      ~DtDeletingSinkFeatureSet();

      Ptr shared_from_this();
      CPtr shared_from_this() const;

   protected:
      explicit DtDeletingSinkFeatureSet(FS*);
   };

   template <typename FS>
   class DT_DLL_features DtSourceFeatureSet
      : public DtSinkFeatureSet<FS>
      , public DtObjectDebugger< DtSourceFeatureSet<FS> >
      , boost::noncopyable
   {
   public:
      typedef FS                                        FeatureSet;
      typedef typename DtSinkFeatureSet<FS>::Feature    Feature;
      typedef typename DtSinkFeatureSet<FS>::FeaturePtr FeaturePtr;

      typedef typename FeatureSet::ForEachFunction ForEachFunction;
      typedef typename FeatureSet::DetachCallback  DetachCallback;

      typedef typename boost::shared_ptr<DtSourceFeatureSet> Ptr;

      static Ptr Make(FS* input = 0);

      FeaturePtr addFeature(Feature* f)          { return addFeaturePtr(f); }
      FeaturePtr addFeature(const Feature& f)    { return addFeaturePtr(f.clone()); }
      FeaturePtr addFeatureRef(const Feature& f) { return addFeature(f); }

      std::string label() const;


      virtual FeaturePtr addFeaturePtr(Feature* feature);

   protected:
      explicit DtSourceFeatureSet(FS* input = 0);
   };
}

DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtFilteredFeatureSet);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtEmptyFeatureSet);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtSinkFeatureSet);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtSourceFeatureSet);