/******************************************************************************
* $Id$
*
* Project: GDAL/OGR Geography Network support (Geographic Network Model)
* Purpose: GNM general public declarations.
* Authors: Mikhail Gusev (gusevmihs at gmail dot com)
* Dmitry Baryshnikov, polimax@mail.ru
*
******************************************************************************
* Copyright (c) 2014, Mikhail Gusev
* Copyright (c) 2014-2015, NextGIS <info@nextgis.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
****************************************************************************/
#ifndef GNM
#define GNM
#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
#include "ogrsf_frmts.h"
#endif
#include "gnmgraph.h"
// Direction of an edge.
typedef int GNMDirection; // We use int values in order to save them to the
// network data.
// Network's metadata parameters names.
#define GNM_MD_NAME "net_name"
#define GNM_MD_DESCR "net_description"
#define GNM_MD_SRS "net_srs"
#define GNM_MD_VERSION "net_version"
#define GNM_MD_RULE "net_rule"
#define GNM_MD_FORMAT "FORMAT"
#define GNM_MD_FETCHEDGES "fetch_edge"
#define GNM_MD_FETCHVERTEX "fetch_vertex"
#define GNM_MD_NUM_PATHS "num_paths"
#define GNM_MD_EMITTER "emitter"
// TODO: Constants for capabilities.
// #define GNMCanChangeConnections "CanChangeConnections"
typedef enum
{
/** Dijkstra shortest path */ GATDijkstraShortestPath = 1,
/** KShortest Paths */ GATKShortestPath,
/** Recursive Breadth-first search */ GATConnectedComponents
} GNMGraphAlgorithmType;
#if defined(__cplusplus) && !defined(CPL_SUPRESS_CPLUSPLUS)
/**
* General GNM class which represents a geography network of common format.
*
* @since GDAL 2.1
*/
class CPL_DLL GNMNetwork : public GDALDataset
{
public:
GNMNetwork();
virtual ~GNMNetwork();
// GDALDataset Interface
const OGRSpatialReference *GetSpatialRef() const override;
virtual char **GetFileList(void) override;
// GNMNetwork Interface
/**
* @brief Create network system layers
*
* Creates the connectivity (the "network path" of data) over the dataset
* and returns the resulting network.
* NOTE: This method does not create any connections among features
* but creates the necessary set of fields, layers, etc.
* NOTE: After the successful creation the passed dataset must not be
* modified outside (but can be read as usual).
* NOTE: For the common network format the creation is forbidden if the
* passed dataset already has network system layers and OVERWRITE creation
* option is FALSE.
*
* @param pszFilename - A path there the network folder (schema, etc.) will
* be created. The folder (schema, etc.) name get
* options.
* @param papszOptions - create network options. The create options
* specific for gnm driver.
* @return CE_None on success
*/
virtual CPLErr Create(const char *pszFilename, char **papszOptions) = 0;
/**
* @brief Open a network
* @param poOpenInfo GDALOpenInfo pointer
* @return CE_None on success
*/
virtual CPLErr Open(GDALOpenInfo *poOpenInfo) = 0;
/**
* @brief Delete network. Delete all dependent layers
* @return CE_None on success
*/
virtual CPLErr Delete() = 0;
/**
* @brief GetName - a network name. The value provided to create function
* in GNM_MD_NAME key. While creation this value used to create the
* folder or db schema name. But can be changed after creation.
* @return Network name string
*/
virtual const char *GetName() const;
/**
* @brief GetVersion return the network version if applicable
* @return version value
*/
virtual int GetVersion() const
{
return 0;
}
/**
* @brief DisconnectAll method clears the network graph
* @return CE_None on success
*/
virtual CPLErr DisconnectAll() = 0;
/**
* @brief GetFeatureByGlobalFID search all network layers for given feature
* identificator.
* @param nGFID feature identificator.
* @return OGRFeature pointer or NULL. The pointer should be freed via
* OGRFeature::DestroyFeature().
*/
virtual OGRFeature *GetFeatureByGlobalFID(GNMGFID nGFID) = 0;
/**
* @brief Create path between start and end GFIDs.
* @param nStartFID - start identificator
* @param nEndFID - end identificator
* @param eAlgorithm - The algorithm to get path
* @param papszOptions - algorithm specific options
* @return In memory OGRLayer pointer with features constituting
* the shortest path (or paths). The caller have to free
* the pointer via @see ReleaseResultSet().
*/
virtual OGRLayer *GetPath(GNMGFID nStartFID, GNMGFID nEndFID,
GNMGraphAlgorithmType eAlgorithm,
char **papszOptions) = 0;
protected:
/**
* @brief Check if network already exist
* @param pszFilename - path to network (folder or database
* @param papszOptions - create options
* @return TRUE if exist and not overwrite or FALSE
*/
virtual int CheckNetworkExist(const char *pszFilename,
char **papszOptions) = 0;
protected:
//! @cond Doxygen_Suppress
CPLString m_soName;
OGRSpatialReference m_oSRS{};
//! @endcond
};
class GNMRule;
class OGRGNMWrappedResultLayer;
/**
* GNM class which represents a geography network of generic format.
*
* @since GDAL 2.1
*/
class CPL_DLL GNMGenericNetwork : public GNMNetwork
{
public:
GNMGenericNetwork();
virtual ~GNMGenericNetwork();
// GDALDataset Interface
virtual int GetLayerCount() override;
virtual OGRLayer *GetLayer(int) override;
virtual OGRErr DeleteLayer(int) override;
virtual int TestCapability(const char *) override;
virtual OGRLayer *CopyLayer(OGRLayer *poSrcLayer, const char *pszNewName,
char **papszOptions = nullptr) override;
virtual int CloseDependentDatasets() override;
virtual CPLErr FlushCache(bool bAtClosing) override;
// GNMNetwork Interface
virtual CPLErr Create(const char *pszFilename,
char **papszOptions) override = 0;
virtual CPLErr Delete() override;
virtual int GetVersion() const override;
/**
* @brief GetNewGlobalFID increase the global ID counter.
* @return New global feature ID.
*/
virtual GNMGFID GetNewGlobalFID();
/**
* @brief Get the algorithm name
* @param eAlgorithm GNM algorithm type
* @param bShortName Indicator which name to return - short or long
* @return String with algorithm name
*/
virtual CPLString GetAlgorithmName(GNMDirection eAlgorithm,
bool bShortName);
/**
* @brief AddFeatureGlobalFID add the FID <-> Layer name link to fast access
* features by global FID.
* @param nFID - global FID
* @param pszLayerName - layer name
* @return CE_None on success
*/
virtual CPLErr AddFeatureGlobalFID(GNMGFID nFID, const char *pszLayerName);
/**
* @brief Connects two features via third feature (may be virtual, so the
* identificator should be -1). The features may be at the same layer
* or different layers.
* @param nSrcFID - source feature identificator
* @param nTgtFID - target feature identificator
* @param nConFID - connection feature identificator (-1 for virtual
* connection)
* @param dfCost - cost moving from source to target (default 1)
* @param dfInvCost - cost moving from target to source (default 1)
* @param eDir - direction, may be source to target, target to source or
* both. (default - both)
* @return CE_None on success
*/
virtual CPLErr ConnectFeatures(GNMGFID nSrcFID, GNMGFID nTgtFID,
GNMGFID nConFID = -1, double dfCost = 1,
double dfInvCost = 1,
GNMDirection eDir = GNM_EDGE_DIR_BOTH);
/**
* @brief Remove features connection
* @param nSrcFID - source feature identificator
* @param nTgtFID - target feature identificator
* @param nConFID - connection feature identificator
* @return CE_None on success
*/
virtual CPLErr DisconnectFeatures(GNMGFID nSrcFID, GNMGFID nTgtFID,
GNMGFID nConFID);
/**
* @brief Find the corresponding identificator in graph (source, target,
* connector) and remove such connections.
* @param nFID - identificator to find.
* @return CE_None on success
*/
virtual CPLErr DisconnectFeaturesWithId(GNMGFID nFID);
/**
* @brief Change connection attributes. Search the connection by source
* feature identificator, target feature identificator and connection
* identificator.
* @param nSrcFID - source feature identificator
* @param nTgtFID - target feature identificator
* @param nConFID - connection feature identificator
* @param dfCost - new cost moving from source to target
* @param dfInvCost - new cost moving from target to source
* @param eDir - new direction
* @return CE_None on success
*/
virtual CPLErr ReconnectFeatures(GNMGFID nSrcFID, GNMGFID nTgtFID,
GNMGFID nConFID, double dfCost = 1,
double dfInvCost = 1,
GNMDirection eDir = GNM_EDGE_DIR_BOTH);
virtual CPLErr DisconnectAll() override;
virtual OGRFeature *GetFeatureByGlobalFID(GNMGFID nFID) override;
/**
* @brief Create network rule
*
* Creates the rule in the network according to the special syntax. These
* rules are declarative and make an effect for the network when they exist.
* Each rule for layer can be created only if the corresponding layer
* existed and removed when the layer is being deleted.
*
* Rules syntax for the common network format in GNM contains the key words
* (words in capital letters or signs) and the modifiers which refers to the
* network objects. All the following combinations are available:
*
* Notation:
* layer1, layer2, layer3 - a layer names (the corresponding layers must be
* exist;
* field1 - a field name (field must be exist);
* constant1 - any double constant;
* string1 - any string;
*
* Rules describing which layer can be connected or not connected with each
* other, and (optional) which layer must serve as a connector. By default
* all connections are forbidden. But while network creation process the
* rule to allow any connection added. During the connection process each
* rule tested if this connection can be created.
*
* "ALLOW CONNECTS ANY"
* "DENY CONNECTS ANY"
* "DENY CONNECTS layer1 WITH layer2"
* "ALLOW CONNECTS layer1 WITH layer2 VIA layer3"
*
* @param pszRuleStr Rule string which will parsed. If the parsing was
* successful, the rule will start having effect immediately.
* @return CE_None on success.
*/
virtual CPLErr CreateRule(const char *pszRuleStr);
/**
* @brief Delete all rules from network
* @return CE_None on success.
*/
virtual CPLErr DeleteAllRules();
/**
* @brief Delete the specified rule
* @param pszRuleStr - the rule to delete
* @return CE_None on success.
*/
virtual CPLErr DeleteRule(const char *pszRuleStr);
/**
* @brief Get the rule list
* @return list of rule strings. The caller have to free the lis via
* CPLDestroy.
*/
virtual char **GetRules() const;
/**
* @brief Attempts to build the network topology automatically
*
* The method simply gets point and line or multiline layers from the
* papszLayerList and searches for each line which connects two points:
* start and end, so it can be not so effective in performance when it is
* called on huge networks. Note, when passing your tolerance value: this
* value will depend of spatial reference system of the network, and
* especially of its 0,0 position because dfTolerance is just divided by 2
* and added/subtracted to/from both sides of each line-feature end point
* forming thus the square area around it. The first point-feature occurred
* inside this area will be given as a start/end point for the current
* connection. So it is also desirable that at least two layers are passed
* in papszLayerList (one point and one line), and they are already
* connected "visually" ("geometrically").
*
* @param papszLayerList A list of layers to connect. The list should be
* freed via CSLDestroy.
* @param dfTolerance Snapping tolerance.
* @param dfCost Direct cost.
* @param dfInvCost Inverse cost.
* @param eDir Direction.
* @return CE_None on success
*/
virtual CPLErr ConnectPointsByLines(char **papszLayerList,
double dfTolerance, double dfCost,
double dfInvCost, GNMDirection eDir);
/**
* @brief Change the block state of edge or vertex
* @param nFID Identificator
* @param bIsBlock Block or unblock
* @return CE_None on success
*/
virtual CPLErr ChangeBlockState(GNMGFID nFID, bool bIsBlock);
/**
* @brief Change all vertices and edges block state.
*
* This is mainly use for unblock all vertices and edges.
*
* @param bIsBlock Block or unblock
* @return CE_None on success
*/
virtual CPLErr ChangeAllBlockState(bool bIsBlock = false);
virtual OGRLayer *GetPath(GNMGFID nStartFID, GNMGFID nEndFID,
GNMGraphAlgorithmType eAlgorithm,
char **papszOptions) override;
protected:
/**
* @brief Check or create layer OGR driver
* @param pszDefaultDriverName - default driver name
* @param papszOptions - create options
* @return CE_None if driver is exist or CE_Failure
*/
virtual CPLErr CheckLayerDriver(const char *pszDefaultDriverName,
char **papszOptions);
/**
* @brief Check if provided OGR driver accepted as storage for network data
* @param pszDriverName The driver name
* @return true if supported, else false
*/
virtual bool CheckStorageDriverSupport(const char *pszDriverName) = 0;
protected:
//! @cond Doxygen_Suppress
virtual CPLErr CreateMetadataLayer(GDALDataset *const pDS, int nVersion,
size_t nFieldSize = 1024);
virtual CPLErr StoreNetworkSrs();
virtual CPLErr LoadNetworkSrs();
virtual CPLErr CreateGraphLayer(GDALDataset *const pDS);
virtual CPLErr CreateFeaturesLayer(GDALDataset *const pDS);
virtual CPLErr LoadMetadataLayer(GDALDataset *const pDS);
virtual CPLErr LoadGraphLayer(GDALDataset *const pDS);
virtual CPLErr LoadGraph();
virtual CPLErr LoadFeaturesLayer(GDALDataset *const pDS);
virtual CPLErr DeleteMetadataLayer() = 0;
virtual CPLErr DeleteGraphLayer() = 0;
virtual CPLErr DeleteFeaturesLayer() = 0;
virtual CPLErr LoadNetworkLayer(const char *pszLayername) = 0;
virtual CPLErr DeleteNetworkLayers() = 0;
virtual void ConnectPointsByMultiline(
GIntBig nFID, const OGRMultiLineString *poMultiLineString,
const std::vector<OGRLayer *> &paPointLayers, double dfTolerance,
double dfCost, double dfInvCost, GNMDirection eDir);
virtual void
ConnectPointsByLine(GIntBig nFID, const OGRLineString *poLineString,
const std::vector<OGRLayer *> &paPointLayers,
double dfTolerance, double dfCost, double dfInvCost,
GNMDirection eDir);
virtual GNMGFID
FindNearestPoint(const OGRPoint *poPoint,
const std::vector<OGRLayer *> &paPointLayers,
double dfTolerance);
virtual OGRFeature *FindConnection(GNMGFID nSrcFID, GNMGFID nTgtFID,
GNMGFID nConFID);
virtual bool SaveRules();
virtual GNMGFID GetNewVirtualFID();
virtual void FillResultLayer(OGRGNMWrappedResultLayer *poResLayer,
const GNMPATH &path, int nNoOfPath,
bool bReturnVertices, bool bReturnEdges);
//! @endcond
protected:
//! @cond Doxygen_Suppress
int m_nVersion;
GNMGFID m_nGID;
GNMGFID m_nVirtualConnectionGID;
OGRLayer *m_poMetadataLayer;
OGRLayer *m_poGraphLayer;
OGRLayer *m_poFeaturesLayer;
GDALDriver *m_poLayerDriver;
std::map<GNMGFID, CPLString> m_moFeatureFIDMap;
std::vector<OGRLayer *> m_apoLayers;
std::vector<GNMRule> m_asRules;
bool m_bIsRulesChanged;
GNMGraph m_oGraph;
bool m_bIsGraphLoaded;
//! @endcond
};
/**
* GNM layer which represents a geography network layer of generic format.
* The class override some OGRLayer methods to fulfill the network requirements.
*
* @since GDAL 2.1
*/
class GNMGenericLayer : public OGRLayer
{
public:
GNMGenericLayer(OGRLayer *poLayer, GNMGenericNetwork *poNetwork);
virtual ~GNMGenericLayer();
// OGRLayer Interface
virtual OGRGeometry *GetSpatialFilter() override;
virtual void SetSpatialFilter(OGRGeometry *) override;
virtual void SetSpatialFilterRect(double dfMinX, double dfMinY,
double dfMaxX, double dfMaxY) override;
virtual void SetSpatialFilter(int iGeomField, OGRGeometry *) override;
virtual void SetSpatialFilterRect(int iGeomField, double dfMinX,
double dfMinY, double dfMaxX,
double dfMaxY) override;
virtual OGRErr SetAttributeFilter(const char *) override;
virtual void ResetReading() override;
virtual OGRFeature *GetNextFeature() override;
virtual OGRErr SetNextByIndex(GIntBig nIndex) override;
virtual OGRErr DeleteFeature(GIntBig nFID) override;
virtual const char *GetName() override;
virtual OGRwkbGeometryType GetGeomType() override;
virtual OGRFeatureDefn *GetLayerDefn() override;
virtual int FindFieldIndex(const char *pszFieldName,
int bExactMatch) override;
virtual OGRSpatialReference *GetSpatialRef() override;
virtual GIntBig GetFeatureCount(int bForce = TRUE) override;
virtual OGRErr GetExtent(OGREnvelope *psExtent, int bForce = TRUE) override;
virtual OGRErr GetExtent(int iGeomField, OGREnvelope *psExtent,
int bForce = TRUE) override;
virtual int TestCapability(const char *) override;
virtual OGRErr CreateField(const OGRFieldDefn *poField,
int bApproxOK = TRUE) override;
virtual OGRErr DeleteField(int iField) override;
virtual OGRErr ReorderFields(int *panMap) override;
virtual OGRErr AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,
int nFlagsIn) override;
virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poField,
int bApproxOK = TRUE) override;
virtual OGRErr SyncToDisk() override;
virtual OGRStyleTable *GetStyleTable() override;
virtual void SetStyleTableDirectly(OGRStyleTable *poStyleTable) override;
virtual void SetStyleTable(OGRStyleTable *poStyleTable) override;
virtual OGRErr StartTransaction() override;
virtual OGRErr CommitTransaction() override;
virtual OGRErr RollbackTransaction() override;
virtual const char *GetFIDColumn() override;
virtual const char *GetGeometryColumn() override;
virtual OGRErr SetIgnoredFields(CSLConstList papszFields) override;
/** Intersection */
OGRErr Intersection(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
char **papszOptions = nullptr,
GDALProgressFunc pfnProgress = nullptr,
void *pProgressArg = nullptr);
/** Union */
OGRErr Union(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
char **papszOptions = nullptr,
GDALProgressFunc pfnProgress = nullptr,
void *pProgressArg = nullptr);
/** SymDifference */
OGRErr SymDifference(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
char **papszOptions, GDALProgressFunc pfnProgress,
void *pProgressArg);
/** Identity */
OGRErr Identity(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
char **papszOptions = nullptr,
GDALProgressFunc pfnProgress = nullptr,
void *pProgressArg = nullptr);
/** Update */
OGRErr Update(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
char **papszOptions = nullptr,
GDALProgressFunc pfnProgress = nullptr,
void *pProgressArg = nullptr);
/** Clip */
OGRErr Clip(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
char **papszOptions = nullptr,
GDALProgressFunc pfnProgress = nullptr,
void *pProgressArg = nullptr);
/** Erase */
OGRErr Erase(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
char **papszOptions = nullptr,
GDALProgressFunc pfnProgress = nullptr,
void *pProgressArg = nullptr);
/** GetFeaturesRead */
GIntBig GetFeaturesRead();
/** AttributeFilterEvaluationNeedsGeometry */
int AttributeFilterEvaluationNeedsGeometry();
//! @cond Doxygen_Suppress
/* consider these private */
OGRErr InitializeIndexSupport(const char *);
OGRLayerAttrIndex *GetIndex();
//! @endcond
protected:
//! @cond Doxygen_Suppress
virtual OGRErr ISetFeature(OGRFeature *poFeature) override;
virtual OGRErr ICreateFeature(OGRFeature *poFeature) override;
protected:
CPLString m_soLayerName;
OGRLayer *m_poLayer;
GNMGenericNetwork *m_poNetwork;
std::map<GNMGFID, GIntBig> m_mnFIDMap;
//! @endcond
};
typedef enum
{
/** Rule for connect features */ GRTConnection = 0
} GNMRuleType;
/**
* @brief The simple class for rules
*
* By now we have only connect rules, so the one class is enough. Maybe in
* future the set of classes for different rule types will be needed.
*
* @since GDAL 2.1
*/
class CPL_DLL GNMRule
{
// to hopefully please Coverity Scan which complains about missing
// move assignment operator for performance reasons
GNMRule &operator==(GNMRule &&) = delete;
public:
/** Constructor */
GNMRule();
/** Constructor */
explicit GNMRule(const std::string &oRule);
/** Constructor */
explicit GNMRule(const char *pszRule);
/** Constructor */
GNMRule(const GNMRule &oRule);
/** Assignment operator */
GNMRule &operator=(const GNMRule &) = default;
virtual ~GNMRule();
/**
* @brief This function indicate if rule string was parsed successfully
* @return true if rule is valid
*/
virtual bool IsValid() const;
/**
* @brief Indicator of any layer state
* @return true if accept any layer
*/
virtual bool IsAcceptAny() const;
/**
* @brief This is for future use to indicate the rule type/ Now return only
* GRTConnection type.
* @return the rule type
*/
virtual GNMRuleType GetType() const;
/**
* @brief Check if connection can take place.
* @param soSrcLayerName - the layer name
* @param soTgtLayerName - the layer name
* @param soConnLayerName - the layer name
* @return true if can connect features from soSrcLayerName and
* soTgtLayerName via soConnLayerName
*/
virtual bool CanConnect(const CPLString &soSrcLayerName,
const CPLString &soTgtLayerName,
const CPLString &soConnLayerName = "");
/** Return source layer name */
virtual CPLString GetSourceLayerName() const;
/** Return target layer name */
virtual CPLString GetTargetLayerName() const;
/** Return connector layer name */
virtual CPLString GetConnectorLayerName() const;
/** Return rule as a string */
const char *c_str() const;
/** Return rule as a string */
operator const char *(void) const;
protected:
//! @cond Doxygen_Suppress
virtual bool ParseRuleString();
protected:
CPLString m_soSrcLayerName;
CPLString m_soTgtLayerName;
CPLString m_soConnLayerName;
bool m_bAllow = false;
bool m_bValid = false;
bool m_bAny = false;
CPLString m_soRuleString;
//! @endcond
};
/**
* @brief The OGRGNMWrappedResultLayer class for search paths queries results.
*
* @since GDAL 2.1
*/
class OGRGNMWrappedResultLayer : public OGRLayer
{
public:
OGRGNMWrappedResultLayer(GDALDataset *poDS, OGRLayer *poLayer);
~OGRGNMWrappedResultLayer();
// OGRLayer
virtual void ResetReading() override;
virtual OGRFeature *GetNextFeature() override;
virtual OGRErr SetNextByIndex(GIntBig nIndex) override;
virtual OGRFeature *GetFeature(GIntBig nFID) override;
virtual OGRFeatureDefn *GetLayerDefn() override;
virtual GIntBig GetFeatureCount(int bForce = TRUE) override;
virtual int TestCapability(const char *pszCap) override;
virtual OGRErr CreateField(const OGRFieldDefn *poField,
int bApproxOK = TRUE) override;
virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poField,
int bApproxOK = TRUE) override;
virtual const char *GetFIDColumn() override;
virtual const char *GetGeometryColumn() override;
virtual OGRSpatialReference *GetSpatialRef() override;
// OGRGNMWrappedResultLayer
virtual OGRErr InsertFeature(OGRFeature *poFeature,
const CPLString &soLayerName, int nPathNo,
bool bIsEdge);
protected:
virtual OGRErr ISetFeature(OGRFeature *poFeature) override;
virtual OGRErr ICreateFeature(OGRFeature *poFeature) override;
protected:
//! @cond Doxygen_Suppress
GDALDataset *poDS;
OGRLayer *poLayer;
//! @endcond
};
#endif // __cplusplus
#endif // GNM