areaFeature.h

Go to the documentation of this file.

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


#pragma once

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

namespace MAKVRinTerra
{
   class DT_DLL_features DtAreaFeature
      : public DtFeature
      , public DtObjectDebugger<DtAreaFeature>
   {
   public:

      static const char* TypeName;

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

      DtAreaFeature* clone() const = 0;

      virtual DtFeatureGeometry::Area area() const;
   };

   typedef DtFeatureSetTemplate<DtAreaFeature> DtAreaFeatureSet;

   class DT_DLL_features DtAreaFeatureSetAdapter : public DtAreaFeatureSet
   {
   public:
      struct DT_DLL_features Config
      {
         std::string type;

         double buffer;

         bool unioned;

         explicit Config(
            const std::string& type, double buffer=0, bool unioned=false);

         bool operator<(const Config& other) const;
      };

      struct AreaCollector;

      explicit DtAreaFeatureSetAdapter(
         DtFeatureSet* fs, const DtProj& proj, const Config& cfg);

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

   protected:
      explicit DtAreaFeatureSetAdapter(
         DtFeatureSet* fs, const DtAreaFeatureSetAdapter& from);

      boost::scoped_ptr<DtFeatureSet> myFeatureSet;
      DtProj::CPtr myProjection;
      Config myConfig;
   };

   template <typename T>
   class DtFeatureWrapper<DtAreaFeature,T>
      : public DtAreaFeature
      //, public DtObjectDebugger< DtFeatureWrapper<DtAreaFeature,T> >
   {
   public:
      DtFeatureWrapper* clone() const
      {
         return new DtFeatureWrapper(*this);
      }

      DtFeatureGeometry::Area area() const
      {
         return myWrapper.wrappedFeature().area();
      }

      DtFeatureGeometry geometry() const
      {
         return area();
      }

      void forEachAttribute(ForEachFunction func) const
      {
         myWrapper.forEachAttribute(func);
      }

      unsigned numberOfAttributes(const Key::String& str) const
      {
         return myWrapper.numberOfAttributes(str);
      }

      boost::optional<Attribute> attribute(const Key& key) const
      {
         return myWrapper.attribute(key);
      }

      DetachCallback addDeleteCallback(const DeleteCallback& callback) const
      {
         return myWrapper.addDeleteCallback(callback);
      }

      bool isDeleted() const
      {
         return myWrapper.isDeleted();
      }

      void setDeleted()
      {
         myWrapper.setDeleted();
      }

      explicit DtFeatureWrapper(const DtFeatureWrapper& from)
         : myWrapper(from.myWrapper)
      {
      }

      explicit DtFeatureWrapper(DtAreaFeature* f)
         : myWrapper(f)
      {
      }

      explicit DtFeatureWrapper(const DtAreaFeature::Ptr& f)
         : myWrapper(f)
      {
      }

      explicit DtFeatureWrapper(const DtAreaFeature& f)
         : myWrapper(f.clone())
      {
      }

   private:
      DtFeatureWrapper<DtFeature, DtAreaFeature> myWrapper;
   };
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtAreaFeature);
DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtAreaFeatureSet);