featureSet.h

Go to the documentation of this file.

#pragma once

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

#include <boost/function.hpp>
#include <vector>
#include <memory>

namespace MAKVRinTerra
{
   class DtFeature;

   enum DtWaitType
   {
      BLOCK,
      DO_NOT_BLOCK
   };

   enum DtLoadType
   {
      LOAD,
      DO_NOT_LOAD
   };

   template <
      typename FS,
      template <typename> class PtrTemplate = boost::scoped_ptr,
      typename InnerFS = FS>
   class DtFeatureSetWrapper;

   template <typename FS, typename InnerFS = FS>
   class DtSharedFeatureSetWrapper;

   template <typename FS>
   class DT_DLL_features DtFeatureSetList;

   template <typename FS>
   class DT_DLL_features DtFilteredFeatureSet;

   template <typename FS>
   class DT_DLL_features DtEmptyFeatureSet;

   template <typename FS>
   class DT_DLL_features DtStorageFeatureSet;

   template <typename F>
   class DT_DLL_features DtFeatureSetTemplate : boost::noncopyable
   {
   public:
      typedef F Feature;

      typedef DtFeatureSetTemplate FeatureSet;

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

      typedef DtFeatureSetWrapper<FeatureSet, boost::scoped_ptr>  ScopedWrapper;

      typedef DtFeatureSetWrapper<FeatureSet, std::auto_ptr>      AutoWrapper;

      typedef DtSharedFeatureSetWrapper<FeatureSet>               SharedWrapper;

      typedef DtFeatureSetList<FeatureSet>      List;
      typedef DtFilteredFeatureSet<FeatureSet>  Filtered;
      typedef DtEmptyFeatureSet<FeatureSet>     Empty;
      typedef DtStorageFeatureSet<FeatureSet>   Storage;

      template <typename FS>
      static DtFeatureSetTemplate* Wrap(FS* fs)
      {
         typedef DtFeatureSetWrapper<FeatureSet, boost::scoped_ptr, FS> Wrapper;
         return new Wrapper(fs);
      }

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

      virtual ~DtFeatureSetTemplate();

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

      virtual void forEachFeature(ForEachFunction func, DtWaitType wait) const = 0;

      virtual void forEachFeatureParallel(ForEachFunction func, DtWaitType wait) const;

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

      virtual DtFeatureSetTemplate* clone() const = 0;

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

      virtual bool empty() const;

      virtual bool isIndexed() const;

      virtual unsigned numberOfFeatures() const;


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

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


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

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

   template <typename FS>
   class DT_DLL_features DtFeatureSetList : public FS
   {
   public:
      typedef FS                                   FeatureSet;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;
      typedef typename FS::Visitor                 Visitor;
      typedef typename FS::ConstVisitor            ConstVisitor;

      DtFeatureSetList(std::string label = std::string());
      ~DtFeatureSetList();

      void setLabel(std::string);

      void add(FS* fs);
      void add(const FS&);
      void add(std::auto_ptr<FS>);

      std::string label() const;
      void forEachFeature(ForEachFunction func, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      DtFeatureSetList* filter(const DtQuery&, DtLoadType) const;
      DtFeatureSetList* clone() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;
      bool empty() const;
      bool isIndexed() const;

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

   protected:
      explicit DtFeatureSetList(const DtFeatureSetList&);

      typedef std::list<FS*> PtrList;

      PtrList myFeatures;
      std::string myLabel;
   };

   template <typename FS>
   class DT_DLL_features DtFilteredFeatureSet : public FS
   {
   public:
      typedef FS FeatureSet;
      typedef typename FeatureSet::Feature         Feature;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;
      typedef typename FS::Visitor                 Visitor;
      typedef typename FS::ConstVisitor            ConstVisitor;

      struct Caller;

      DtFilteredFeatureSet(FS* fs, const DtQuery &);
      DtFilteredFeatureSet(const FS&, const DtQuery&);

      const FS& filteredFeatureSet() const;
      const DtQuery& query() const;

      std::string label() const;
      void forEachFeature(ForEachFunction func, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      FS* filter(const DtQuery&, DtLoadType) const;
      DtFilteredFeatureSet* clone() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;
      bool empty() const;
      bool isIndexed() const;

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

   protected:
      explicit DtFilteredFeatureSet(const DtFilteredFeatureSet&);

      boost::scoped_ptr<FS> myFeatureSet;
      DtQuery myQuery;
   };

   template <typename FS>
   class DT_DLL_features DtEmptyFeatureSet : public FS
   {
   public:
      typedef FS FeatureSet;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;

      std::string label() const;
      void forEachFeature(ForEachFunction, DtWaitType) const;
      DtEmptyFeatureSet* filter(const DtQuery&, DtLoadType) const;
      DtEmptyFeatureSet* clone() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;
      bool empty() const { return true; }
   };

   template <typename FS>
   class DT_DLL_features DtStorageFeatureSet : public FS
   {
   public:
      typedef FS FeatureSet;
      typedef typename FeatureSet::Feature Feature;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;

      typedef std::vector<typename Feature::CPtr> FeatureVector;

      static FS* Make(FeatureSet*);

      explicit DtStorageFeatureSet(const FS&);
      explicit DtStorageFeatureSet();

      std::string label() const;
      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      DtStorageFeatureSet* clone() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;
      bool empty() const { return myFeatures->empty(); }

      void addFeature(const Feature& feature);

   protected:
      struct AddFeature;
      struct ParallelCaller;

      explicit DtStorageFeatureSet(const DtStorageFeatureSet&);

      boost::shared_ptr<FeatureVector> myFeatures;
      std::string myLabel;
   };

   template <typename FS, template <typename> class PtrTemplate, typename InnerFS>
   class DtFeatureSetWrapper : public FS
   {
   public:
      typedef FS FeatureSet;
      typedef typename FeatureSet::Feature Feature;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;

      typedef PtrTemplate<InnerFS> WrappedPtr;

      explicit DtFeatureSetWrapper(InnerFS* fs)
         : mySet(fs)
      {
      }

      explicit DtFeatureSetWrapper(WrappedPtr fs)
         : mySet(fs)
      {
      }

      bool isSet() const
      {
         return mySet.get();
      }

      void set(InnerFS* fs)
      {
         mySet.reset(fs);
      }

      template <typename PtrType>
      void set(PtrType fs)
      {
         mySet = fs;
      }

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

      void forEachFeature(ForEachFunction func, DtWaitType wait) const
      {
         mySet->forEachFeature(func,wait);
      }

      void forEachFeatureParallel(ForEachFunction func, DtWaitType wait) const
      {
         mySet->forEachFeatureParallel(func,wait);
      }

      FeatureSet* filter(const DtQuery& query, DtLoadType load) const
      {
         return FeatureSet::Wrap(mySet->filter(query,load));
      }

      FeatureSet* clone() const
      {
         return new DtFeatureSetWrapper(mySet->clone());
      }

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

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

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

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

   protected:
      WrappedPtr mySet;
   };

   template <typename FS, template <typename> class PtrTemplate>
   class DtFeatureSetWrapper<FS,PtrTemplate,FS> : public FS
   {
   public:
      typedef FS FeatureSet;
      typedef typename FeatureSet::Feature Feature;
      typedef typename FeatureSet::ForEachFunction ForEachFunction;

      typedef PtrTemplate<FS> WrappedPtr;

      explicit DtFeatureSetWrapper(FS* fs)
         : mySet(fs)
      {
      }

      explicit DtFeatureSetWrapper(WrappedPtr fs)
         : mySet(fs)
      {
      }

      bool isSet() const
      {
         return mySet.get();
      }

      void set(FS* fs)
      {
         mySet.reset(fs);
      }

      template <typename PtrType>
      void set(PtrType fs)
      {
         mySet = fs;
      }

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

      void forEachFeature(ForEachFunction func, DtWaitType wait) const
      {
         mySet->forEachFeature(func,wait);
      }

      void forEachFeatureParallel(ForEachFunction func, DtWaitType wait) const
      {
         mySet->forEachFeatureParallel(func,wait);
      }

      FeatureSet* filter(const DtQuery& query, DtLoadType load) const
      {
         return mySet->filter(query,load);
      }

      FeatureSet* clone() const
      {
         assert(mySet.get());
         return mySet->clone();
      }

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

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

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

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

   protected:
      WrappedPtr mySet;
   };

   template <typename FS, typename InnerFS>
   class DtSharedFeatureSetWrapper
      : public DtFeatureSetWrapper<FS, boost::shared_ptr, InnerFS>
   {
      typedef DtFeatureSetWrapper<FS, boost::shared_ptr, InnerFS> Parent;
      typedef typename Parent::WrappedPtr WrappedPtr;

   public:
      explicit DtSharedFeatureSetWrapper(InnerFS* fs)
         : Parent(fs)
      {
      }

      explicit DtSharedFeatureSetWrapper(WrappedPtr fs)
         : Parent(fs)
      {
      }

      FS* clone() const
      {
         assert(this->mySet.get());
         return new DtSharedFeatureSetWrapper(this->mySet);
      }
   };

   typedef DtFeatureSetTemplate<DtFeature>      DtFeatureSet;
}