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 F, typename FS>
   class DT_DLL_features DtFeatureSetList;

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

      typedef DtFeatureSetTemplate FeatureSet;

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

      template <
         typename WrappedFeature = Feature,
         template <typename> class PtrTemplate = boost::scoped_ptr>
      class Wrapper;

      typedef Wrapper<Feature, boost::scoped_ptr>  ScopedWrapper;

      typedef Wrapper<Feature, std::auto_ptr>      AutoWrapper;

      typedef Wrapper<Feature, boost::shared_ptr>  SharedWrapper;

      typedef DtFeatureSetList<F, FeatureSet> List;

      class DT_DLL_features Filtered;
      class DT_DLL_features Empty;
      class DT_DLL_features Storage;

      virtual ~DtFeatureSetTemplate();

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

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

      virtual DtQuery schema() 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 unsigned numberOfFeatures() const;
   };

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

   template <typename F, typename FS>
   class DtFeatureSetList : public DtFeatureSetTemplate<F>
   {
   public:
      typedef typename DtFeatureSetTemplate<F>::ForEachFunction ForEachFunction;

      DtFeatureSetList();
      ~DtFeatureSetList();

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

      unsigned size() const;

      void forEachFeature(ForEachFunction func, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      DtFeatureSetList* filter(const DtQuery&, DtLoadType) const;
      DtFeatureSetList* clone() const;
      DtQuery schema() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;

   protected:
      explicit DtFeatureSetList(const DtFeatureSetList&);

      typedef std::list<FS*> PtrList;

      PtrList myFeatures;
      DtQuery mySchema;
   };

   template <typename F>
   class DtFeatureSetTemplate<F>::Filtered : public DtFeatureSetTemplate<F>
   {
   public:
      typedef typename DtFeatureSetTemplate<F>::ForEachFunction ForEachFunction;

      Filtered(DtFeatureSetTemplate<F>* fs, const DtQuery &);
      Filtered(const DtFeatureSetTemplate&, const DtQuery&);

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

      void forEachFeature(ForEachFunction func, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      DtFeatureSetTemplate<F>* filter(const DtQuery&, DtLoadType) const;
      Filtered* clone() const;
      DtQuery schema() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;

   protected:
      explicit Filtered(const Filtered&);

   private:
      struct Caller;

      boost::scoped_ptr<DtFeatureSetTemplate> myFeatureSet;
      DtQuery myQuery;
      DtQuery mySchema;
   };

   template <typename F>
   class DtFeatureSetTemplate<F>::Empty : public DtFeatureSetTemplate<F>
   {
   public:
      typedef typename DtFeatureSetTemplate<F>::ForEachFunction ForEachFunction;

      void forEachFeature(ForEachFunction, DtWaitType) const;
      Empty* filter(const DtQuery&, DtLoadType) const;
      Empty* clone() const;
      DtQuery schema() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;
   };

   template <typename F>
   class DtFeatureSetTemplate<F>::Storage : public DtFeatureSetTemplate<F>
   {
   public:
      typedef typename DtFeatureSetTemplate<F>::ForEachFunction ForEachFunction;

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

      static DtFeatureSetTemplate* Make(FeatureSet*);

      explicit Storage(const FeatureSet&);
      explicit Storage(const DtQuery&);

      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      DtQuery schema() const;
      Storage* clone() const;
      bool loaded(double = 0.0) const;
      unsigned numberOfFeatures() const;

      void addFeature(const F& feature);

   protected:
      struct AddFeature;
      struct ParallelCaller;

      explicit Storage(const Storage&);

      DtQuery mySchema;
      boost::shared_ptr<FeatureVector> myFeatures;
   };

   template <typename F>
   template <typename Wrapped, template <typename> class PtrTemplate>
   class DtFeatureSetTemplate<F>::Wrapper : public DtFeatureSetTemplate<F>
   {
   public:
      typedef typename DtFeatureSetTemplate<F>::ForEachFunction ForEachFunction;
     typedef DtFeatureSetTemplate<F> FeatureSet;

      typedef Wrapped                        WrappedFeature;
      typedef DtFeatureSetTemplate<Wrapped>  WrappedFeatureSet;
      typedef PtrTemplate<WrappedFeatureSet> WrappedPtr;

      explicit Wrapper(const WrappedFeatureSet& fs)
         : mySet(fs.clone())
      {
      }

      explicit Wrapper(WrappedFeatureSet* fs)
         : mySet(fs)
      {
      }

      template <typename PtrType>
      explicit Wrapper(PtrType fs)
         : mySet(fs)
      {
      }

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

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

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

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

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

      FeatureSet* filter(const DtQuery& query, DtLoadType load) const
      {
         assert(mySet.get());
         return new Wrapper(mySet->filter(query,load));
      }

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

      DtQuery schema() const
      {
         assert(mySet.get());
         return mySet->schema();
      }

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

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

   protected:
      WrappedPtr mySet;
   };

   template <typename F>
   template <template <typename> class PtrTemplate>
   class DtFeatureSetTemplate<F>::Wrapper<F,PtrTemplate>
      : public DtFeatureSetTemplate<F>
   {
   public:
      typedef typename DtFeatureSetTemplate<F>::ForEachFunction ForEachFunction;
     typedef DtFeatureSetTemplate<F> FeatureSet;
     
      typedef F                        WrappedFeature;
      typedef DtFeatureSetTemplate<F>  WrappedFeatureSet;
      typedef PtrTemplate<FeatureSet>  WrappedPtr;

      explicit Wrapper(const WrappedFeatureSet& fs)
         : mySet(fs.clone())
      {
      }

      explicit Wrapper(WrappedFeatureSet* fs)
         : mySet(fs)
      {
      }

      template <typename PtrType>
      explicit Wrapper(PtrType fs)
         : mySet(fs)
      {
      }

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

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

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

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

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

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

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

      DtQuery schema() const
      {
         assert(mySet.get());
         return mySet->schema();
      }

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

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

   protected:
      WrappedPtr mySet;
   };

   typedef DtFeatureSetTemplate<DtFeature>      DtFeatureSet;
}