@crossbind/port-gdal-wasm 2.0.0-beta.50

package/dist/prebuilt/wasm-wasm32-st-release/include/gnm.h

@@ -0,0 +1,781 @@
+/******************************************************************************
+ *
+ * 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();
+    ~GNMNetwork() override;
+
+    // GDALDataset Interface
+    const OGRSpatialReference *GetSpatialRef() const override;
+    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,
+                          CSLConstList 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,
+                              CSLConstList papszOptions) = 0;
+
+    /** Casts a handle to a pointer */
+    static inline GNMNetwork *FromHandle(GNMGenericNetworkH hNet)
+    {
+        return static_cast<GNMNetwork *>(hNet);
+    }
+
+    /** Casts a pointer to a handle */
+    static inline GNMGenericNetworkH ToHandle(GNMNetwork *poNetwork)
+    {
+        return static_cast<GNMGenericNetworkH>(poNetwork);
+    }
+
+  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,
+                                  CSLConstList 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();
+    ~GNMGenericNetwork() override;
+
+    // GDALDataset Interface
+
+    int GetLayerCount() const override;
+    OGRLayer *GetLayer(int) const override;
+    OGRErr DeleteLayer(int) override;
+
+    int TestCapability(const char *) const override;
+
+    virtual OGRLayer *CopyLayer(OGRLayer *poSrcLayer, const char *pszNewName,
+                                CSLConstList papszOptions = nullptr) override;
+
+    int CloseDependentDatasets() override;
+    CPLErr FlushCache(bool bAtClosing) override;
+
+    // GNMNetwork Interface
+
+    virtual CPLErr Create(const char *pszFilename,
+                          CSLConstList papszOptions) override = 0;
+    CPLErr Delete() override;
+
+    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);
+
+    CPLErr DisconnectAll() override;
+
+    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,
+                              CSLConstList papszOptions) override;
+
+    /** Casts a handle to a pointer */
+    static inline GNMGenericNetwork *FromHandle(GNMGenericNetworkH hNet)
+    {
+        return static_cast<GNMGenericNetwork *>(hNet);
+    }
+
+    /** Casts a pointer to a handle */
+    static inline GNMGenericNetworkH ToHandle(GNMGenericNetwork *poNetwork)
+    {
+        return static_cast<GNMGenericNetworkH>(poNetwork);
+    }
+
+  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,
+                                    CSLConstList 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 = 0;
+    GNMGFID m_nGID = 0;
+    GNMGFID m_nVirtualConnectionGID = -1;
+    OGRLayer *m_poMetadataLayer = nullptr;
+    OGRLayer *m_poGraphLayer = nullptr;
+    OGRLayer *m_poFeaturesLayer = nullptr;
+
+    GDALDriver *m_poLayerDriver = nullptr;
+
+    std::map<GNMGFID, CPLString> m_moFeatureFIDMap{};
+    std::vector<OGRLayer *> m_apoLayers{};
+    std::vector<GNMRule> m_asRules;
+    bool m_bIsRulesChanged = false;
+
+    GNMGraph m_oGraph{};
+    bool m_bIsGraphLoaded = false;
+    //! @endcond
+  private:
+    CPL_DISALLOW_COPY_ASSIGN(GNMGenericNetwork)
+};
+
+/**
+ * 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 final : public OGRLayer
+{
+  public:
+    GNMGenericLayer(OGRLayer *poLayer, GNMGenericNetwork *poNetwork);
+    ~GNMGenericLayer() override;
+
+    // OGRLayer Interface
+
+    OGRGeometry *GetSpatialFilter() override;
+
+    virtual OGRErr ISetSpatialFilter(int iGeomField,
+                                     const OGRGeometry *) override;
+
+    OGRErr SetAttributeFilter(const char *) override;
+
+    void ResetReading() override;
+    OGRFeature *GetNextFeature() override;
+    OGRErr SetNextByIndex(GIntBig nIndex) override;
+
+    OGRErr DeleteFeature(GIntBig nFID) override;
+
+    const char *GetName() const override;
+    OGRwkbGeometryType GetGeomType() const override;
+    const OGRFeatureDefn *GetLayerDefn() const override;
+    virtual int FindFieldIndex(const char *pszFieldName,
+                               int bExactMatch) override;
+
+    const OGRSpatialReference *GetSpatialRef() const override;
+
+    GIntBig GetFeatureCount(int bForce = TRUE) override;
+
+    virtual OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,
+                              bool bForce = true) override;
+
+    int TestCapability(const char *) const override;
+
+    virtual OGRErr CreateField(const OGRFieldDefn *poField,
+                               int bApproxOK = TRUE) override;
+    OGRErr DeleteField(int iField) override;
+    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;
+
+    OGRErr SyncToDisk() override;
+
+    OGRStyleTable *GetStyleTable() override;
+    void SetStyleTableDirectly(OGRStyleTable *poStyleTable) override;
+
+    void SetStyleTable(OGRStyleTable *poStyleTable) override;
+
+    OGRErr StartTransaction() override;
+    OGRErr CommitTransaction() override;
+    OGRErr RollbackTransaction() override;
+
+    const char *GetFIDColumn() const override;
+    const char *GetGeometryColumn() const override;
+
+    OGRErr SetIgnoredFields(CSLConstList papszFields) override;
+
+    /** Intersection */
+    OGRErr Intersection(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
+                        CSLConstList papszOptions = nullptr,
+                        GDALProgressFunc pfnProgress = nullptr,
+                        void *pProgressArg = nullptr);
+    /** Union */
+    OGRErr Union(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
+                 CSLConstList papszOptions = nullptr,
+                 GDALProgressFunc pfnProgress = nullptr,
+                 void *pProgressArg = nullptr);
+    /** SymDifference */
+    OGRErr SymDifference(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
+                         CSLConstList papszOptions,
+                         GDALProgressFunc pfnProgress, void *pProgressArg);
+    /** Identity */
+    OGRErr Identity(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
+                    CSLConstList papszOptions = nullptr,
+                    GDALProgressFunc pfnProgress = nullptr,
+                    void *pProgressArg = nullptr);
+    /** Update */
+    OGRErr Update(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
+                  CSLConstList papszOptions = nullptr,
+                  GDALProgressFunc pfnProgress = nullptr,
+                  void *pProgressArg = nullptr);
+    /** Clip */
+    OGRErr Clip(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
+                CSLConstList papszOptions = nullptr,
+                GDALProgressFunc pfnProgress = nullptr,
+                void *pProgressArg = nullptr);
+    /** Erase */
+    OGRErr Erase(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
+                 CSLConstList 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
+    OGRErr ISetFeature(OGRFeature *poFeature) override;
+    OGRErr ICreateFeature(OGRFeature *poFeature) override;
+
+  protected:
+    CPLString m_soLayerName{};
+    OGRLayer *m_poLayer = nullptr;
+    GNMGenericNetwork *m_poNetwork = nullptr;
+    std::map<GNMGFID, GIntBig> m_mnFIDMap{};
+    //! @endcond
+
+  private:
+    CPL_DISALLOW_COPY_ASSIGN(GNMGenericLayer)
+};
+
+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 /* non final */
+{
+  public:
+    /** Constructor */
+    GNMRule();
+    /** Constructor */
+    explicit GNMRule(const std::string &oRule);
+    /** Constructor */
+    explicit GNMRule(const char *pszRule);
+
+    /** Copy constructor */
+    GNMRule(const GNMRule &) = default;
+
+    /** Move constructor */
+    GNMRule(GNMRule &&) = default;
+
+    /** Assignment operator */
+    GNMRule &operator=(const GNMRule &) = default;
+
+    /** Move assignment operator */
+    GNMRule &operator=(GNMRule &&) = default;
+
+    /** Destructor */
+    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 final : public OGRLayer
+{
+  public:
+    OGRGNMWrappedResultLayer(GDALDataset *poDS, OGRLayer *poLayer);
+    ~OGRGNMWrappedResultLayer() override;
+
+    // OGRLayer
+    void ResetReading() override;
+    OGRFeature *GetNextFeature() override;
+    OGRErr SetNextByIndex(GIntBig nIndex) override;
+    OGRFeature *GetFeature(GIntBig nFID) override;
+    const OGRFeatureDefn *GetLayerDefn() const override;
+    GIntBig GetFeatureCount(int bForce = TRUE) override;
+    int TestCapability(const char *pszCap) const override;
+    virtual OGRErr CreateField(const OGRFieldDefn *poField,
+                               int bApproxOK = TRUE) override;
+    virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poField,
+                                   int bApproxOK = TRUE) override;
+    const char *GetFIDColumn() const override;
+    const char *GetGeometryColumn() const override;
+    const OGRSpatialReference *GetSpatialRef() const override;
+
+    // OGRGNMWrappedResultLayer
+    OGRErr InsertFeature(OGRFeature *poFeature, const CPLString &soLayerName,
+                         int nPathNo, bool bIsEdge);
+
+  protected:
+    OGRErr ISetFeature(OGRFeature *poFeature) override;
+    OGRErr ICreateFeature(OGRFeature *poFeature) override;
+
+  protected:
+    //! @cond Doxygen_Suppress
+    GDALDataset *poDS = nullptr;
+    OGRLayer *poLayer = nullptr;
+    //! @endcond
+
+  private:
+    CPL_DISALLOW_COPY_ASSIGN(OGRGNMWrappedResultLayer)
+};
+
+#endif  // __cplusplus
+
+#endif  // GNM