LCOV - code coverage report
Current view: directory - ogr/ogrsf_frmts/generic - ogrlayerpool.cpp (source / functions) Found Hit Coverage
Test: gdal_filtered.info Lines: 193 131 67.9 %
Date: 2012-12-26 Functions: 49 21 42.9 %

       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                 : 

Generated by: LCOV version 1.7