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/spirit/include/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());

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

      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;

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

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

      boost::scoped_ptr<DtFeatureSet> myFeatures;

      TransformMap myTransforms;
   };

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

      DtFeature* clone() const;

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

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

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

   private:
      const TransformMap& myTransforms;
   };
}