1 : /******************************************************************************
2 : * $Id: ogrlayerpool.cpp 24646 2012-07-02 07:21:55Z rouault $
3 : *
4 : * Project: OpenGIS Simple Features Reference Implementation
5 : * Purpose: Defines OGRLayerPool and OGRProxiedLayer class
6 : * Author: Even Rouault, even dot rouault at mines dash paris dot org
7 : *
8 : ******************************************************************************
9 : * Copyright (c) 2012, Even Rouault <even dot rouault at mines dash paris dot org>
10 : *
11 : * Permission is hereby granted, free of charge, to any person obtaining a
12 : * copy of this software and associated documentation files (the "Software"),
13 : * to deal in the Software without restriction, including without limitation
14 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 : * and/or sell copies of the Software, and to permit persons to whom the
16 : * Software is furnished to do so, subject to the following conditions:
17 : *
18 : * The above copyright notice and this permission notice shall be included
19 : * in all copies or substantial portions of the Software.
20 : *
21 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 : * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
27 : * DEALINGS IN THE SOFTWARE.
28 : ****************************************************************************/
29 :
30 : #include "ogrlayerpool.h"
31 :
32 : CPL_CVSID("$Id: ogrlayerpool.cpp 24646 2012-07-02 07:21:55Z rouault $");
33 :
34 : /************************************************************************/
35 : /* OGRAbstractProxiedLayer() */
36 : /************************************************************************/
37 :
38 3910 : OGRAbstractProxiedLayer::OGRAbstractProxiedLayer(OGRLayerPool* poPool)
39 : {
40 3910 : CPLAssert(poPool != NULL);
41 3910 : this->poPool = poPool;
42 3910 : poPrevLayer = NULL;
43 3910 : poNextLayer = NULL;
44 3910 : }
45 :
46 : /************************************************************************/
47 : /* ~OGRAbstractProxiedLayer() */
48 : /************************************************************************/
49 :
50 3910 : OGRAbstractProxiedLayer::~OGRAbstractProxiedLayer()
51 : {
52 : /* Remove us from the list of LRU layers if necessary */
53 3910 : poPool->UnchainLayer(this);
54 3910 : }
55 :
56 :
57 :
58 : /************************************************************************/
59 : /* OGRLayerPool() */
60 : /************************************************************************/
61 :
62 1664 : OGRLayerPool::OGRLayerPool(int nMaxSimultaneouslyOpened)
63 : {
64 1664 : poMRULayer = NULL;
65 1664 : poLRULayer = NULL;
66 1664 : nMRUListSize = 0;
67 1664 : this->nMaxSimultaneouslyOpened = nMaxSimultaneouslyOpened;
68 1664 : }
69 :
70 : /************************************************************************/
71 : /* ~OGRLayerPool() */
72 : /************************************************************************/
73 :
74 1664 : OGRLayerPool::~OGRLayerPool()
75 : {
76 1664 : CPLAssert( poMRULayer == NULL );
77 1664 : CPLAssert( poLRULayer == NULL );
78 1664 : CPLAssert( nMRUListSize == 0 );
79 1664 : }
80 :
81 : /************************************************************************/
82 : /* SetLastUsedLayer() */
83 : /************************************************************************/
84 :
85 7781 : void OGRLayerPool::SetLastUsedLayer(OGRAbstractProxiedLayer* poLayer)
86 : {
87 : /* If we are already the MRU layer, nothing to do */
88 7781 : if (poLayer == poMRULayer)
89 5224 : return;
90 :
91 : //CPLDebug("OGR", "SetLastUsedLayer(%s)", poLayer->GetName());
92 :
93 2559 : if (poLayer->poPrevLayer != NULL || poLayer->poNextLayer != NULL)
94 : {
95 : /* Remove current layer from its current place in the list */
96 2 : UnchainLayer(poLayer);
97 : }
98 2555 : else if (nMRUListSize == nMaxSimultaneouslyOpened)
99 : {
100 : /* If we have reached the maximum allowed number of layers */
101 : /* simultaneously opened, then close the LRU one that */
102 : /* was still active until now */
103 2052 : CPLAssert(poLRULayer != NULL);
104 :
105 2052 : poLRULayer->CloseUnderlyingLayer();
106 2052 : UnchainLayer(poLRULayer);
107 : }
108 :
109 : /* Put current layer on top of MRU list */
110 2557 : CPLAssert(poLayer->poPrevLayer == NULL);
111 2557 : CPLAssert(poLayer->poNextLayer == NULL);
112 2557 : poLayer->poNextLayer = poMRULayer;
113 2557 : if (poMRULayer != NULL)
114 : {
115 2505 : CPLAssert(poMRULayer->poPrevLayer == NULL);
116 2505 : poMRULayer->poPrevLayer = poLayer;
117 : }
118 2557 : poMRULayer = poLayer;
119 2557 : if (poLRULayer == NULL)
120 52 : poLRULayer = poLayer;
121 2557 : nMRUListSize ++;
122 : }
123 :
124 : /************************************************************************/
125 : /* UnchainLayer() */
126 : /************************************************************************/
127 :
128 5964 : void OGRLayerPool::UnchainLayer(OGRAbstractProxiedLayer* poLayer)
129 : {
130 5964 : OGRAbstractProxiedLayer* poPrevLayer = poLayer->poPrevLayer;
131 5964 : OGRAbstractProxiedLayer* poNextLayer = poLayer->poNextLayer;
132 :
133 5964 : CPLAssert(poPrevLayer == NULL || poPrevLayer->poNextLayer == poLayer);
134 5964 : CPLAssert(poNextLayer == NULL || poNextLayer->poPrevLayer == poLayer);
135 :
136 5964 : if (poPrevLayer != NULL || poNextLayer != NULL || poLayer == poMRULayer)
137 2557 : nMRUListSize --;
138 :
139 5964 : if (poLayer == poMRULayer)
140 55 : poMRULayer = poNextLayer;
141 5964 : if (poLayer == poLRULayer)
142 2548 : poLRULayer = poPrevLayer;
143 5964 : if (poPrevLayer != NULL)
144 2502 : poPrevLayer->poNextLayer = poNextLayer;
145 5964 : if (poNextLayer != NULL)
146 9 : poNextLayer->poPrevLayer = poPrevLayer;
147 5964 : poLayer->poPrevLayer = NULL;
148 5964 : poLayer->poNextLayer = NULL;
149 5964 : }
150 :
151 :
152 :
153 : /************************************************************************/
154 : /* OGRProxiedLayer() */
155 : /************************************************************************/
156 :
157 2 : OGRProxiedLayer::OGRProxiedLayer(OGRLayerPool* poPool,
158 : OpenLayerFunc pfnOpenLayer,
159 : FreeUserDataFunc pfnFreeUserData,
160 2 : void* pUserData) : OGRAbstractProxiedLayer(poPool)
161 : {
162 2 : CPLAssert(pfnOpenLayer != NULL);
163 :
164 2 : this->pfnOpenLayer = pfnOpenLayer;
165 2 : this->pfnFreeUserData = pfnFreeUserData;
166 2 : this->pUserData = pUserData;
167 2 : poUnderlyingLayer = NULL;
168 2 : poFeatureDefn = NULL;
169 2 : poSRS = NULL;
170 2 : }
171 :
172 : /************************************************************************/
173 : /* ~OGRProxiedLayer() */
174 : /************************************************************************/
175 :
176 2 : OGRProxiedLayer::~OGRProxiedLayer()
177 : {
178 2 : delete poUnderlyingLayer;
179 :
180 2 : if( poSRS )
181 2 : poSRS->Release();
182 :
183 2 : if( poFeatureDefn )
184 2 : poFeatureDefn->Release();
185 :
186 2 : if( pfnFreeUserData != NULL )
187 2 : pfnFreeUserData(pUserData);
188 2 : }
189 :
190 : /************************************************************************/
191 : /* OpenUnderlyingLayer() */
192 : /************************************************************************/
193 :
194 47 : int OGRProxiedLayer::OpenUnderlyingLayer()
195 : {
196 47 : CPLDebug("OGR", "OpenUnderlyingLayer(%p)", this);
197 47 : CPLAssert(poUnderlyingLayer == NULL);
198 47 : poPool->SetLastUsedLayer(this);
199 47 : poUnderlyingLayer = pfnOpenLayer(pUserData);
200 47 : if( poUnderlyingLayer == NULL )
201 : {
202 : CPLError(CE_Failure, CPLE_FileIO,
203 0 : "Cannot open underlying layer");
204 : }
205 47 : return poUnderlyingLayer != NULL;
206 : }
207 :
208 : /************************************************************************/
209 : /* CloseUnderlyingLayer() */
210 : /************************************************************************/
211 :
212 46 : void OGRProxiedLayer::CloseUnderlyingLayer()
213 : {
214 46 : CPLDebug("OGR", "CloseUnderlyingLayer(%p)", this);
215 46 : delete poUnderlyingLayer;
216 46 : poUnderlyingLayer = NULL;
217 46 : }
218 :
219 : /************************************************************************/
220 : /* GetSpatialFilter() */
221 : /************************************************************************/
222 :
223 0 : OGRGeometry *OGRProxiedLayer::GetSpatialFilter()
224 : {
225 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return NULL;
226 0 : return poUnderlyingLayer->GetSpatialFilter();
227 : }
228 :
229 : /************************************************************************/
230 : /* GetSpatialFilter() */
231 : /************************************************************************/
232 :
233 69 : void OGRProxiedLayer::SetSpatialFilter( OGRGeometry * poGeom )
234 : {
235 69 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return;
236 69 : poUnderlyingLayer->SetSpatialFilter(poGeom);
237 : }
238 :
239 : /************************************************************************/
240 : /* SetAttributeFilter() */
241 : /************************************************************************/
242 :
243 67 : OGRErr OGRProxiedLayer::SetAttributeFilter( const char * poAttrFilter )
244 : {
245 67 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
246 67 : return poUnderlyingLayer->SetAttributeFilter(poAttrFilter);
247 : }
248 :
249 : /************************************************************************/
250 : /* ResetReading() */
251 : /************************************************************************/
252 :
253 49 : void OGRProxiedLayer::ResetReading()
254 : {
255 49 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return;
256 49 : poUnderlyingLayer->ResetReading();
257 : }
258 :
259 : /************************************************************************/
260 : /* GetNextFeature() */
261 : /************************************************************************/
262 :
263 580 : OGRFeature *OGRProxiedLayer::GetNextFeature()
264 : {
265 580 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return NULL;
266 580 : return poUnderlyingLayer->GetNextFeature();
267 : }
268 :
269 : /************************************************************************/
270 : /* SetNextByIndex() */
271 : /************************************************************************/
272 :
273 0 : OGRErr OGRProxiedLayer::SetNextByIndex( long nIndex )
274 : {
275 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
276 0 : return poUnderlyingLayer->SetNextByIndex(nIndex);
277 : }
278 :
279 : /************************************************************************/
280 : /* GetFeature() */
281 : /************************************************************************/
282 :
283 0 : OGRFeature *OGRProxiedLayer::GetFeature( long nFID )
284 : {
285 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return NULL;
286 0 : return poUnderlyingLayer->GetFeature(nFID);
287 : }
288 :
289 : /************************************************************************/
290 : /* SetFeature() */
291 : /************************************************************************/
292 :
293 0 : OGRErr OGRProxiedLayer::SetFeature( OGRFeature *poFeature )
294 : {
295 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
296 0 : return poUnderlyingLayer->SetFeature(poFeature);
297 : }
298 :
299 : /************************************************************************/
300 : /* CreateFeature() */
301 : /************************************************************************/
302 :
303 0 : OGRErr OGRProxiedLayer::CreateFeature( OGRFeature *poFeature )
304 : {
305 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
306 0 : return poUnderlyingLayer->CreateFeature(poFeature);
307 : }
308 :
309 : /************************************************************************/
310 : /* DeleteFeature() */
311 : /************************************************************************/
312 :
313 0 : OGRErr OGRProxiedLayer::DeleteFeature( long nFID )
314 : {
315 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
316 0 : return poUnderlyingLayer->DeleteFeature(nFID);
317 : }
318 :
319 : /************************************************************************/
320 : /* GetName() */
321 : /************************************************************************/
322 :
323 0 : const char *OGRProxiedLayer::GetName()
324 : {
325 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return "";
326 0 : return poUnderlyingLayer->GetName();
327 : }
328 :
329 : /************************************************************************/
330 : /* GetGeomType() */
331 : /************************************************************************/
332 :
333 2 : OGRwkbGeometryType OGRProxiedLayer::GetGeomType()
334 : {
335 2 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return wkbUnknown;
336 2 : return poUnderlyingLayer->GetGeomType();
337 : }
338 :
339 : /************************************************************************/
340 : /* GetLayerDefn() */
341 : /************************************************************************/
342 :
343 57 : OGRFeatureDefn *OGRProxiedLayer::GetLayerDefn()
344 : {
345 57 : if( poFeatureDefn != NULL )
346 55 : return poFeatureDefn;
347 :
348 2 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() )
349 : {
350 0 : poFeatureDefn = new OGRFeatureDefn("");
351 : }
352 : else
353 : {
354 2 : poFeatureDefn = poUnderlyingLayer->GetLayerDefn();
355 : }
356 :
357 2 : poFeatureDefn->Reference();
358 :
359 2 : return poFeatureDefn;
360 : }
361 :
362 : /************************************************************************/
363 : /* GetSpatialRef() */
364 : /************************************************************************/
365 :
366 509 : OGRSpatialReference *OGRProxiedLayer::GetSpatialRef()
367 : {
368 509 : if( poSRS != NULL )
369 507 : return poSRS;
370 2 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return NULL;
371 2 : OGRSpatialReference* poRet = poUnderlyingLayer->GetSpatialRef();
372 2 : if( poRet != NULL )
373 : {
374 2 : poSRS = poRet;
375 2 : poSRS->Reference();
376 : }
377 2 : return poRet;
378 : }
379 :
380 : /************************************************************************/
381 : /* GetFeatureCount() */
382 : /************************************************************************/
383 :
384 12 : int OGRProxiedLayer::GetFeatureCount( int bForce )
385 : {
386 12 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return 0;
387 12 : return poUnderlyingLayer->GetFeatureCount(bForce);
388 : }
389 :
390 : /************************************************************************/
391 : /* GetExtent() */
392 : /************************************************************************/
393 :
394 2 : OGRErr OGRProxiedLayer::GetExtent(OGREnvelope *psExtent, int bForce)
395 : {
396 2 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
397 2 : return poUnderlyingLayer->GetExtent(psExtent, bForce);
398 : }
399 :
400 : /************************************************************************/
401 : /* TestCapability() */
402 : /************************************************************************/
403 :
404 51 : int OGRProxiedLayer::TestCapability( const char * pszCapability )
405 : {
406 51 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return FALSE;
407 51 : return poUnderlyingLayer->TestCapability(pszCapability);
408 : }
409 :
410 : /************************************************************************/
411 : /* CreateField() */
412 : /************************************************************************/
413 :
414 0 : OGRErr OGRProxiedLayer::CreateField( OGRFieldDefn *poField,
415 : int bApproxOK )
416 : {
417 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
418 0 : return poUnderlyingLayer->CreateField(poField, bApproxOK);
419 : }
420 :
421 : /************************************************************************/
422 : /* DeleteField() */
423 : /************************************************************************/
424 :
425 0 : OGRErr OGRProxiedLayer::DeleteField( int iField )
426 : {
427 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
428 0 : return poUnderlyingLayer->DeleteField(iField);
429 : }
430 :
431 : /************************************************************************/
432 : /* ReorderFields() */
433 : /************************************************************************/
434 :
435 0 : OGRErr OGRProxiedLayer::ReorderFields( int* panMap )
436 : {
437 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
438 0 : return poUnderlyingLayer->ReorderFields(panMap);
439 : }
440 :
441 : /************************************************************************/
442 : /* AlterFieldDefn() */
443 : /************************************************************************/
444 :
445 0 : OGRErr OGRProxiedLayer::AlterFieldDefn( int iField, OGRFieldDefn* poNewFieldDefn, int nFlags )
446 : {
447 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
448 0 : return poUnderlyingLayer->AlterFieldDefn(iField, poNewFieldDefn, nFlags);
449 : }
450 :
451 : /************************************************************************/
452 : /* SyncToDisk() */
453 : /************************************************************************/
454 :
455 0 : OGRErr OGRProxiedLayer::SyncToDisk()
456 : {
457 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
458 0 : return poUnderlyingLayer->SyncToDisk();
459 : }
460 :
461 : /************************************************************************/
462 : /* GetStyleTable() */
463 : /************************************************************************/
464 :
465 0 : OGRStyleTable *OGRProxiedLayer::GetStyleTable()
466 : {
467 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return NULL;
468 0 : return poUnderlyingLayer->GetStyleTable();
469 : }
470 :
471 : /************************************************************************/
472 : /* SetStyleTableDirectly() */
473 : /************************************************************************/
474 :
475 0 : void OGRProxiedLayer::SetStyleTableDirectly( OGRStyleTable *poStyleTable )
476 : {
477 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return;
478 0 : return poUnderlyingLayer->SetStyleTableDirectly(poStyleTable);
479 : }
480 :
481 : /************************************************************************/
482 : /* SetStyleTable() */
483 : /************************************************************************/
484 :
485 0 : void OGRProxiedLayer::SetStyleTable(OGRStyleTable *poStyleTable)
486 : {
487 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return;
488 0 : return poUnderlyingLayer->SetStyleTable(poStyleTable);
489 : }
490 :
491 : /************************************************************************/
492 : /* StartTransaction() */
493 : /************************************************************************/
494 :
495 0 : OGRErr OGRProxiedLayer::StartTransaction()
496 : {
497 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
498 0 : return poUnderlyingLayer->StartTransaction();
499 : }
500 :
501 : /************************************************************************/
502 : /* CommitTransaction() */
503 : /************************************************************************/
504 :
505 0 : OGRErr OGRProxiedLayer::CommitTransaction()
506 : {
507 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
508 0 : return poUnderlyingLayer->CommitTransaction();
509 : }
510 :
511 : /************************************************************************/
512 : /* RollbackTransaction() */
513 : /************************************************************************/
514 :
515 0 : OGRErr OGRProxiedLayer::RollbackTransaction()
516 : {
517 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
518 0 : return poUnderlyingLayer->RollbackTransaction();
519 : }
520 :
521 : /************************************************************************/
522 : /* GetFIDColumn() */
523 : /************************************************************************/
524 :
525 0 : const char *OGRProxiedLayer::GetFIDColumn()
526 : {
527 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return "";
528 0 : return poUnderlyingLayer->GetFIDColumn();
529 : }
530 :
531 : /************************************************************************/
532 : /* GetGeometryColumn() */
533 : /************************************************************************/
534 :
535 0 : const char *OGRProxiedLayer::GetGeometryColumn()
536 : {
537 0 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return "";
538 0 : return poUnderlyingLayer->GetGeometryColumn();
539 : }
540 :
541 : /************************************************************************/
542 : /* SetIgnoredFields() */
543 : /************************************************************************/
544 :
545 49 : OGRErr OGRProxiedLayer::SetIgnoredFields( const char **papszFields )
546 : {
547 49 : if( poUnderlyingLayer == NULL && !OpenUnderlyingLayer() ) return OGRERR_FAILURE;
548 49 : return poUnderlyingLayer->SetIgnoredFields(papszFields);
549 : }
550 :
|
