otbOGRDataSourceWrapper.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2024 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#ifndef otbOGRDataSourceWrapper_h
#define otbOGRDataSourceWrapper_h
 
#include <string>
 
// to implement copy_const
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#include <boost/mpl/if.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/noncopyable.hpp>
#pragma GCC diagnostic pop
#else
#include <boost/mpl/if.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/noncopyable.hpp>
#endif
 
#include "itkDataObject.h"
#include "itkMacro.h"         // itkNewMacro
#include "itkObjectFactory.h" // that should have been included by itkMacro.h
 
#include "otbOGRLayerWrapper.h"
#include "otbOGRExtendedFilenameToOptions.h"
 
class OGRLayer;
class OGRSpatialReference;
class OGRGeometry;
// #include "ogr_core.h" // OGRwkbGeometryType, included from Layer
 
namespace otb
{
namespace ogr
{
#include "OTBGdalAdaptersExport.h"
 
class OTBGdalAdapters_EXPORT DataSource : public itk::DataObject, public boost::noncopyable
{
public:
  typedef DataSource                    Self;
  typedef itk::DataObject               Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  typedef OGRExtendedFilenameToOptions FileNameHelperType;
 
  itkNewMacro(Self);
  itkTypeMacro(DataSource, DataObject);
 
 
  struct Modes
  {
    enum type
    {
      Invalid,
      Read,                   
      Overwrite,              
      Update_LayerOverwrite,  
      Update_LayerUpdate,     
      Update_LayerCreateOnly, 
      MAX__
    };
  };
 
  static Pointer New(std::string const& datasourcename, Modes::type mode = Modes::Read);
 
  static Pointer New(GDALDataset* sourcemode, Modes::type mode = Modes::Read, const std::vector<std::string>& layerOptions = std::vector<std::string>());
 
#if 0
  void SetProjectionRef(const std::string& projectionRef);
  std::string GetProjectionRef() const;
#endif
 
 
  bool Clear();
 
 
  template <class Value>
  class layer_iter : public boost::iterator_facade<layer_iter<Value>, Value, boost::random_access_traversal_tag, Value>
  {
    struct enabler
    {
    };
 
    typedef typename boost::mpl::if_<boost::is_const<Value>, otb::ogr::DataSource const, otb::ogr::DataSource>::type container_type;
 
  public:
    layer_iter(container_type& datasource, size_t index);
    layer_iter();
 
    template <class OtherValue>
    layer_iter(layer_iter<OtherValue> const& other, typename boost::enable_if<boost::is_convertible<OtherValue*, Value*>, enabler>::type = enabler());
 
  private:
    friend class boost::iterator_core_access;
    template <class>
    friend class layer_iter;
 
    template <class OtherValue>
    bool equal(layer_iter<OtherValue> const& other) const;
    void  increment();
    Value dereference() const;
 
    container_type* m_DataSource;
    size_t          m_index;
  };
 
  template <class>
  friend class layer_iter;
  typedef layer_iter<Layer>       iterator;
  typedef layer_iter<Layer const> const_iterator;
 
  const_iterator begin() const
  {
    return cbegin();
  }
  const_iterator end() const
  {
    return cend();
  }
  const_iterator cbegin() const;
  const_iterator cend() const;
  iterator       begin();
  iterator       end();
 
  int Size(bool doForceComputation) const;
 
  std::string GetGlobalExtent(double& ulx, double& uly, double& lrx, double& lry, bool force = false) const;
 
  OGREnvelope GetGlobalExtent(bool force = false, std::string* outwkt = nullptr) const;
 
  void Graft(const itk::DataObject* data) override;
 
  void Reset(GDALDataset* source);
 
 
  Layer CreateLayer(std::string const& name, OGRSpatialReference* poSpatialRef = nullptr, OGRwkbGeometryType eGType = wkbUnknown,
                    std::vector<std::string> const& papszOptions = std::vector<std::string>());
 
  void DeleteLayer(size_t i);
 
  Layer CopyLayer(Layer& srcLayer, std::string const& newName, std::vector<std::string> const& papszOptions = std::vector<std::string>());
 
 
  int GetLayersCount() const;
 
  Layer GetLayer(size_t i);
 
  Layer const GetLayer(size_t i) const;
 
  Layer GetLayer(std::string const& name);
 
  Layer const GetLayer(std::string const& name) const;
 
  Layer GetLayerChecked(size_t i);
 
  Layer const GetLayerChecked(size_t i) const;
 
  Layer GetLayerChecked(std::string const& name);
 
  Layer const GetLayerChecked(std::string const& name) const;
 
  Layer ExecuteSQL(std::string const& statement, OGRGeometry* poSpatialFilter, char const* pszDialect);
 
 
 
  struct boolean
  {
    int i;
  };
  operator int boolean::*() const
  {
    return m_DataSource ? &boolean::i : nullptr;
  }
 
  void SyncToDisk();
 
  bool HasCapability(std::string const& capabilityName) const;
 
  GDALDataset& ogr();
 
  void SetLayerCreationOptions(const std::vector<std::string>& options);
  void AddLayerCreationOptions(std::vector<std::string> options);
  const std::vector<std::string>& GetLayerCreationOptions() const;
 
protected:
  DataSource();
 
  DataSource(GDALDataset* source, Modes::type mode, const std::vector<std::string>& layerOption = std::vector<std::string>());
 
  ~DataSource() override;
 
  static Pointer OpenDataSource(std::string const& datasourceName, Modes::type mode);
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
private:
  OGRLayer* GetLayerUnchecked(size_t i);
 
  OGRLayer* GetLayerUnchecked(size_t i) const;
 
  bool IsLayerModifiable(size_t i) const;
  bool IsLayerModifiable(std::string const& name) const;
 
  size_t GetLayerID(std::string const& name) const;
  int GetLayerIDUnchecked(std::string const& name) const;
 
  std::string GetDatasetDescription() const;
 
private:
  GDALDataset*             m_DataSource;
  std::vector<std::string> m_LayerOptions;
  Modes::type              m_OpenMode;
  int                      m_FirstModifiableLayerID;
}; // end class DataSource
}
} // end namespace otb::ogr
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbOGRDataSourceWrapper.hxx"
#endif
 
#endif // otbOGRDataSourceWrapper_h