/src/gdal/gnm/gnmlayer.cpp

Source (jump to first uncovered line)
/******************************************************************************
 *
 * Project:  GDAL/OGR Geography Network support (Geographic Network Model)
 * Purpose:  GNM layer class.
 * 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.
 ****************************************************************************/
#include "gnm.h"
#include "gnm_priv.h"

/**
 * GNMGenericLayer
 */
GNMGenericLayer::GNMGenericLayer(OGRLayer *poLayer,
                                 GNMGenericNetwork *poNetwork)
    : m_soLayerName(poLayer->GetName()), m_poLayer(poLayer),
      m_poNetwork(poNetwork)
{
}

/**
 * ~GNMGenericLayer
 */
GNMGenericLayer::~GNMGenericLayer() = default;

const char *GNMGenericLayer::GetFIDColumn()
{
    return GNM_SYSFIELD_GFID;
}

const char *GNMGenericLayer::GetGeometryColumn()
{
    return m_poLayer->GetGeometryColumn();
}

OGRErr GNMGenericLayer::SetIgnoredFields(CSLConstList papszFields)
{
    return m_poLayer->SetIgnoredFields(papszFields);
}

OGRErr GNMGenericLayer::Intersection(OGRLayer *pLayerMethod,
                                     OGRLayer *pLayerResult,
                                     char **papszOptions,
                                     GDALProgressFunc pfnProgress,
                                     void *pProgressArg)
{
    return m_poLayer->Intersection(pLayerMethod, pLayerResult, papszOptions,
                                   pfnProgress, pProgressArg);
}

OGRErr GNMGenericLayer::Union(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                              char **papszOptions, GDALProgressFunc pfnProgress,
                              void *pProgressArg)
{
    return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
                            pfnProgress, pProgressArg);
}

OGRErr GNMGenericLayer::SymDifference(OGRLayer *pLayerMethod,
                                      OGRLayer *pLayerResult,
                                      char **papszOptions,
                                      GDALProgressFunc pfnProgress,
                                      void *pProgressArg)
{
    return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
                            pfnProgress, pProgressArg);
}

OGRErr GNMGenericLayer::Identity(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                                 char **papszOptions,
                                 GDALProgressFunc pfnProgress,
                                 void *pProgressArg)
{
    return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
                            pfnProgress, pProgressArg);
}

OGRErr GNMGenericLayer::Update(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                               char **papszOptions,
                               GDALProgressFunc pfnProgress, void *pProgressArg)
{
    return m_poLayer->Update(pLayerMethod, pLayerResult, papszOptions,
                             pfnProgress, pProgressArg);
}

OGRErr GNMGenericLayer::Clip(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                             char **papszOptions, GDALProgressFunc pfnProgress,
                             void *pProgressArg)
{
    return m_poLayer->Clip(pLayerMethod, pLayerResult, papszOptions,
                           pfnProgress, pProgressArg);
}

OGRErr GNMGenericLayer::Erase(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
                              char **papszOptions, GDALProgressFunc pfnProgress,
                              void *pProgressArg)
{
    return m_poLayer->Erase(pLayerMethod, pLayerResult, papszOptions,
                            pfnProgress, pProgressArg);
}

GIntBig GNMGenericLayer::GetFeaturesRead()
{
    return m_poLayer->GetFeaturesRead();
}

int GNMGenericLayer::AttributeFilterEvaluationNeedsGeometry()
{
    return m_poLayer->AttributeFilterEvaluationNeedsGeometry();
}

//! @cond Doxygen_Suppress
OGRErr GNMGenericLayer::InitializeIndexSupport(const char *pszVal)
{
    return m_poLayer->InitializeIndexSupport(pszVal);
}

OGRLayerAttrIndex *GNMGenericLayer::GetIndex()
{
    return m_poLayer->GetIndex();
}

OGRErr GNMGenericLayer::ISetFeature(OGRFeature *poFeature)
{
    VALIDATE_POINTER1(poFeature, "GNMGenericLayer::ISetFeature", CE_Failure);
    std::map<GNMGFID, GIntBig>::iterator it =
        m_mnFIDMap.find(poFeature->GetFID());
    if (it == m_mnFIDMap.end())
    {
        CPLError(CE_Failure, CPLE_IllegalArg,
                 "The FID " CPL_FRMT_GIB " is invalid", poFeature->GetFID());
        return OGRERR_NON_EXISTING_FEATURE;
    }

    // TODO: check connection rules if feature can be changed.

    poFeature->SetFID(it->second);
    return m_poLayer->SetFeature(poFeature);
}

OGRErr GNMGenericLayer::ICreateFeature(OGRFeature *poFeature)
{
    VALIDATE_POINTER1(poFeature, "GNMGenericLayer::ICreateFeature", CE_Failure);
    GNMGFID nFID = m_poNetwork->GetNewGlobalFID();
    poFeature->SetFID(nFID);
    poFeature->SetField(GNM_SYSFIELD_GFID, nFID);
    poFeature->SetField(GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE);
    if (m_poNetwork->AddFeatureGlobalFID(nFID, GetName()) != CE_None)
        return OGRERR_FAILURE;
    return m_poLayer->CreateFeature(poFeature);
}

//! @endcond

OGRGeometry *GNMGenericLayer::GetSpatialFilter()
{
    return m_poLayer->GetSpatialFilter();
}

OGRErr GNMGenericLayer::ISetSpatialFilter(int iGeomField,
                                          const OGRGeometry *poGeometry)
{
    return m_poLayer->SetSpatialFilter(iGeomField, poGeometry);
}

OGRErr GNMGenericLayer::SetAttributeFilter(const char *pszFilter)
{
    return m_poLayer->SetAttributeFilter(pszFilter);
}

void GNMGenericLayer::ResetReading()
{
    m_poLayer->ResetReading();
}

OGRFeature *GNMGenericLayer::GetNextFeature()
{
    OGRFeature *pFeature = m_poLayer->GetNextFeature();
    if (nullptr == pFeature)
        return nullptr;
    GNMGFID nGFID = pFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_GFID);
    m_mnFIDMap[nGFID] = pFeature->GetFID();
    pFeature->SetFID(nGFID);
    return pFeature;
}

OGRErr GNMGenericLayer::SetNextByIndex(GIntBig nIndex)
{
    return m_poLayer->SetNextByIndex(nIndex);
}

OGRErr GNMGenericLayer::DeleteFeature(GIntBig nFID)
{
    OGRFeature *poFeature = GetFeature(nFID);
    if (nullptr == poFeature)
        return CE_Failure;

    nFID = poFeature->GetFID();
    std::map<GNMGFID, GIntBig>::iterator it = m_mnFIDMap.find(nFID);
    if (it == m_mnFIDMap.end())
    {
        CPLError(CE_Failure, CPLE_IllegalArg,
                 "The FID " CPL_FRMT_GIB " is invalid", nFID);
        return OGRERR_NON_EXISTING_FEATURE;
    }

    OGRFeature::DestroyFeature(poFeature);

    // delete from graph
    if (m_poNetwork->DisconnectFeaturesWithId(static_cast<GNMGFID>(nFID)) !=
        CE_None)
        return CE_Failure;

    return m_poLayer->DeleteFeature(it->second);
}

const char *GNMGenericLayer::GetName()
{
    return m_soLayerName;
}

OGRwkbGeometryType GNMGenericLayer::GetGeomType()
{
    return m_poLayer->GetGeomType();
}

int GNMGenericLayer::FindFieldIndex(const char *pszFieldName, int bExactMatch)
{
    return m_poLayer->FindFieldIndex(pszFieldName, bExactMatch);
}

OGRSpatialReference *GNMGenericLayer::GetSpatialRef()
{
    return m_poLayer->GetSpatialRef();
}

GIntBig GNMGenericLayer::GetFeatureCount(int bForce)
{
    return m_poLayer->GetFeatureCount(bForce);
}

OGRErr GNMGenericLayer::IGetExtent(int iGeomField, OGREnvelope *psExtent,
                                   bool bForce)
{
    return m_poLayer->GetExtent(iGeomField, psExtent, bForce);
}

int GNMGenericLayer::TestCapability(const char *pszCapability)
{
    return m_poLayer->TestCapability(pszCapability);
}

OGRErr GNMGenericLayer::CreateField(const OGRFieldDefn *poField, int bApproxOK)
{
    return m_poLayer->CreateField(poField, bApproxOK);
}

OGRErr GNMGenericLayer::DeleteField(int iField)
{
    if (iField == FindFieldIndex(GNM_SYSFIELD_GFID, TRUE))
        return OGRERR_UNSUPPORTED_OPERATION;
    if (iField == FindFieldIndex(GNM_SYSFIELD_BLOCKED, TRUE))
        return OGRERR_UNSUPPORTED_OPERATION;
    return m_poLayer->DeleteField(iField);
}

OGRErr GNMGenericLayer::ReorderFields(int *panMap)
{
    return m_poLayer->ReorderFields(panMap);
}

OGRErr GNMGenericLayer::AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,
                                       int nFlagsIn)
{
    if (iField == FindFieldIndex(GNM_SYSFIELD_GFID, TRUE))
        return OGRERR_UNSUPPORTED_OPERATION;
    if (iField == FindFieldIndex(GNM_SYSFIELD_BLOCKED, TRUE))
        return OGRERR_UNSUPPORTED_OPERATION;
    return m_poLayer->AlterFieldDefn(iField, poNewFieldDefn, nFlagsIn);
}

OGRErr GNMGenericLayer::CreateGeomField(const OGRGeomFieldDefn *poField,
                                        int bApproxOK)
{
    return m_poLayer->CreateGeomField(poField, bApproxOK);
}

OGRErr GNMGenericLayer::SyncToDisk()
{
    return m_poLayer->SyncToDisk();
}

OGRStyleTable *GNMGenericLayer::GetStyleTable()
{
    return m_poLayer->GetStyleTable();
}

void GNMGenericLayer::SetStyleTableDirectly(OGRStyleTable *poStyleTable)
{
    return m_poLayer->SetStyleTableDirectly(poStyleTable);
}

void GNMGenericLayer::SetStyleTable(OGRStyleTable *poStyleTable)
{
    return m_poLayer->SetStyleTable(poStyleTable);
}

OGRErr GNMGenericLayer::StartTransaction()
{
    return m_poLayer->StartTransaction();
}

OGRErr GNMGenericLayer::CommitTransaction()
{
    return m_poLayer->CommitTransaction();
}

OGRErr GNMGenericLayer::RollbackTransaction()
{
    return m_poLayer->RollbackTransaction();
}

OGRFeatureDefn *GNMGenericLayer::GetLayerDefn()
{
    // TODO: hide GNM_SYSFIELD_GFID filed
    return m_poLayer->GetLayerDefn();
}

Coverage Report

Created: 2025-06-09 08:44

Line	Count	Source (jump to first uncovered line)
1		/******************************************************************************
2		*
3		* Project: GDAL/OGR Geography Network support (Geographic Network Model)
4		* Purpose: GNM layer class.
5		* Authors: Mikhail Gusev (gusevmihs at gmail dot com)
6		* Dmitry Baryshnikov, polimax@mail.ru
7		*
8		******************************************************************************
9		* Copyright (c) 2014, Mikhail Gusev
10		* Copyright (c) 2014-2015, NextGIS <info@nextgis.com>
11		*
12		* Permission is hereby granted, free of charge, to any person obtaining a
13		* copy of this software and associated documentation files (the "Software"),
14		* to deal in the Software without restriction, including without limitation
15		* the rights to use, copy, modify, merge, publish, distribute, sublicense,
16		* and/or sell copies of the Software, and to permit persons to whom the
17		* Software is furnished to do so, subject to the following conditions:
18		*
19		* The above copyright notice and this permission notice shall be included
20		* in all copies or substantial portions of the Software.
21		*
22		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23		* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
25		* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26		* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27		* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28		* DEALINGS IN THE SOFTWARE.
29		****************************************************************************/
30		#include "gnm.h"
31		#include "gnm_priv.h"
32
33		/**
34		* GNMGenericLayer
35		*/
36		GNMGenericLayer::GNMGenericLayer(OGRLayer *poLayer,
37		GNMGenericNetwork *poNetwork)
38	0	: m_soLayerName(poLayer->GetName()), m_poLayer(poLayer),
39	0	m_poNetwork(poNetwork)
40	0	{
41	0	}
42
43		/**
44		* ~GNMGenericLayer
45		*/
46	0	GNMGenericLayer::~GNMGenericLayer() = default;
47
48		const char *GNMGenericLayer::GetFIDColumn()
49	0	{
50	0	return GNM_SYSFIELD_GFID;
51	0	}
52
53		const char *GNMGenericLayer::GetGeometryColumn()
54	0	{
55	0	return m_poLayer->GetGeometryColumn();
56	0	}
57
58		OGRErr GNMGenericLayer::SetIgnoredFields(CSLConstList papszFields)
59	0	{
60	0	return m_poLayer->SetIgnoredFields(papszFields);
61	0	}
62
63		OGRErr GNMGenericLayer::Intersection(OGRLayer *pLayerMethod,
64		OGRLayer *pLayerResult,
65		char **papszOptions,
66		GDALProgressFunc pfnProgress,
67		void *pProgressArg)
68	0	{
69	0	return m_poLayer->Intersection(pLayerMethod, pLayerResult, papszOptions,
70	0	pfnProgress, pProgressArg);
71	0	}
72
73		OGRErr GNMGenericLayer::Union(OGRLayer pLayerMethod, OGRLayer pLayerResult,
74		char **papszOptions, GDALProgressFunc pfnProgress,
75		void *pProgressArg)
76	0	{
77	0	return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
78	0	pfnProgress, pProgressArg);
79	0	}
80
81		OGRErr GNMGenericLayer::SymDifference(OGRLayer *pLayerMethod,
82		OGRLayer *pLayerResult,
83		char **papszOptions,
84		GDALProgressFunc pfnProgress,
85		void *pProgressArg)
86	0	{
87	0	return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
88	0	pfnProgress, pProgressArg);
89	0	}
90
91		OGRErr GNMGenericLayer::Identity(OGRLayer pLayerMethod, OGRLayer pLayerResult,
92		char **papszOptions,
93		GDALProgressFunc pfnProgress,
94		void *pProgressArg)
95	0	{
96	0	return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
97	0	pfnProgress, pProgressArg);
98	0	}
99
100		OGRErr GNMGenericLayer::Update(OGRLayer pLayerMethod, OGRLayer pLayerResult,
101		char **papszOptions,
102		GDALProgressFunc pfnProgress, void *pProgressArg)
103	0	{
104	0	return m_poLayer->Update(pLayerMethod, pLayerResult, papszOptions,
105	0	pfnProgress, pProgressArg);
106	0	}
107
108		OGRErr GNMGenericLayer::Clip(OGRLayer pLayerMethod, OGRLayer pLayerResult,
109		char **papszOptions, GDALProgressFunc pfnProgress,
110		void *pProgressArg)
111	0	{
112	0	return m_poLayer->Clip(pLayerMethod, pLayerResult, papszOptions,
113	0	pfnProgress, pProgressArg);
114	0	}
115
116		OGRErr GNMGenericLayer::Erase(OGRLayer pLayerMethod, OGRLayer pLayerResult,
117		char **papszOptions, GDALProgressFunc pfnProgress,
118		void *pProgressArg)
119	0	{
120	0	return m_poLayer->Erase(pLayerMethod, pLayerResult, papszOptions,
121	0	pfnProgress, pProgressArg);
122	0	}
123
124		GIntBig GNMGenericLayer::GetFeaturesRead()
125	0	{
126	0	return m_poLayer->GetFeaturesRead();
127	0	}
128
129		int GNMGenericLayer::AttributeFilterEvaluationNeedsGeometry()
130	0	{
131	0	return m_poLayer->AttributeFilterEvaluationNeedsGeometry();
132	0	}
133
134		//! @cond Doxygen_Suppress
135		OGRErr GNMGenericLayer::InitializeIndexSupport(const char *pszVal)
136	0	{
137	0	return m_poLayer->InitializeIndexSupport(pszVal);
138	0	}
139
140		OGRLayerAttrIndex *GNMGenericLayer::GetIndex()
141	0	{
142	0	return m_poLayer->GetIndex();
143	0	}
144
145		OGRErr GNMGenericLayer::ISetFeature(OGRFeature *poFeature)
146	0	{
147	0	VALIDATE_POINTER1(poFeature, "GNMGenericLayer::ISetFeature", CE_Failure);
148	0	std::map<GNMGFID, GIntBig>::iterator it =
149	0	m_mnFIDMap.find(poFeature->GetFID());
150	0	if (it == m_mnFIDMap.end())
151	0	{
152	0	CPLError(CE_Failure, CPLE_IllegalArg,
153	0	"The FID " CPL_FRMT_GIB " is invalid", poFeature->GetFID());
154	0	return OGRERR_NON_EXISTING_FEATURE;
155	0	}
156
157		// TODO: check connection rules if feature can be changed.
158
159	0	poFeature->SetFID(it->second);
160	0	return m_poLayer->SetFeature(poFeature);
161	0	}
162
163		OGRErr GNMGenericLayer::ICreateFeature(OGRFeature *poFeature)
164	0	{
165	0	VALIDATE_POINTER1(poFeature, "GNMGenericLayer::ICreateFeature", CE_Failure);
166	0	GNMGFID nFID = m_poNetwork->GetNewGlobalFID();
167	0	poFeature->SetFID(nFID);
168	0	poFeature->SetField(GNM_SYSFIELD_GFID, nFID);
169	0	poFeature->SetField(GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE);
170	0	if (m_poNetwork->AddFeatureGlobalFID(nFID, GetName()) != CE_None)
171	0	return OGRERR_FAILURE;
172	0	return m_poLayer->CreateFeature(poFeature);
173	0	}
174
175		//! @endcond
176
177		OGRGeometry *GNMGenericLayer::GetSpatialFilter()
178	0	{
179	0	return m_poLayer->GetSpatialFilter();
180	0	}
181
182		OGRErr GNMGenericLayer::ISetSpatialFilter(int iGeomField,
183		const OGRGeometry *poGeometry)
184	0	{
185	0	return m_poLayer->SetSpatialFilter(iGeomField, poGeometry);
186	0	}
187
188		OGRErr GNMGenericLayer::SetAttributeFilter(const char *pszFilter)
189	0	{
190	0	return m_poLayer->SetAttributeFilter(pszFilter);
191	0	}
192
193		void GNMGenericLayer::ResetReading()
194	0	{
195	0	m_poLayer->ResetReading();
196	0	}
197
198		OGRFeature *GNMGenericLayer::GetNextFeature()
199	0	{
200	0	OGRFeature *pFeature = m_poLayer->GetNextFeature();
201	0	if (nullptr == pFeature)
202	0	return nullptr;
203	0	GNMGFID nGFID = pFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_GFID);
204	0	m_mnFIDMap[nGFID] = pFeature->GetFID();
205	0	pFeature->SetFID(nGFID);
206	0	return pFeature;
207	0	}
208
209		OGRErr GNMGenericLayer::SetNextByIndex(GIntBig nIndex)
210	0	{
211	0	return m_poLayer->SetNextByIndex(nIndex);
212	0	}
213
214		OGRErr GNMGenericLayer::DeleteFeature(GIntBig nFID)
215	0	{
216	0	OGRFeature *poFeature = GetFeature(nFID);
217	0	if (nullptr == poFeature)
218	0	return CE_Failure;
219
220	0	nFID = poFeature->GetFID();
221	0	std::map<GNMGFID, GIntBig>::iterator it = m_mnFIDMap.find(nFID);
222	0	if (it == m_mnFIDMap.end())
223	0	{
224	0	CPLError(CE_Failure, CPLE_IllegalArg,
225	0	"The FID " CPL_FRMT_GIB " is invalid", nFID);
226	0	return OGRERR_NON_EXISTING_FEATURE;
227	0	}
228
229	0	OGRFeature::DestroyFeature(poFeature);
230
231		// delete from graph
232	0	if (m_poNetwork->DisconnectFeaturesWithId(static_cast<GNMGFID>(nFID)) !=
233	0	CE_None)
234	0	return CE_Failure;
235
236	0	return m_poLayer->DeleteFeature(it->second);
237	0	}
238
239		const char *GNMGenericLayer::GetName()
240	0	{
241	0	return m_soLayerName;
242	0	}
243
244		OGRwkbGeometryType GNMGenericLayer::GetGeomType()
245	0	{
246	0	return m_poLayer->GetGeomType();
247	0	}
248
249		int GNMGenericLayer::FindFieldIndex(const char *pszFieldName, int bExactMatch)
250	0	{
251	0	return m_poLayer->FindFieldIndex(pszFieldName, bExactMatch);
252	0	}
253
254		OGRSpatialReference *GNMGenericLayer::GetSpatialRef()
255	0	{
256	0	return m_poLayer->GetSpatialRef();
257	0	}
258
259		GIntBig GNMGenericLayer::GetFeatureCount(int bForce)
260	0	{
261	0	return m_poLayer->GetFeatureCount(bForce);
262	0	}
263
264		OGRErr GNMGenericLayer::IGetExtent(int iGeomField, OGREnvelope *psExtent,
265		bool bForce)
266	0	{
267	0	return m_poLayer->GetExtent(iGeomField, psExtent, bForce);
268	0	}
269
270		int GNMGenericLayer::TestCapability(const char *pszCapability)
271	0	{
272	0	return m_poLayer->TestCapability(pszCapability);
273	0	}
274
275		OGRErr GNMGenericLayer::CreateField(const OGRFieldDefn *poField, int bApproxOK)
276	0	{
277	0	return m_poLayer->CreateField(poField, bApproxOK);
278	0	}
279
280		OGRErr GNMGenericLayer::DeleteField(int iField)
281	0	{
282	0	if (iField == FindFieldIndex(GNM_SYSFIELD_GFID, TRUE))
283	0	return OGRERR_UNSUPPORTED_OPERATION;
284	0	if (iField == FindFieldIndex(GNM_SYSFIELD_BLOCKED, TRUE))
285	0	return OGRERR_UNSUPPORTED_OPERATION;
286	0	return m_poLayer->DeleteField(iField);
287	0	}
288
289		OGRErr GNMGenericLayer::ReorderFields(int *panMap)
290	0	{
291	0	return m_poLayer->ReorderFields(panMap);
292	0	}
293
294		OGRErr GNMGenericLayer::AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,
295		int nFlagsIn)
296	0	{
297	0	if (iField == FindFieldIndex(GNM_SYSFIELD_GFID, TRUE))
298	0	return OGRERR_UNSUPPORTED_OPERATION;
299	0	if (iField == FindFieldIndex(GNM_SYSFIELD_BLOCKED, TRUE))
300	0	return OGRERR_UNSUPPORTED_OPERATION;
301	0	return m_poLayer->AlterFieldDefn(iField, poNewFieldDefn, nFlagsIn);
302	0	}
303
304		OGRErr GNMGenericLayer::CreateGeomField(const OGRGeomFieldDefn *poField,
305		int bApproxOK)
306	0	{
307	0	return m_poLayer->CreateGeomField(poField, bApproxOK);
308	0	}
309
310		OGRErr GNMGenericLayer::SyncToDisk()
311	0	{
312	0	return m_poLayer->SyncToDisk();
313	0	}
314
315		OGRStyleTable *GNMGenericLayer::GetStyleTable()
316	0	{
317	0	return m_poLayer->GetStyleTable();
318	0	}
319
320		void GNMGenericLayer::SetStyleTableDirectly(OGRStyleTable *poStyleTable)
321	0	{
322	0	return m_poLayer->SetStyleTableDirectly(poStyleTable);
323	0	}
324
325		void GNMGenericLayer::SetStyleTable(OGRStyleTable *poStyleTable)
326	0	{
327	0	return m_poLayer->SetStyleTable(poStyleTable);
328	0	}
329
330		OGRErr GNMGenericLayer::StartTransaction()
331	0	{
332	0	return m_poLayer->StartTransaction();
333	0	}
334
335		OGRErr GNMGenericLayer::CommitTransaction()
336	0	{
337	0	return m_poLayer->CommitTransaction();
338	0	}
339
340		OGRErr GNMGenericLayer::RollbackTransaction()
341	0	{
342	0	return m_poLayer->RollbackTransaction();
343	0	}
344
345		OGRFeatureDefn *GNMGenericLayer::GetLayerDefn()
346	0	{
347		// TODO: hide GNM_SYSFIELD_GFID filed
348	0	return m_poLayer->GetLayerDefn();
349	0	}