自学教程：C++ GetLayerDefn函数代码示例

void OGRILI1Layer::JoinGeomLayers(){    bGeomsJoined = TRUE;    int bResetConfigOption = FALSE;    if (EQUAL(CPLGetConfigOption("OGR_ARC_STEPSIZE", ""), ""))    {        bResetConfigOption = TRUE;        CPLSetThreadLocalConfigOption("OGR_ARC_STEPSIZE", "0.96");    }    for (GeomFieldInfos::const_iterator it = oGeomFieldInfos.begin(); it != oGeomFieldInfos.end(); ++it)    {        OGRFeatureDefn* geomFeatureDefn = it->second.geomTable;        if (geomFeatureDefn)        {            CPLDebug( "OGR_ILI", "Join geometry table %s of field '%s'", geomFeatureDefn->GetName(), it->first.c_str() );            OGRILI1Layer* poGeomLayer = poDS->GetLayerByName(geomFeatureDefn->GetName());            int nGeomFieldIndex = GetLayerDefn()->GetGeomFieldIndex(it->first.c_str());            if (it->second.iliGeomType == "Surface")            {                JoinSurfaceLayer(poGeomLayer, nGeomFieldIndex);            }            else if (it->second.iliGeomType == "Area")            {                CPLString pointField = it->first + "__Point";                int nPointFieldIndex = GetLayerDefn()->GetGeomFieldIndex(pointField.c_str());                PolygonizeAreaLayer(poGeomLayer, nGeomFieldIndex, nPointFieldIndex);            }        }    }    if( bResetConfigOption )        CPLSetThreadLocalConfigOption("OGR_ARC_STEPSIZE", NULL);}

void OGRILI1Layer::JoinSurfaceLayer( OGRILI1Layer* poSurfaceLineLayer, int nSurfaceFieldIndex ){    CPLDebug( "OGR_ILI", "Joining surface layer %s with geometries", GetLayerDefn()->GetName());    OGRwkbGeometryType geomType = GetLayerDefn()->GetGeomFieldDefn(nSurfaceFieldIndex)->GetType();    poSurfaceLineLayer->ResetReading();    while (OGRFeature *linefeature = poSurfaceLineLayer->GetNextFeatureRef()) {        //OBJE entries with same _RefTID are polygon rings of same feature        //TODO: non-numeric _RefTID/FID is not supported yet!        GIntBig reftid = linefeature->GetFieldAsInteger64(1); //_RefTID        OGRFeature *feature = GetFeatureRef((int)reftid);        if (feature) {            OGRCurvePolygon *poly;            if (feature->GetGeomFieldRef(nSurfaceFieldIndex)) {                CPLDebug( "OGR_ILI", "Adding ring to FID " CPL_FRMT_GIB, reftid );                poly = (OGRCurvePolygon *)feature->GetGeomFieldRef(nSurfaceFieldIndex);            } else {                poly = (geomType == wkbPolygon) ? new OGRPolygon() : new OGRCurvePolygon();                feature->SetGeomFieldDirectly(nSurfaceFieldIndex, poly);            }            OGRMultiCurve *lines = (OGRMultiCurve*)linefeature->GetGeomFieldRef(0);            for( int i = 0; i < lines->getNumGeometries(); i++ ) {                OGRCurve *line = (OGRCurve*)lines->getGeometryRef(i);                OGRCurve *ring = (geomType == wkbPolygon) ?                                 OGRCurve::CastToLinearRing((OGRCurve*)line->clone()) :                                 (OGRCurve*)line->clone();                poly->addRingDirectly(ring);            }        } else {            CPLError(CE_Warning, CPLE_AppDefined, "Couldn't join feature FID " CPL_FRMT_GIB, reftid );        }    }    ResetReading();    poSurfaceLineLayer = 0;}

void OGRPGResultLayer::SetSpatialFilter( int iGeomField, OGRGeometry * poGeomIn ){    if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() ||        GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetType() == wkbNone )    {        if( iGeomField != 0 )        {            CPLError(CE_Failure, CPLE_AppDefined,                     "Invalid geometry field index : %d", iGeomField);        }        return;    }    m_iGeomFieldFilter = iGeomField;    OGRPGGeomFieldDefn* poGeomFieldDefn =        poFeatureDefn->myGetGeomFieldDefn(m_iGeomFieldFilter);    if( InstallFilter( poGeomIn ) )    {        if ( poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOMETRY ||             poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOGRAPHY )        {            if( m_poFilterGeom != NULL)            {                char szBox3D_1[128];                char szBox3D_2[128];                OGREnvelope  sEnvelope;                m_poFilterGeom->getEnvelope( &sEnvelope );                if( poGeomFieldDefn->ePostgisType == GEOM_TYPE_GEOGRAPHY )                {                    if( sEnvelope.MinX < -180.0 )                        sEnvelope.MinX = -180.0;                    if( sEnvelope.MinY < -90.0 )                        sEnvelope.MinY = -90.0;                    if( sEnvelope.MaxX > 180.0 )                        sEnvelope.MaxX = 180.0;                    if( sEnvelope.MaxY > 90.0 )                        sEnvelope.MaxY = 90.0;                }                CPLsnprintf(szBox3D_1, sizeof(szBox3D_1), "%.18g %.18g", sEnvelope.MinX, sEnvelope.MinY);                CPLsnprintf(szBox3D_2, sizeof(szBox3D_2), "%.18g %.18g", sEnvelope.MaxX, sEnvelope.MaxY);                osWHERE.Printf("WHERE %s && %s('BOX3D(%s, %s)'::box3d,%d) ",                               OGRPGEscapeColumnName(poGeomFieldDefn->GetNameRef()).c_str(),                               (poDS->sPostGISVersion.nMajor >= 2) ? "ST_SetSRID" : "SetSRID",                               szBox3D_1, szBox3D_2, poGeomFieldDefn->nSRSId );            }            else            {                osWHERE = "";            }            BuildFullQueryStatement();        }        ResetReading();    }}

void OGRUnionLayer::AutoWarpLayerIfNecessary(int iLayer){    if( !pabCheckIfAutoWrap[iLayer] )    {        pabCheckIfAutoWrap[iLayer] = TRUE;        for(int i=0; i<GetLayerDefn()->GetGeomFieldCount();i++)        {            OGRSpatialReference* poSRS = GetLayerDefn()->GetGeomFieldDefn(i)->GetSpatialRef();            if( poSRS != NULL )                poSRS->Reference();            OGRFeatureDefn* poSrcFeatureDefn = papoSrcLayers[iLayer]->GetLayerDefn();            int iSrcGeomField = poSrcFeatureDefn->GetGeomFieldIndex(                    GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef());            if( iSrcGeomField >= 0 )            {                OGRSpatialReference* poSRS2 =                    poSrcFeatureDefn->GetGeomFieldDefn(iSrcGeomField)->GetSpatialRef();                if( (poSRS == NULL && poSRS2 != NULL) ||                    (poSRS != NULL && poSRS2 == NULL) )                {                    CPLError(CE_Warning, CPLE_AppDefined,                            "SRS of geometry field '%s' layer %s not consistent with UnionLayer SRS",                            GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef(),                            papoSrcLayers[iLayer]->GetName());                }                else if (poSRS != NULL && poSRS2 != NULL &&                        poSRS != poSRS2 && !poSRS->IsSame(poSRS2))                {                    CPLDebug("VRT", "SRS of geometry field '%s' layer %s not consistent with UnionLayer SRS. "                            "Trying auto warping",                            GetLayerDefn()->GetGeomFieldDefn(i)->GetNameRef(),                            papoSrcLayers[iLayer]->GetName());                    OGRCoordinateTransformation* poCT =                        OGRCreateCoordinateTransformation( poSRS2, poSRS );                    OGRCoordinateTransformation* poReversedCT = (poCT != NULL) ?                        OGRCreateCoordinateTransformation( poSRS, poSRS2 ) : NULL;                    if( poReversedCT != NULL )                        papoSrcLayers[iLayer] = new OGRWarpedLayer(                                    papoSrcLayers[iLayer], iSrcGeomField, TRUE, poCT, poReversedCT);                    else                    {                        CPLError(CE_Warning, CPLE_AppDefined,                                 "AutoWarpLayerIfNecessary failed to create "                                 "poCT or poReversedCT.");                        if ( poCT != NULL )                            delete poCT;                    }                }            }            if( poSRS != NULL )                poSRS->Release();        }    }}

OGRFeature *OGRGFTLayer::GetNextFeature(){    GetLayerDefn();    while( true )    {        if (nNextInSeq < nOffset ||            nNextInSeq >= nOffset + static_cast<int>(aosRows.size()))        {            if (bEOF)                return nullptr;            nOffset += static_cast<int>(aosRows.size());            if (!FetchNextRows())                return nullptr;        }        OGRFeature *poFeature = GetNextRawFeature();        if (poFeature == nullptr)            return nullptr;        if((m_poFilterGeom == nullptr            || FilterGeometry( poFeature->GetGeometryRef() ) )        && (m_poAttrQuery == nullptr            || m_poAttrQuery->Evaluate( poFeature )) )        {            return poFeature;        }        else            delete poFeature;    }}

OGRErr OGRUnionLayer::SetAttributeFilter( const char * pszAttributeFilterIn ){    if( pszAttributeFilterIn == NULL && pszAttributeFilter == NULL)        return OGRERR_NONE;    if( pszAttributeFilterIn != NULL && pszAttributeFilter != NULL &&        strcmp(pszAttributeFilterIn, pszAttributeFilter) == 0)        return OGRERR_NONE;    if( poFeatureDefn == NULL ) GetLayerDefn();    bAttrFilterPassThroughValue = -1;    OGRErr eErr = OGRLayer::SetAttributeFilter(pszAttributeFilterIn);    if( eErr != OGRERR_NONE )        return eErr;    CPLFree(pszAttributeFilter);    pszAttributeFilter = pszAttributeFilterIn ?                                CPLStrdup(pszAttributeFilterIn) : NULL;    if( iCurLayer >= 0 && iCurLayer < nSrcLayers)        ApplyAttributeFilterToSrcLayer(iCurLayer);    return OGRERR_NONE;}

OGRFeature* OGRCARTODBTableLayer::GetFeature( GIntBig nFeatureId ){    if( bDeferedCreation && RunDeferedCreationIfNecessary() != OGRERR_NONE )        return NULL;    FlushDeferedInsert();    GetLayerDefn();        if( osFIDColName.size() == 0 )        return OGRCARTODBLayer::GetFeature(nFeatureId);    CPLString osSQL = osSELECTWithoutWHERE;    osSQL += " WHERE ";    osSQL += OGRCARTODBEscapeIdentifier(osFIDColName).c_str();    osSQL += " = ";    osSQL += CPLSPrintf(CPL_FRMT_GIB, nFeatureId);    json_object* poObj = poDS->RunSQL(osSQL);    json_object* poRowObj = OGRCARTODBGetSingleRow(poObj);    if( poRowObj == NULL )    {        if( poObj != NULL )            json_object_put(poObj);        return OGRCARTODBLayer::GetFeature(nFeatureId);    }    OGRFeature* poFeature = BuildFeature(poRowObj);    json_object_put(poObj);    return poFeature;}

OGRFeature *OGRGFTLayer::GetNextFeature(){    OGRFeature  *poFeature;    GetLayerDefn();    while(TRUE)    {        if (nNextInSeq < nOffset ||            nNextInSeq >= nOffset + (int)aosRows.size())        {            if (bEOF)                return NULL;            nOffset += aosRows.size();            if (!FetchNextRows())                return NULL;        }        poFeature = GetNextRawFeature();        if (poFeature == NULL)            return NULL;        if((m_poFilterGeom == NULL            || FilterGeometry( poFeature->GetGeometryRef() ) )        && (m_poAttrQuery == NULL            || m_poAttrQuery->Evaluate( poFeature )) )        {            return poFeature;        }        else            delete poFeature;    }}

void OGRGeoJSONLayer::AddFeature( OGRFeature* poFeature ){    CPLAssert( NULL != poFeature );    // NOTE - mloskot:    // Features may not be sorted according to FID values.    // TODO: Should we check if feature already exists?    // TODO: Think about sync operation, upload, etc.    OGRFeature* poNewFeature = NULL;    poNewFeature = poFeature->Clone();    if( -1 == poNewFeature->GetFID() )    {        int nFID = static_cast<int>(seqFeatures_.size());        poNewFeature->SetFID( nFID );        // TODO - mlokot: We need to redesign creation of FID column        int nField = poNewFeature->GetFieldIndex( DefaultFIDColumn );        if( -1 != nField && GetLayerDefn()->GetFieldDefn(nField)->GetType() == OFTInteger )        {            poNewFeature->SetField( nField, nFID );        }    }    seqFeatures_.push_back( poNewFeature );}

OGRErr OGRLayer::GetExtent(OGREnvelope *psExtent, int bForce ){    OGRFeature  *poFeature;    OGREnvelope oEnv;    GBool       bExtentSet = FALSE;    /* -------------------------------------------------------------------- */    /*      If this layer has a none geometry type, then we can             */    /*      reasonably assume there are not extents available.              */    /* -------------------------------------------------------------------- */    if( GetLayerDefn()->GetGeomType() == wkbNone )    {        psExtent->MinX = 0.0;        psExtent->MaxX = 0.0;        psExtent->MinY = 0.0;        psExtent->MaxY = 0.0;        return OGRERR_FAILURE;    }    /* -------------------------------------------------------------------- */    /*      If not forced, we should avoid having to scan all the           */    /*      features and just return a failure.                             */    /* -------------------------------------------------------------------- */    if( !bForce )        return OGRERR_FAILURE;    /* -------------------------------------------------------------------- */    /*      OK, we hate to do this, but go ahead and read through all       */    /*      the features to collect geometries and build extents.           */    /* -------------------------------------------------------------------- */    ResetReading();    while( (poFeature = GetNextFeature()) != NULL )    {        OGRGeometry *poGeom = poFeature->GetGeometryRef();        if (poGeom && !bExtentSet)        {            poGeom->getEnvelope(psExtent);            bExtentSet = TRUE;        }        else if (poGeom)        {            poGeom->getEnvelope(&oEnv);            if (oEnv.MinX < psExtent->MinX)                psExtent->MinX = oEnv.MinX;            if (oEnv.MinY < psExtent->MinY)                psExtent->MinY = oEnv.MinY;            if (oEnv.MaxX > psExtent->MaxX)                psExtent->MaxX = oEnv.MaxX;            if (oEnv.MaxY > psExtent->MaxY)                psExtent->MaxY = oEnv.MaxY;        }        delete poFeature;    }    ResetReading();    return (bExtentSet ? OGRERR_NONE : OGRERR_FAILURE);}

GIntBig OGRSVGLayer::GetFeatureCount( int bForce ){    if (m_poAttrQuery != NULL || m_poFilterGeom != NULL)        return OGRLayer::GetFeatureCount(bForce);    GetLayerDefn();    return nTotalFeatures;}

void OGRILI1Layer::JoinSurfaceLayer(){    if (poSurfacePolyLayer == 0) return;    CPLDebug( "OGR_ILI", "Joining surface layer %s with geometries", GetLayerDefn()->GetName());    GetLayerDefn()->SetGeomType(poSurfacePolyLayer->GetLayerDefn()->GetGeomType());    ResetReading();    while (OGRFeature *feature = GetNextFeatureRef())    {        OGRFeature *polyfeature = poSurfacePolyLayer->GetFeatureRef(feature->GetFID());        if (polyfeature) {            feature->SetGeometry(polyfeature->GetGeometryRef());        }    }    ResetReading();    poSurfacePolyLayer = 0;}

OGRErr OGRGFTTableLayer::DeleteFeature( long nFID ){    GetLayerDefn();    if (!poDS->IsReadWrite())    {        CPLError(CE_Failure, CPLE_AppDefined,                 "Operation not available in read-only mode");        return OGRERR_FAILURE;    }    if (osTableId.size() == 0)    {        CPLError(CE_Failure, CPLE_NotSupported,                "Cannot delete feature in non-created table");        return OGRERR_FAILURE;    }    if (poDS->GetAuth().size() == 0)    {        CPLError(CE_Failure, CPLE_AppDefined,                 "Operation not available in unauthenticated mode");        return OGRERR_FAILURE;    }    CPLString      osCommand;    osCommand += "DELETE FROM ";    osCommand += osTableId;    osCommand += " WHERE ROWID = '";    osCommand += CPLSPrintf("%ld", nFID);    osCommand += "'";    //CPLDebug("GFT", "%s",  osCommand.c_str());    CPLHTTPResult * psResult = poDS->RunSQL(osCommand);    if (psResult == NULL)    {        CPLError(CE_Failure, CPLE_AppDefined, "Feature deletion failed");        return OGRERR_FAILURE;    }    char* pszLine = (char*) psResult->pabyData;    if (pszLine == NULL ||        strncmp(pszLine, "OK", 2) != 0 ||        psResult->pszErrBuf != NULL)    {        CPLError(CE_Failure, CPLE_AppDefined, "Feature deletion failed");        CPLHTTPDestroyResult(psResult);        return OGRERR_FAILURE;    }    CPLHTTPDestroyResult(psResult);    return OGRERR_NONE;}

const char *OGRDB2Layer::GetFIDColumn(){    GetLayerDefn();    if( pszFIDColumn != nullptr )        return pszFIDColumn;    else        return "";}

int OGROCIWritableLayer::FindFieldIndex( const char *pszFieldName, int bExactMatch ){  int iField = GetLayerDefn()->GetFieldIndex( pszFieldName );  if( !bExactMatch && iField < 0 )  {      // try laundered version      OGROCISession *poSession = poDS->GetSession();      char *pszSafeName = CPLStrdup( pszFieldName );      poSession->CleanName( pszSafeName );      iField = GetLayerDefn()->GetFieldIndex( pszSafeName );      CPLFree( pszSafeName );  }  return iField;}

const char *OGRMSSQLSpatialLayer::GetGeometryColumn() {    GetLayerDefn();    if( pszGeomColumn != NULL )        return pszGeomColumn;    else        return "";}

void OGRWarpedLayer::SetSpatialFilter( int iGeomField, OGRGeometry *poGeom ){    if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() )    {        CPLError(CE_Failure, CPLE_AppDefined,                    "Invalid geometry field index : %d", iGeomField);        return;    }    m_iGeomFieldFilter = iGeomField;    if( InstallFilter( poGeom ) )        ResetReading();    if( m_iGeomFieldFilter == m_iGeomField )    {        if( poGeom == NULL || m_poReversedCT == NULL )        {            m_poDecoratedLayer->SetSpatialFilter(m_iGeomFieldFilter,                                                NULL);        }        else        {            OGREnvelope sEnvelope;            poGeom->getEnvelope(&sEnvelope);            if( CPLIsInf(sEnvelope.MinX) && CPLIsInf(sEnvelope.MinY) &&                CPLIsInf(sEnvelope.MaxX) && CPLIsInf(sEnvelope.MaxY) )            {                m_poDecoratedLayer->SetSpatialFilterRect(m_iGeomFieldFilter,                                                        sEnvelope.MinX,                                                        sEnvelope.MinY,                                                        sEnvelope.MaxX,                                                        sEnvelope.MaxY);            }            else if( ReprojectEnvelope(&sEnvelope, m_poReversedCT) )            {                m_poDecoratedLayer->SetSpatialFilterRect(m_iGeomFieldFilter,                                                        sEnvelope.MinX,                                                        sEnvelope.MinY,                                                        sEnvelope.MaxX,                                                        sEnvelope.MaxY);            }            else            {                m_poDecoratedLayer->SetSpatialFilter(m_iGeomFieldFilter,                                                    NULL);            }        }    }    else    {        m_poDecoratedLayer->SetSpatialFilter(m_iGeomFieldFilter,                                             poGeom);    }}

OGRFeature * OGRGFTTableLayer::GetFeature( GIntBig nFID ){    GetLayerDefn();    CPLString osSQL("SELECT ROWID");    for(int i=0;i<poFeatureDefn->GetFieldCount();i++)    {        osSQL += ",";        const char* pszFieldName =            poFeatureDefn->GetFieldDefn(i)->GetNameRef();        osSQL += EscapeAndQuote(pszFieldName);    }    if (bHiddenGeometryField)    {        osSQL += ",";        osSQL += EscapeAndQuote(GetGeometryColumn());    }    osSQL += " FROM ";    osSQL += osTableId;    osSQL += CPLSPrintf(" WHERE ROWID='" CPL_FRMT_GIB "'", nFID);    CPLPushErrorHandler(CPLQuietErrorHandler);    CPLHTTPResult * psResult = poDS->RunSQL(osSQL);    CPLPopErrorHandler();    if (psResult == NULL)        return NULL;    char* pszLine = (char*) psResult->pabyData;    if (pszLine == NULL || psResult->pszErrBuf != NULL)    {        CPLHTTPDestroyResult(psResult);        return NULL;    }    /* skip header line */    pszLine = OGRGFTGotoNextLine(pszLine);    if (pszLine == NULL || pszLine[0] == 0)    {        CPLHTTPDestroyResult(psResult);        return NULL;    }    int nLen = (int)strlen(pszLine);    if (nLen > 0 && pszLine[nLen-1] == '/n')        pszLine[nLen-1] = '/0';    OGRFeature* poFeature = BuildFeatureFromSQL(pszLine);    CPLHTTPDestroyResult(psResult);    return poFeature;}

OGRErr OGRUnionLayer::GetExtent(int iGeomField, OGREnvelope *psExtent, int bForce){    if( iGeomField >= 0 && iGeomField < nGeomFields &&        papoGeomFields[iGeomField]->sStaticEnvelope.IsInit() )    {        memcpy(psExtent, &papoGeomFields[iGeomField]->sStaticEnvelope, sizeof(OGREnvelope));        return OGRERR_NONE;    }    if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() )    {        CPLError(CE_Failure, CPLE_AppDefined,                     "Invalid geometry field index : %d", iGeomField);        return OGRERR_FAILURE;    }    int bInit = FALSE;    for(int i = 0; i < nSrcLayers; i++)    {        AutoWarpLayerIfNecessary(i);        int iSrcGeomField = papoSrcLayers[i]->GetLayerDefn()->GetGeomFieldIndex(            GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetNameRef());        if( iSrcGeomField >= 0 )        {            if( !bInit )            {                if( papoSrcLayers[i]->GetExtent(iSrcGeomField, psExtent, bForce) == OGRERR_NONE )                    bInit = TRUE;            }            else            {                OGREnvelope sExtent;                if( papoSrcLayers[i]->GetExtent(iSrcGeomField, &sExtent, bForce) == OGRERR_NONE )                {                    psExtent->Merge(sExtent);                }            }        }    }    return (bInit) ? OGRERR_NONE : OGRERR_FAILURE;}

OGRFeature * OGRLayerWithTransaction::GetFeature( GIntBig nFID ){    if( !m_poDecoratedLayer ) return NULL;    OGRFeature* poSrcFeature = m_poDecoratedLayer->GetFeature(nFID);    if( !poSrcFeature )        return NULL;    OGRFeature* poFeature = new OGRFeature(GetLayerDefn());    poFeature->SetFrom(poSrcFeature);    poFeature->SetFID(poSrcFeature->GetFID());    delete poSrcFeature;    return poFeature;}

OGRErr OGRLayer::ReorderField( int iOldFieldPos, int iNewFieldPos ){    OGRErr eErr;    int nFieldCount = GetLayerDefn()->GetFieldCount();    if (iOldFieldPos < 0 || iOldFieldPos >= nFieldCount)    {        CPLError( CE_Failure, CPLE_NotSupported,                  "Invalid field index");        return OGRERR_FAILURE;    }    if (iNewFieldPos < 0 || iNewFieldPos >= nFieldCount)    {        CPLError( CE_Failure, CPLE_NotSupported,                  "Invalid field index");        return OGRERR_FAILURE;    }    if (iNewFieldPos == iOldFieldPos)        return OGRERR_NONE;    int* panMap = (int*) CPLMalloc(sizeof(int) * nFieldCount);    int i;    if (iOldFieldPos < iNewFieldPos)    {        /* "0","1","2","3","4" (1,3) -> "0","2","3","1","4" */        for(i=0;i<iOldFieldPos;i++)            panMap[i] = i;        for(;i<iNewFieldPos;i++)            panMap[i] = i + 1;        panMap[iNewFieldPos] = iOldFieldPos;        for(i=iNewFieldPos+1;i<nFieldCount;i++)            panMap[i] = i;    }    else    {        /* "0","1","2","3","4" (3,1) -> "0","3","1","2","4" */        for(i=0;i<iNewFieldPos;i++)            panMap[i] = i;        panMap[iNewFieldPos] = iOldFieldPos;        for(i=iNewFieldPos+1;i<=iOldFieldPos;i++)            panMap[i] = i - 1;        for(;i<nFieldCount;i++)            panMap[i] = i;    }    eErr = ReorderFields(panMap);    CPLFree(panMap);    return eErr;}

void OGRCARTODBTableLayer::SetSpatialFilter( int iGeomField, OGRGeometry * poGeomIn ){    if( iGeomField < 0 || iGeomField >= GetLayerDefn()->GetGeomFieldCount() ||        GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetType() == wkbNone )    {        if( iGeomField != 0 )        {            CPLError(CE_Failure, CPLE_AppDefined,                     "Invalid geometry field index : %d", iGeomField);        }        return;    }    m_iGeomFieldFilter = iGeomField;    if( InstallFilter( poGeomIn ) )    {        BuildWhere();        ResetReading();    }}

/*!  /brief Get feature (private)    /return pointer to OGRFeature  /return NULL not found*/OGRFeature *OGRVFKLayer::GetFeature(VFKFeature *poVFKFeature){    OGRGeometry *poGeom;        /* skip feature with unknown geometry type */    if (poVFKFeature->GetGeometryType() == wkbUnknown)	return NULL;        /* get features geometry */    poGeom = CreateGeometry(poVFKFeature);    if (poGeom != NULL)	poGeom->assignSpatialReference(poSRS);        /* does it satisfy the spatial query, if there is one? */    if (m_poFilterGeom != NULL && poGeom && !FilterGeometry(poGeom)) {	return NULL;    }        /* convert the whole feature into an OGRFeature */    OGRFeature *poOGRFeature = new OGRFeature(GetLayerDefn());    poOGRFeature->SetFID(poVFKFeature->GetFID());    // poOGRFeature->SetFID(++m_iNextFeature);        for (int iField = 0; iField < poDataBlock->GetPropertyCount(); iField++) {	if (poVFKFeature->GetProperty(iField)->IsNull())	    continue;	OGRFieldType fType = poOGRFeature->GetDefnRef()->GetFieldDefn(iField)->GetType();	if (fType == OFTInteger) 	    poOGRFeature->SetField(iField,				   poVFKFeature->GetProperty(iField)->GetValueI());	else if (fType == OFTReal)	    poOGRFeature->SetField(iField,				   poVFKFeature->GetProperty(iField)->GetValueD());	else	    poOGRFeature->SetField(iField,				   poVFKFeature->GetProperty(iField)->GetValueS());    }        /* test against the attribute query */    if (m_poAttrQuery != NULL &&	!m_poAttrQuery->Evaluate(poOGRFeature)) {	delete poOGRFeature;	return NULL;    }        if (poGeom)	poOGRFeature->SetGeometryDirectly(poGeom->clone());        return poOGRFeature;}

GIntBig OGRXLSLayer::GetFeatureCount( int bForce ){    if( m_poAttrQuery == nullptr /* && m_poFilterGeom == NULL */ )    {        const char* pszXLSHeaders = CPLGetConfigOption("OGR_XLS_HEADERS", "");        if(EQUAL(pszXLSHeaders, "DISABLE"))            return nRows;        GetLayerDefn();        return bFirstLineIsHeaders ? nRows - 1 : nRows;    }    return OGRLayer::GetFeatureCount(bForce);}