ogrFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/featuresDefines.h>
#include <features/featureSetList.h>
#include <features/featureSet.h>
#include <features/feature.h>
#include <features/query.h>

#include <vrfutil/taggedException.h>

#include <tbb/spin_rw_mutex.h>

#include <gdal.h>
#include <set>

class OGRFeature;
class GDALDataset;

namespace MAKVRinTerra
{
   class DT_DLL_features DtOgrFeature : public DtFeature
   {
   public:
      typedef std::vector<DtFeatureGeometry> GeometryVector;

      DtOgrFeature(std::shared_ptr<OGRFeature> feature, DtFeatureGeometry geometry, DtFeature::CPtr defaults);

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

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

      virtual DtFeatureGeometry geometry() const override;

      virtual void forEachAttribute(ForEachFunction) const override;

      virtual DetachCallback addDeleteCallback(const DeleteCallback&) const override { return DetachCallback(); }

      virtual bool isDeleted() const override {
         return false;
      }

   private:
      std::shared_ptr<OGRFeature> myFeature;
      DtFeatureGeometry myGeometry;
      DtFeature::CPtr myDefaults;
   };

   class DT_DLL_features DtOgrDataSource : public DtFeatureSet::List
   {
   public:
      typedef std::shared_ptr<DtOgrDataSource> Ptr;
      typedef std::shared_ptr<GDALDataset> GDALPtr;

      static DtFeatureSet* Make(std::string file, std::string layerName = "");

      explicit DtOgrDataSource(std::string file, std::string layerName = "");

      virtual std::string label() const override;
      virtual bool isIndexed() const override;

   protected:
      std::string myFile;
      GDALPtr myDataSource;
   };

   class DT_DLL_features DtOgrLayer : public DtFeatureSet
   {
   public:
      typedef DtTaggedException<DtOgrLayer> Exception;
      typedef std::shared_ptr<GDALDataset> GDALPtr;

      DtOgrLayer(const std::string& path, int layerNum, bool indexed, const std::string& srcPath,
         const std::string& configLayerName = "");

      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& query, const boost::optional<DtFeatureGeometry>&, DtLoadType) const override;
      virtual DtFeatureSet* clone() const override;
      virtual bool loaded(double) const override;
      virtual DetachCallback addLoadedCallback(const LoadedCallback&) const override;
      virtual bool elided() const override;
      virtual bool empty() const override;
      virtual bool isIndexed() const override;

   protected:
      class GDALDataSource
      {
      public:
         GDALDataSource(const std::string&);

         GDALPtr getDataSource() const;

      protected:
         mutable tbb::spin_rw_mutex myThreadedGDALDataSetsMutex;
         typedef std::map<unsigned int, GDALPtr> ThreadedGDALDataSets;
         mutable ThreadedGDALDataSets myThreadedGDALDataSets;

         std::string myDatasetFile;
      };

   protected:
      explicit DtOgrLayer(const DtOgrLayer& from);
      DtOgrLayer(const DtOgrLayer& from, boost::optional<DtFeatureGeometry> filter);

      typedef std::set<DtFeature::Key> AttributeSet;

      std::string myDatasetFile;
      DtProj::CPtr myGeometryProjection;
      boost::optional<DtFeatureGeometry> myGeometryFilter;
      AttributeSet myAttributes;
      int myLayerNumber;
      std::string myLayerName;
      std::string myConfigLayerName;
      DtFeature::CPtr myDefaults;
      bool myIndexedFlag;
      std::string myLabel;

      std::shared_ptr<GDALDataSource> myGDALDataSource;
   };
}