ogrFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/featuresDefines.h>
#include <features/featureSetList.h>

#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>

#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(
         boost::shared_ptr<OGRFeature> feature,
         DtFeatureGeometry geometry,
         DtFeature::CPtr defaults);

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

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

      DtFeatureGeometry geometry() const;

      void forEachAttribute(ForEachFunction) const;

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

      bool isDeleted() const
      {
         return false;
      }

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

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

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

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

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

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

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

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

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

   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;

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