transformFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/attributeConfigParser.h>
#include <features/feature.h>
#include <features/featureSet.h>

#include <boost/spirit/include/qi.hpp>
#include <boost/phoenix/operator.hpp>
#include <boost/ptr_container/ptr_map.hpp>

namespace MAKVRinTerra
{
   class DT_DLL_features DtTransformFeatureSet : public DtFeatureSet
   {
   public:
      typedef DtAttributeConfigParser::TransformVector   TransformVector;
      typedef DtAttributeConfigParser::DtQueryMap        QueryMap;

      struct Record
      {
         typedef std::vector<Record> Vector;

         DtFeatureTransform transform;
         DtQuery query;

         boost::optional<DtFeature::Attribute> attribute;

         Record(const DtFeatureTransform& transform, const DtQuery& q);
      };

      typedef std::map<DtFeature::Key::String, Record::Vector> TransformMap;

      class DT_DLL_features FeatureWrapper;

      explicit DtTransformFeatureSet(
         DtFeatureSet* g,
         const QueryMap& queries = QueryMap(), const TransformVector& transforms = TransformVector());

      explicit DtTransformFeatureSet(
         DtFeatureSet* fs, DtAttributeConfigParser& parser, const TransformVector& transforms = TransformVector());

      virtual std::string label() const override;
      virtual void forEachFeatureParallel(const ForEachFunction&) const override;
      virtual DetachCallback forEachFeatureAsync(const ForEachFunction&) const override;
      virtual DtFeatureSet* filter(
         const DtQuery& q, const boost::optional<DtFeatureGeometry>&, DtLoadType) const override;
      virtual DtTransformFeatureSet* clone() const override;
      virtual bool loaded(double) const override;
      virtual DetachCallback addLoadedCallback(const LoadedCallback&) const override;
      virtual unsigned numberOfFeatures() const override;
      virtual bool elided() const override;
      virtual bool empty() const override;
      virtual bool isIndexed() const override;
      virtual bool isCacheable(const boost::optional<DtFeatureGeometry>& area) const override;
      virtual void cacheEstimate(
         double& time, double& size, const boost::optional<DtFeatureGeometry>& area) const override;
      virtual void cacheData(
         const boost::optional<DtFeatureGeometry>& area, DtFeatureCacheProgressCallback* progress) const override;

      const QueryMap& queryMap() const;
      const TransformVector& transforms() const;

      bool addTransform(DtQuery query, const DtFeatureTransform& transform, bool back=true);
      bool addTransform(
         const QueryMap& queries, const DtFeatureTransform& transform, bool back=true);
      bool addTransform(
         DtAttributeConfigParser& parser, const DtFeatureTransform&, bool back=true);

      const DtFeatureSet& input() const;

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

   protected:
      DtTransformFeatureSet(DtFeatureSet*, const TransformMap&);

      const std::unique_ptr<DtFeatureSet> myFeatures;

      TransformMap myTransforms;
   };

   class DtTransformFeatureSet::FeatureWrapper
      : public DtFeatureRefWrapper<DtFeature>
   {
   public:
      FeatureWrapper(const DtFeature& feature, const TransformMap&);

      virtual DtFeature* clone() const override;

      virtual boost::optional<Attribute> attribute(const Key& key) const override;

      virtual void forEachAttribute(ForEachFunction f) const override;
      void forEachTransformAttribute(ForEachFunction f) const;

      virtual unsigned numberOfAttributes(const Key::String& name) const override;

   private:
      const TransformMap& myTransforms;
   };
}