Line data Source code
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 25 : GNMGenericLayer::GNMGenericLayer(OGRLayer *poLayer,
37 25 : GNMGenericNetwork *poNetwork)
38 25 : : m_soLayerName(poLayer->GetName()), m_poLayer(poLayer),
39 25 : m_poNetwork(poNetwork)
40 : {
41 25 : }
42 :
43 : /**
44 : * ~GNMGenericLayer
45 : */
46 : GNMGenericLayer::~GNMGenericLayer() = default;
47 :
48 0 : const char *GNMGenericLayer::GetFIDColumn()
49 : {
50 0 : return GNM_SYSFIELD_GFID;
51 : }
52 :
53 0 : const char *GNMGenericLayer::GetGeometryColumn()
54 : {
55 0 : return m_poLayer->GetGeometryColumn();
56 : }
57 :
58 0 : OGRErr GNMGenericLayer::SetIgnoredFields(CSLConstList papszFields)
59 : {
60 0 : return m_poLayer->SetIgnoredFields(papszFields);
61 : }
62 :
63 0 : OGRErr GNMGenericLayer::Intersection(OGRLayer *pLayerMethod,
64 : OGRLayer *pLayerResult,
65 : char **papszOptions,
66 : GDALProgressFunc pfnProgress,
67 : void *pProgressArg)
68 : {
69 0 : return m_poLayer->Intersection(pLayerMethod, pLayerResult, papszOptions,
70 0 : pfnProgress, pProgressArg);
71 : }
72 :
73 0 : OGRErr GNMGenericLayer::Union(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
74 : char **papszOptions, GDALProgressFunc pfnProgress,
75 : void *pProgressArg)
76 : {
77 0 : return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
78 0 : pfnProgress, pProgressArg);
79 : }
80 :
81 0 : OGRErr GNMGenericLayer::SymDifference(OGRLayer *pLayerMethod,
82 : OGRLayer *pLayerResult,
83 : char **papszOptions,
84 : GDALProgressFunc pfnProgress,
85 : void *pProgressArg)
86 : {
87 0 : return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
88 0 : pfnProgress, pProgressArg);
89 : }
90 :
91 0 : OGRErr GNMGenericLayer::Identity(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
92 : char **papszOptions,
93 : GDALProgressFunc pfnProgress,
94 : void *pProgressArg)
95 : {
96 0 : return m_poLayer->Union(pLayerMethod, pLayerResult, papszOptions,
97 0 : pfnProgress, pProgressArg);
98 : }
99 :
100 0 : OGRErr GNMGenericLayer::Update(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
101 : char **papszOptions,
102 : GDALProgressFunc pfnProgress, void *pProgressArg)
103 : {
104 0 : return m_poLayer->Update(pLayerMethod, pLayerResult, papszOptions,
105 0 : pfnProgress, pProgressArg);
106 : }
107 :
108 0 : OGRErr GNMGenericLayer::Clip(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
109 : char **papszOptions, GDALProgressFunc pfnProgress,
110 : void *pProgressArg)
111 : {
112 0 : return m_poLayer->Clip(pLayerMethod, pLayerResult, papszOptions,
113 0 : pfnProgress, pProgressArg);
114 : }
115 :
116 0 : OGRErr GNMGenericLayer::Erase(OGRLayer *pLayerMethod, OGRLayer *pLayerResult,
117 : char **papszOptions, GDALProgressFunc pfnProgress,
118 : void *pProgressArg)
119 : {
120 0 : return m_poLayer->Erase(pLayerMethod, pLayerResult, papszOptions,
121 0 : pfnProgress, pProgressArg);
122 : }
123 :
124 0 : GIntBig GNMGenericLayer::GetFeaturesRead()
125 : {
126 0 : return m_poLayer->GetFeaturesRead();
127 : }
128 :
129 0 : int GNMGenericLayer::AttributeFilterEvaluationNeedsGeometry()
130 : {
131 0 : return m_poLayer->AttributeFilterEvaluationNeedsGeometry();
132 : }
133 :
134 : //! @cond Doxygen_Suppress
135 0 : OGRErr GNMGenericLayer::InitializeIndexSupport(const char *pszVal)
136 : {
137 0 : return m_poLayer->InitializeIndexSupport(pszVal);
138 : }
139 :
140 0 : OGRLayerAttrIndex *GNMGenericLayer::GetIndex()
141 : {
142 0 : return m_poLayer->GetIndex();
143 : }
144 :
145 0 : OGRErr GNMGenericLayer::ISetFeature(OGRFeature *poFeature)
146 : {
147 0 : VALIDATE_POINTER1(poFeature, "GNMGenericLayer::ISetFeature", CE_Failure);
148 : std::map<GNMGFID, GIntBig>::iterator it =
149 0 : m_mnFIDMap.find(poFeature->GetFID());
150 0 : if (it == m_mnFIDMap.end())
151 : {
152 0 : CPLError(CE_Failure, CPLE_IllegalArg,
153 : "The FID " CPL_FRMT_GIB " is invalid", poFeature->GetFID());
154 0 : return OGRERR_NON_EXISTING_FEATURE;
155 : }
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 : }
162 :
163 128 : OGRErr GNMGenericLayer::ICreateFeature(OGRFeature *poFeature)
164 : {
165 128 : VALIDATE_POINTER1(poFeature, "GNMGenericLayer::ICreateFeature", CE_Failure);
166 128 : GNMGFID nFID = m_poNetwork->GetNewGlobalFID();
167 128 : poFeature->SetFID(nFID);
168 128 : poFeature->SetField(GNM_SYSFIELD_GFID, nFID);
169 128 : poFeature->SetField(GNM_SYSFIELD_BLOCKED, GNM_BLOCK_NONE);
170 128 : if (m_poNetwork->AddFeatureGlobalFID(nFID, GetName()) != CE_None)
171 0 : return OGRERR_FAILURE;
172 128 : return m_poLayer->CreateFeature(poFeature);
173 : }
174 :
175 : //! @endcond
176 :
177 0 : OGRGeometry *GNMGenericLayer::GetSpatialFilter()
178 : {
179 0 : return m_poLayer->GetSpatialFilter();
180 : }
181 :
182 716 : OGRErr GNMGenericLayer::ISetSpatialFilter(int iGeomField,
183 : const OGRGeometry *poGeometry)
184 : {
185 716 : return m_poLayer->SetSpatialFilter(iGeomField, poGeometry);
186 : }
187 :
188 584 : OGRErr GNMGenericLayer::SetAttributeFilter(const char *pszFilter)
189 : {
190 584 : return m_poLayer->SetAttributeFilter(pszFilter);
191 : }
192 :
193 428 : void GNMGenericLayer::ResetReading()
194 : {
195 428 : m_poLayer->ResetReading();
196 428 : }
197 :
198 5313 : OGRFeature *GNMGenericLayer::GetNextFeature()
199 : {
200 5313 : OGRFeature *pFeature = m_poLayer->GetNextFeature();
201 5313 : if (nullptr == pFeature)
202 2 : return nullptr;
203 5311 : GNMGFID nGFID = pFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_GFID);
204 5311 : m_mnFIDMap[nGFID] = pFeature->GetFID();
205 5311 : pFeature->SetFID(nGFID);
206 5311 : return pFeature;
207 : }
208 :
209 0 : OGRErr GNMGenericLayer::SetNextByIndex(GIntBig nIndex)
210 : {
211 0 : return m_poLayer->SetNextByIndex(nIndex);
212 : }
213 :
214 0 : OGRErr GNMGenericLayer::DeleteFeature(GIntBig nFID)
215 : {
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 : {
224 0 : CPLError(CE_Failure, CPLE_IllegalArg,
225 : "The FID " CPL_FRMT_GIB " is invalid", nFID);
226 0 : return OGRERR_NON_EXISTING_FEATURE;
227 : }
228 :
229 0 : OGRFeature::DestroyFeature(poFeature);
230 :
231 : // delete from graph
232 0 : if (m_poNetwork->DisconnectFeaturesWithId(static_cast<GNMGFID>(nFID)) !=
233 : CE_None)
234 0 : return CE_Failure;
235 :
236 0 : return m_poLayer->DeleteFeature(it->second);
237 : }
238 :
239 1570 : const char *GNMGenericLayer::GetName()
240 : {
241 1570 : return m_soLayerName;
242 : }
243 :
244 8 : OGRwkbGeometryType GNMGenericLayer::GetGeomType()
245 : {
246 8 : return m_poLayer->GetGeomType();
247 : }
248 :
249 0 : int GNMGenericLayer::FindFieldIndex(const char *pszFieldName, int bExactMatch)
250 : {
251 0 : return m_poLayer->FindFieldIndex(pszFieldName, bExactMatch);
252 : }
253 :
254 0 : OGRSpatialReference *GNMGenericLayer::GetSpatialRef()
255 : {
256 0 : return m_poLayer->GetSpatialRef();
257 : }
258 :
259 0 : GIntBig GNMGenericLayer::GetFeatureCount(int bForce)
260 : {
261 0 : return m_poLayer->GetFeatureCount(bForce);
262 : }
263 :
264 0 : OGRErr GNMGenericLayer::IGetExtent(int iGeomField, OGREnvelope *psExtent,
265 : bool bForce)
266 : {
267 0 : return m_poLayer->GetExtent(iGeomField, psExtent, bForce);
268 : }
269 :
270 12 : int GNMGenericLayer::TestCapability(const char *pszCapability)
271 : {
272 12 : return m_poLayer->TestCapability(pszCapability);
273 : }
274 :
275 8 : OGRErr GNMGenericLayer::CreateField(const OGRFieldDefn *poField, int bApproxOK)
276 : {
277 8 : return m_poLayer->CreateField(poField, bApproxOK);
278 : }
279 :
280 0 : OGRErr GNMGenericLayer::DeleteField(int iField)
281 : {
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 : }
288 :
289 0 : OGRErr GNMGenericLayer::ReorderFields(int *panMap)
290 : {
291 0 : return m_poLayer->ReorderFields(panMap);
292 : }
293 :
294 0 : OGRErr GNMGenericLayer::AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,
295 : int nFlagsIn)
296 : {
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 : }
303 :
304 0 : OGRErr GNMGenericLayer::CreateGeomField(const OGRGeomFieldDefn *poField,
305 : int bApproxOK)
306 : {
307 0 : return m_poLayer->CreateGeomField(poField, bApproxOK);
308 : }
309 :
310 21 : OGRErr GNMGenericLayer::SyncToDisk()
311 : {
312 21 : return m_poLayer->SyncToDisk();
313 : }
314 :
315 0 : OGRStyleTable *GNMGenericLayer::GetStyleTable()
316 : {
317 0 : return m_poLayer->GetStyleTable();
318 : }
319 :
320 0 : void GNMGenericLayer::SetStyleTableDirectly(OGRStyleTable *poStyleTable)
321 : {
322 0 : return m_poLayer->SetStyleTableDirectly(poStyleTable);
323 : }
324 :
325 0 : void GNMGenericLayer::SetStyleTable(OGRStyleTable *poStyleTable)
326 : {
327 0 : return m_poLayer->SetStyleTable(poStyleTable);
328 : }
329 :
330 0 : OGRErr GNMGenericLayer::StartTransaction()
331 : {
332 0 : return m_poLayer->StartTransaction();
333 : }
334 :
335 0 : OGRErr GNMGenericLayer::CommitTransaction()
336 : {
337 0 : return m_poLayer->CommitTransaction();
338 : }
339 :
340 0 : OGRErr GNMGenericLayer::RollbackTransaction()
341 : {
342 0 : return m_poLayer->RollbackTransaction();
343 : }
344 :
345 394 : OGRFeatureDefn *GNMGenericLayer::GetLayerDefn()
346 : {
347 : // TODO: hide GNM_SYSFIELD_GFID filed
348 394 : return m_poLayer->GetLayerDefn();
349 : }
|
