OGRFeature *OGRSEGUKOOABaseLayer::GetNextFeature()
{
OGRFeature *poFeature;
while(TRUE)
{
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;
}
}
OGRFeature *OGRDXFBlocksLayer::GetNextFeature()
{
while( true )
{
OGRFeature *poFeature = GetNextUnfilteredFeature();
if( poFeature == NULL )
return NULL;
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature ) ) )
{
return poFeature;
}
delete poFeature;
}
}
OGRFeature *OGRMySQLLayer::GetNextFeature()
{
for( ; TRUE; )
{
OGRFeature *poFeature;
poFeature = GetNextRawFeature();
if( poFeature == NULL )
return NULL;
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
}
OGRFeature *OGRWarpedLayer::GetNextFeature()
{
while(TRUE)
{
OGRFeature* poFeature = m_poDecoratedLayer->GetNextFeature();
if( poFeature == NULL )
return NULL;
OGRFeature* poFeatureNew = SrcFeatureToWarpedFeature(poFeature);
delete poFeature;
OGRGeometry* poGeom = poFeatureNew->GetGeomFieldRef(m_iGeomField);
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
{
delete poFeatureNew;
continue;
}
return poFeatureNew;
}
}
OGRFeature *OGRMySQLLayer::GetNextFeature()
{
while( true )
{
OGRFeature *poFeature;
poFeature = GetNextRawFeature();
if( poFeature == nullptr )
return nullptr;
if( (m_poFilterGeom == nullptr
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == nullptr
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
}
int OGROSMLayer::AddFeature(OGRFeature* poFeature,
int bAttrFilterAlreadyEvaluated,
int* pbFilteredOut,
int bCheckFeatureThreshold)
{
if( !bUserInterested )
{
if (pbFilteredOut)
*pbFilteredOut = TRUE;
delete poFeature;
return TRUE;
}
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if (poGeom)
poGeom->assignSpatialReference( poSRS );
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL || bAttrFilterAlreadyEvaluated
|| m_poAttrQuery->Evaluate( poFeature )) )
{
if (!AddToArray(poFeature, bCheckFeatureThreshold))
{
delete poFeature;
return FALSE;
}
}
else
{
if (pbFilteredOut)
*pbFilteredOut = TRUE;
delete poFeature;
return TRUE;
}
if (pbFilteredOut)
*pbFilteredOut = FALSE;
return TRUE;
}
OGRFeature *OGRMemLayer::GetNextFeature()
{
while( iNextReadFID < nMaxFeatureCount )
{
OGRFeature *poFeature = papoFeatures[iNextReadFID++];
if( poFeature == NULL )
continue;
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeomFieldRef(m_iGeomFieldFilter) ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature ) ) )
{
m_nFeaturesRead++;
return poFeature->Clone();
}
}
return NULL;
}
OGRFeature* OGROpenFileGDBSimpleSQLLayer::GetNextFeature()
{
while(TRUE)
{
int nRow = poIter->GetNextRowSortedByValue();
if( nRow < 0 )
return NULL;
OGRFeature* poFeature = GetFeature(nRow + 1);
if( poFeature == NULL )
return NULL;
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL ||
m_poAttrQuery->Evaluate( poFeature ) ) )
{
return poFeature;
}
delete poFeature;
}
}
OGRFeature *OGRDGNLayer::GetNextFeature()
{
DGNElemCore *psElement;
DGNGetElementIndex( hDGN, NULL );
while( (psElement = DGNReadElement( hDGN )) != NULL )
{
OGRFeature *poFeature;
if( psElement->deleted )
{
DGNFreeElement( hDGN, psElement );
continue;
}
poFeature = ElementToFeature( psElement );
DGNFreeElement( hDGN, psElement );
if( poFeature == NULL )
continue;
if( poFeature->GetGeometryRef() == NULL )
{
delete poFeature;
continue;
}
if( (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature ))
&& FilterGeometry( poFeature->GetGeometryRef() ) )
return poFeature;
delete poFeature;
}
return NULL;
}
OGRFeature *OGRUnionLayer::GetNextFeature()
{
if( poFeatureDefn == NULL ) GetLayerDefn();
if( iCurLayer < 0 )
ResetReading();
if( iCurLayer == nSrcLayers )
return NULL;
while( true )
{
OGRFeature* poSrcFeature = papoSrcLayers[iCurLayer]->GetNextFeature();
if( poSrcFeature == NULL )
{
iCurLayer ++;
if( iCurLayer < nSrcLayers )
{
ConfigureActiveLayer();
continue;
}
else
break;
}
OGRFeature* poFeature = TranslateFromSrcLayer(poSrcFeature);
delete poSrcFeature;
if( (m_poFilterGeom == NULL ||
FilterGeometry( poFeature->GetGeomFieldRef(m_iGeomFieldFilter) ) ) &&
(m_poAttrQuery == NULL ||
m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
delete poFeature;
}
return NULL;
}
OGRFeature *OGRAeronavFAALayer::GetNextFeature()
{
while( true )
{
if( bEOF )
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;
}
}
OGRFeature *OGRPLScenesLayer::GetNextFeature()
{
if( !bFilterMustBeClientSideEvaluated )
return GetNextRawFeature();
while( true )
{
OGRFeature *poFeature = 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;
}
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature or NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(IVFKFeature *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);
poVFKFeature->LoadProperties(poOGRFeature);
/* 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;
}
OGRFeature *OGRGeoconceptLayer::GetNextFeature()
{
OGRFeature* poFeature = NULL;
for( ;; )
{
if( !(poFeature= (OGRFeature*)ReadNextFeature_GCIO(_gcFeature)) )
{
/*
* As several features are embed in the Geoconcept file,
* when reaching the end of the feature type, resetting
* the reader would allow reading other features :
* ogrinfo -ro export.gxt FT1 FT2 ...
* will be all features for all features types !
*/
Rewind_GCIO(GetSubTypeGCHandle_GCIO(_gcFeature),NULL);
break;
}
if( (m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) )
&&
(m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) )
{
break;
}
delete poFeature;
}
CPLDebug( "GEOCONCEPT",
"FID : %ld\n"
"%s : %s",
poFeature? poFeature->GetFID():-1L,
poFeature && poFeature->GetFieldCount()>0? poFeature->GetFieldDefnRef(0)->GetNameRef():"-",
poFeature && poFeature->GetFieldCount()>0? poFeature->GetFieldAsString(0):"");
return poFeature;
}
OGRFeature *OGRHTFLayer::GetNextFeature()
{
if (fpHTF == NULL || bEOF)
return NULL;
while(!bEOF)
{
OGRFeature *poFeature = GetNextRawFeature();
if (poFeature == NULL)
return NULL;
if((m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
delete poFeature;
}
return NULL;
}
OGRFeature *OGRShapeLayer::GetNextFeature()
{
OGRFeature *poFeature = NULL;
/* -------------------------------------------------------------------- */
/* Collect a matching list if we have attribute or spatial */
/* indices. Only do this on the first request for a given pass */
/* of course. */
/* -------------------------------------------------------------------- */
if( (m_poAttrQuery != NULL || m_poFilterGeom != NULL)
&& iNextShapeId == 0 && panMatchingFIDs == NULL )
{
ScanIndices();
}
/* -------------------------------------------------------------------- */
/* Loop till we find a feature matching our criteria. */
/* -------------------------------------------------------------------- */
while( TRUE )
{
if( panMatchingFIDs != NULL )
{
if( panMatchingFIDs[iMatchingFID] == OGRNullFID )
{
return NULL;
}
// Check the shape object's geometry, and if it matches
// any spatial filter, return it.
poFeature = FetchShape(panMatchingFIDs[iMatchingFID]);
iMatchingFID++;
}
else
{
if( iNextShapeId >= nTotalShapeCount )
{
return NULL;
}
if ( hDBF && DBFIsRecordDeleted( hDBF, iNextShapeId ) ) {
poFeature = NULL;
} else {
// Check the shape object's geometry, and if it matches
// any spatial filter, return it.
poFeature = FetchShape(iNextShapeId);
}
iNextShapeId++;
}
if( poFeature != NULL )
{
if( poFeature->GetGeometryRef() != NULL )
{
poFeature->GetGeometryRef()->assignSpatialReference( GetSpatialRef() );
}
m_nFeaturesRead++;
if( (m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
delete poFeature;
}
}
/*
* NEVER SHOULD GET HERE
*/
CPLAssert(!"OGRShapeLayer::GetNextFeature(): Execution never should get here!");
}
OGRFeature *OGRBNALayer::GetNextFeature()
{
OGRFeature *poFeature;
BNARecord* record;
int offset, line;
if (failed || eof) return NULL;
while(1)
{
int ok = FALSE;
offset = (int) VSIFTellL(fpBNA);
line = curLine;
if (nNextFID < nFeatures)
{
VSIFSeekL( fpBNA, offsetAndLineFeaturesTable[nNextFID].offset, SEEK_SET );
curLine = offsetAndLineFeaturesTable[nNextFID].line;
}
record = BNA_GetNextRecord(fpBNA, &ok, &curLine, TRUE, bnaFeatureType);
if (ok == FALSE)
{
BNA_FreeRecord(record);
failed = TRUE;
return NULL;
}
if (record == NULL)
{
/* end of file */
eof = TRUE;
/* and we have finally build the whole index table */
partialIndexTable = FALSE;
return NULL;
}
if (record->featureType == bnaFeatureType)
{
if (nNextFID >= nFeatures)
{
nFeatures++;
offsetAndLineFeaturesTable =
(OffsetAndLine*)CPLRealloc(offsetAndLineFeaturesTable, nFeatures * sizeof(OffsetAndLine));
offsetAndLineFeaturesTable[nFeatures-1].offset = offset;
offsetAndLineFeaturesTable[nFeatures-1].line = line;
}
poFeature = BuildFeatureFromBNARecord(record, nNextFID++);
BNA_FreeRecord(record);
if( (m_poFilterGeom == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
{
return poFeature;
}
delete poFeature;
}
else
{
BNA_FreeRecord(record);
}
}
}
OGRFeature *OGRNTFLayer::GetNextFeature()
{
OGRFeature *poFeature = NULL;
/* -------------------------------------------------------------------- */
/* Have we processed all features already? */
/* -------------------------------------------------------------------- */
if( iCurrentReader == poDS->GetFileCount() )
return NULL;
/* -------------------------------------------------------------------- */
/* Do we need to open a file? */
/* -------------------------------------------------------------------- */
if( iCurrentReader == -1 )
{
iCurrentReader++;
nCurrentPos = -1;
}
NTFFileReader *poCurrentReader = poDS->GetFileReader(iCurrentReader);
if( poCurrentReader->GetFP() == NULL )
{
poCurrentReader->Open();
}
/* -------------------------------------------------------------------- */
/* Ensure we are reading on from the same point we were reading */
/* from for the last feature, even if some other access */
/* mechanism has moved the file pointer. */
/* -------------------------------------------------------------------- */
if( nCurrentPos != -1 )
poCurrentReader->SetFPPos( nCurrentPos, nCurrentFID );
else
poCurrentReader->Reset();
/* -------------------------------------------------------------------- */
/* Read features till we find one that satisfies our current */
/* spatial criteria. */
/* -------------------------------------------------------------------- */
while( TRUE )
{
poFeature = poCurrentReader->ReadOGRFeature( this );
if( poFeature == NULL )
break;
m_nFeaturesRead++;
if( (m_poFilterGeom == NULL
|| poFeature->GetGeometryRef() == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
break;
delete poFeature;
}
/* -------------------------------------------------------------------- */
/* If we get NULL the file must be all consumed, advance to the */
/* next file that contains features for this layer. */
/* -------------------------------------------------------------------- */
if( poFeature == NULL )
{
poCurrentReader->Close();
if( poDS->GetOption("CACHING") != NULL
&& EQUAL(poDS->GetOption("CACHING"),"OFF") )
{
poCurrentReader->DestroyIndex();
}
do {
iCurrentReader++;
} while( iCurrentReader < poDS->GetFileCount()
&& !poDS->GetFileReader(iCurrentReader)->TestForLayer(this) );
nCurrentPos = -1;
nCurrentFID = 1;
poFeature = GetNextFeature();
}
else
{
poCurrentReader->GetFPPos(&nCurrentPos, &nCurrentFID);
}
return poFeature;
}
OGRFeature *OGROGDILayer::GetNextFeature()
{
OGRFeature *poFeature=NULL;
ecs_Result *psResult;
int i;
/* Reset reading if we are not the current layer */
/* WARNING : this does not allow interleaved reading of layers */
if( m_poODS->GetCurrentLayer() != this )
{
m_poODS->SetCurrentLayer(this);
ResetReading();
}
/* -------------------------------------------------------------------- */
/* Retrieve object from OGDI server and create new feature */
/* -------------------------------------------------------------------- */
TryAgain:
psResult = cln_GetNextObject(m_nClientID);
if (! ECSSUCCESS(psResult))
{
// We probably reached EOF... keep track of shape count.
m_nTotalShapeCount = m_iNextShapeId;
return NULL;
}
poFeature = new OGRFeature(m_poFeatureDefn);
poFeature->SetFID( m_iNextShapeId++ );
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Process geometry */
/* -------------------------------------------------------------------- */
if (m_eFamily == Point)
{
ecs_Point *psPoint = &(ECSGEOM(psResult).point);
OGRPoint *poOGRPoint = new OGRPoint(psPoint->c.x, psPoint->c.y);
poFeature->SetGeometryDirectly(poOGRPoint);
}
else if (m_eFamily == Line)
{
ecs_Line *psLine = &(ECSGEOM(psResult).line);
OGRLineString *poOGRLine = new OGRLineString();
poOGRLine->setNumPoints( psLine->c.c_len );
for( i=0; i < (int) psLine->c.c_len; i++ )
{
poOGRLine->setPoint(i, psLine->c.c_val[i].x, psLine->c.c_val[i].y);
}
poFeature->SetGeometryDirectly(poOGRLine);
}
else if (m_eFamily == Area)
{
ecs_Area *psArea = &(ECSGEOM(psResult).area);
OGRPolygon *poOGRPolygon = new OGRPolygon();
for(int iRing=0; iRing < (int) psArea->ring.ring_len; iRing++)
{
ecs_FeatureRing *psRing = &(psArea->ring.ring_val[iRing]);
OGRLinearRing *poOGRRing = new OGRLinearRing();
poOGRRing->setNumPoints( psRing->c.c_len );
for( i=0; i < (int) psRing->c.c_len; i++ )
{
poOGRRing->setPoint(i, psRing->c.c_val[i].x,
psRing->c.c_val[i].y);
}
poOGRPolygon->addRingDirectly(poOGRRing);
}
// __TODO__
// When OGR supports polygon centroids then we should carry them here
poFeature->SetGeometryDirectly(poOGRPolygon);
}
else if (m_eFamily == Text)
{
// __TODO__
// For now text is treated as a point and string is lost
//
ecs_Text *psText = &(ECSGEOM(psResult).text);
OGRPoint *poOGRPoint = new OGRPoint(psText->c.x, psText->c.y);
poFeature->SetGeometryDirectly(poOGRPoint);
}
else
{
CPLAssert(FALSE);
}
/* -------------------------------------------------------------------- */
/* Set attributes */
/* -------------------------------------------------------------------- */
char *pszAttrList = ECSOBJECTATTR(psResult);
for( int iField = 0; iField < m_poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszFieldStart;
int nNameLen;
char chSavedChar;
/* parse out the next attribute value */
if( !ecs_FindElement( pszAttrList, &pszFieldStart, &pszAttrList,
&nNameLen, NULL ) )
{
nNameLen = 0;
pszFieldStart = pszAttrList;
}
/* Skip any trailing white space (for string constants). */
if( nNameLen > 0 && pszFieldStart[nNameLen-1] == ' ' )
nNameLen--;
/* skip leading white space */
while( pszFieldStart[0] == ' ' && nNameLen > 0 )
{
pszFieldStart++;
nNameLen--;
}
/* zero terminate the single field value, but save the */
/* character we overwrote, so we can restore it when done. */
chSavedChar = pszFieldStart[nNameLen];
pszFieldStart[nNameLen] = '\0';
/* OGR takes care of all field type conversions for us! */
poFeature->SetField(iField, pszFieldStart);
pszFieldStart[nNameLen] = chSavedChar;
}
/* -------------------------------------------------------------------- */
/* Apply the text associated with text features if appropriate. */
/* -------------------------------------------------------------------- */
if( m_eFamily == Text )
{
poFeature->SetField( "text", ECSGEOM(psResult).text.desc );
}
/* -------------------------------------------------------------------- */
/* Do we need to apply an attribute test? */
/* -------------------------------------------------------------------- */
if( (m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poFeature ) )
|| (m_poFilterGeom != NULL
&& !FilterGeometry( poFeature->GetGeometryRef() ) ) )
{
delete poFeature;
goto TryAgain;
}
return poFeature;
}
OGRFeature *OGRGMLLayer::GetNextFeature()
{
if (bWriter)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot read features when writing a GML file");
return NULL;
}
if( poDS->GetLastReadLayer() != this )
{
if( poDS->GetReadMode() != INTERLEAVED_LAYERS )
ResetReading();
poDS->SetLastReadLayer(this);
}
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( true )
{
GMLFeature *poGMLFeature = NULL;
OGRGeometry *poGeom = NULL;
poGMLFeature = poDS->PeekStoredGMLFeature();
if (poGMLFeature != NULL)
poDS->SetStoredGMLFeature(NULL);
else
{
poGMLFeature = poDS->GetReader()->NextFeature();
if( poGMLFeature == NULL )
return NULL;
// We count reading low level GML features as a feature read for
// work checking purposes, though at least we didn't necessary
// have to turn it into an OGRFeature.
m_nFeaturesRead++;
}
/* -------------------------------------------------------------------- */
/* Is it of the proper feature class? */
/* -------------------------------------------------------------------- */
if( poGMLFeature->GetClass() != poFClass )
{
if( poDS->GetReadMode() == INTERLEAVED_LAYERS ||
(poDS->GetReadMode() == SEQUENTIAL_LAYERS && iNextGMLId != 0) )
{
CPLAssert(poDS->PeekStoredGMLFeature() == NULL);
poDS->SetStoredGMLFeature(poGMLFeature);
return NULL;
}
else
{
delete poGMLFeature;
continue;
}
}
/* -------------------------------------------------------------------- */
/* Extract the fid: */
/* -Assumes the fids are non-negative integers with an optional */
/* prefix */
/* -If a prefix differs from the prefix of the first feature from */
/* the poDS then the fids from the poDS are ignored and are */
/* assigned serially thereafter */
/* -------------------------------------------------------------------- */
GIntBig nFID = -1;
const char * pszGML_FID = poGMLFeature->GetFID();
if( bInvalidFIDFound )
{
nFID = iNextGMLId++;
}
else if( pszGML_FID == NULL )
{
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
else if( iNextGMLId == 0 )
{
int j = 0;
int i = static_cast<int>(strlen( pszGML_FID ))-1;
while( i >= 0 && pszGML_FID[i] >= '0'
&& pszGML_FID[i] <= '9' && j<20)
i--, j++;
/* i points the last character of the fid */
if( i >= 0 && j < 20 && pszFIDPrefix == NULL)
{
pszFIDPrefix = (char *) CPLMalloc(i+2);
pszFIDPrefix[i+1] = '\0';
strncpy(pszFIDPrefix, pszGML_FID, i+1);
}
/* pszFIDPrefix now contains the prefix or NULL if no prefix is found */
if( j < 20 && sscanf(pszGML_FID+i+1, CPL_FRMT_GIB, &nFID)==1)
{
if( iNextGMLId <= nFID )
iNextGMLId = nFID + 1;
}
else
{
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
}
else if( iNextGMLId != 0 )
{
const char* pszFIDPrefix_notnull = pszFIDPrefix;
if (pszFIDPrefix_notnull == NULL) pszFIDPrefix_notnull = "";
int nLenPrefix = static_cast<int>(strlen(pszFIDPrefix_notnull));
if( strncmp(pszGML_FID, pszFIDPrefix_notnull, nLenPrefix) == 0 &&
strlen(pszGML_FID+nLenPrefix) < 20 &&
sscanf(pszGML_FID+nLenPrefix, CPL_FRMT_GIB, &nFID) == 1 )
{ /* fid with the prefix. Using its numerical part */
if( iNextGMLId < nFID )
iNextGMLId = nFID + 1;
}
else
{ /* fid without the aforementioned prefix or a valid numerical part */
bInvalidFIDFound = true;
nFID = iNextGMLId++;
}
}
/* -------------------------------------------------------------------- */
/* Does it satisfy the spatial query, if there is one? */
/* -------------------------------------------------------------------- */
OGRGeometry** papoGeometries = NULL;
const CPLXMLNode* const * papsGeometry = poGMLFeature->GetGeometryList();
if( poFeatureDefn->GetGeomFieldCount() > 1 )
{
papoGeometries = (OGRGeometry**)
CPLCalloc( poFeatureDefn->GetGeomFieldCount(), sizeof(OGRGeometry*) );
const char* pszSRSName = poDS->GetGlobalSRSName();
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
const CPLXMLNode* psGeom = poGMLFeature->GetGeometryRef(i);
if( psGeom != NULL )
{
const CPLXMLNode* myGeometryList[2];
myGeometryList[0] = psGeom;
myGeometryList[1] = NULL;
poGeom = GML_BuildOGRGeometryFromList(myGeometryList, true,
poDS->GetInvertAxisOrderIfLatLong(),
pszSRSName,
poDS->GetConsiderEPSGAsURN(),
poDS->GetSecondaryGeometryOption(),
hCacheSRS,
bFaceHoleNegative );
/* Do geometry type changes if needed to match layer geometry type */
if (poGeom != NULL)
{
papoGeometries[i] = OGRGeometryFactory::forceTo(poGeom,
poFeatureDefn->GetGeomFieldDefn(i)->GetType());
poGeom = NULL;
}
else
// We assume the createFromGML() function would have already
// reported the error.
{
for( i=0; i < poFeatureDefn->GetGeomFieldCount(); i++)
{
delete papoGeometries[i];
}
CPLFree(papoGeometries);
delete poGMLFeature;
return NULL;
}
}
}
if( m_poFilterGeom != NULL &&
m_iGeomFieldFilter >= 0 &&
m_iGeomFieldFilter < poFeatureDefn->GetGeomFieldCount() &&
papoGeometries[m_iGeomFieldFilter] &&
!FilterGeometry( papoGeometries[m_iGeomFieldFilter] ) )
{
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
delete papoGeometries[i];
}
CPLFree(papoGeometries);
delete poGMLFeature;
continue;
}
}
else if (papsGeometry[0] != NULL)
{
const char* pszSRSName = poDS->GetGlobalSRSName();
poGeom = GML_BuildOGRGeometryFromList(papsGeometry, true,
poDS->GetInvertAxisOrderIfLatLong(),
pszSRSName,
poDS->GetConsiderEPSGAsURN(),
poDS->GetSecondaryGeometryOption(),
hCacheSRS,
bFaceHoleNegative );
/* Do geometry type changes if needed to match layer geometry type */
if (poGeom != NULL)
{
poGeom = OGRGeometryFactory::forceTo(poGeom, GetGeomType());
}
else
// We assume the createFromGML() function would have already
// reported the error.
{
delete poGMLFeature;
return NULL;
}
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
{
delete poGMLFeature;
delete poGeom;
continue;
}
}
/* -------------------------------------------------------------------- */
/* Convert the whole feature into an OGRFeature. */
/* -------------------------------------------------------------------- */
int iField;
int iDstField = 0;
OGRFeature *poOGRFeature = new OGRFeature( poFeatureDefn );
poOGRFeature->SetFID( nFID );
if (poDS->ExposeId())
{
if (pszGML_FID)
poOGRFeature->SetField( iDstField, pszGML_FID );
iDstField ++;
}
int nPropertyCount = poFClass->GetPropertyCount();
for( iField = 0; iField < nPropertyCount; iField++, iDstField ++ )
{
const GMLProperty *psGMLProperty = poGMLFeature->GetProperty( iField );
if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 )
continue;
switch( poFClass->GetProperty(iField)->GetType() )
{
case GMLPT_Real:
{
poOGRFeature->SetField( iDstField, CPLAtof(psGMLProperty->papszSubProperties[0]) );
}
break;
case GMLPT_IntegerList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
for( int i = 0; i < nCount; i++ )
panIntList[i]
= atoi(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_Integer64List:
{
int nCount = psGMLProperty->nSubProperties;
GIntBig *panIntList = (GIntBig *) CPLMalloc(sizeof(GIntBig) * nCount );
for( int i = 0; i < nCount; i++ )
panIntList[i]
= CPLAtoGIntBig(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_RealList:
{
int nCount = psGMLProperty->nSubProperties;
double *padfList = (double *)CPLMalloc(sizeof(double)*nCount);
for( int i = 0; i < nCount; i++ )
padfList[i]
= CPLAtof(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, padfList );
CPLFree( padfList );
}
break;
case GMLPT_StringList:
case GMLPT_FeaturePropertyList:
{
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties );
}
break;
case GMLPT_Boolean:
{
if( strcmp(psGMLProperty->papszSubProperties[0], "true") == 0 ||
strcmp(psGMLProperty->papszSubProperties[0], "1") == 0 )
{
poOGRFeature->SetField( iDstField, 1);
}
else if( strcmp(psGMLProperty->papszSubProperties[0], "false") == 0 ||
strcmp(psGMLProperty->papszSubProperties[0], "0") == 0 )
{
poOGRFeature->SetField( iDstField, 0);
}
else
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
case GMLPT_BooleanList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
for( int i = 0; i < nCount; i++ )
{
panIntList[i] = (
strcmp(psGMLProperty->papszSubProperties[i],
"true") == 0 ||
strcmp(psGMLProperty->papszSubProperties[i],
"1") == 0 );
}
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
break;
}
default:
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
}
delete poGMLFeature;
poGMLFeature = NULL;
/* Assign the geometry before the attribute filter because */
/* the attribute filter may use a special field like OGR_GEOMETRY */
if( papoGeometries != NULL )
{
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
poOGRFeature->SetGeomFieldDirectly( i, papoGeometries[i] );
}
CPLFree(papoGeometries);
papoGeometries = NULL;
}
else
poOGRFeature->SetGeometryDirectly( poGeom );
/* Assign SRS */
for( int i=0; i < poFeatureDefn->GetGeomFieldCount(); i++ )
{
poGeom = poOGRFeature->GetGeomFieldRef(i);
if( poGeom != NULL )
{
OGRSpatialReference* poSRS
= poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef();
if (poSRS != NULL)
poGeom->assignSpatialReference(poSRS);
}
}
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poOGRFeature ) )
{
delete poOGRFeature;
continue;
}
/* -------------------------------------------------------------------- */
/* Wow, we got our desired feature. Return it. */
/* -------------------------------------------------------------------- */
return poOGRFeature;
}
return NULL;
}
OGRFeature *OGRGMLLayer::GetNextFeature()
{
GMLFeature *poGMLFeature = NULL;
OGRGeometry *poGeom = NULL;
if (bWriter)
{
CPLError(CE_Failure, CPLE_NotSupported,
"Cannot read features when writing a GML file");
return NULL;
}
if( iNextGMLId == 0 )
ResetReading();
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( TRUE )
{
/* -------------------------------------------------------------------- */
/* Cleanup last feature, and get a new raw gml feature. */
/* -------------------------------------------------------------------- */
if( poGMLFeature != NULL )
delete poGMLFeature;
if( poGeom != NULL )
{
delete poGeom;
poGeom = NULL;
}
poGMLFeature = poDS->GetReader()->NextFeature();
if( poGMLFeature == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Is it of the proper feature class? */
/* -------------------------------------------------------------------- */
// We count reading low level GML features as a feature read for
// work checking purposes, though at least we didn't necessary
// have to turn it into an OGRFeature.
m_nFeaturesRead++;
if( poGMLFeature->GetClass() != poFClass )
continue;
/* -------------------------------------------------------------------- */
/* Extract the fid: */
/* -Assumes the fids are non-negative integers with an optional */
/* prefix */
/* -If a prefix differs from the prefix of the first feature from */
/* the poDS then the fids from the poDS are ignored and are */
/* assigned serially thereafter */
/* -------------------------------------------------------------------- */
int nFID = -1;
const char * pszGML_FID = poGMLFeature->GetFID();
if( bInvalidFIDFound )
{
nFID = iNextGMLId++;
}
else if( pszGML_FID == NULL )
{
bInvalidFIDFound = TRUE;
nFID = iNextGMLId++;
}
else if( iNextGMLId == 0 )
{
int i = strlen( pszGML_FID )-1, j = 0;
while( i >= 0 && pszGML_FID[i] >= '0'
&& pszGML_FID[i] <= '9' && j<8)
i--, j++;
/* i points the last character of the fid */
if( i >= 0 && j < 8 && pszFIDPrefix == NULL)
{
pszFIDPrefix = (char *) CPLMalloc(i+2);
pszFIDPrefix[i+1] = '\0';
strncpy(pszFIDPrefix, pszGML_FID, i+1);
}
/* pszFIDPrefix now contains the prefix or NULL if no prefix is found */
if( j < 8 && sscanf(pszGML_FID+i+1, "%d", &nFID)==1)
{
if( iNextGMLId <= nFID )
iNextGMLId = nFID + 1;
}
else
{
bInvalidFIDFound = TRUE;
nFID = iNextGMLId++;
}
}
else if( iNextGMLId != 0 )
{
const char* pszFIDPrefix_notnull = pszFIDPrefix;
if (pszFIDPrefix_notnull == NULL) pszFIDPrefix_notnull = "";
int nLenPrefix = strlen(pszFIDPrefix_notnull);
if( strncmp(pszGML_FID, pszFIDPrefix_notnull, nLenPrefix) == 0 &&
strlen(pszGML_FID+nLenPrefix) <= 9 &&
sscanf(pszGML_FID+nLenPrefix, "%d", &nFID) == 1 )
{ /* fid with the prefix. Using its numerical part */
if( iNextGMLId < nFID )
iNextGMLId = nFID + 1;
}
else
{ /* fid without the aforementioned prefix or a valid numerical part */
bInvalidFIDFound = TRUE;
nFID = iNextGMLId++;
}
}
/* -------------------------------------------------------------------- */
/* Does it satisfy the spatial query, if there is one? */
/* -------------------------------------------------------------------- */
char** papszGeometryList = poGMLFeature->GetGeometryList();
if( papszGeometryList != NULL )
{
const char* pszSRSName = poDS->GetGlobalSRSName();
poGeom = GML_BuildOGRGeometryFromList(papszGeometryList, TRUE,
m_bInvertAxisOrderIfLatLong, pszSRSName);
if (poGeom != NULL && poSRS != NULL)
poGeom->assignSpatialReference(poSRS);
// We assume the createFromGML() function would have already
// reported the error.
if( poGeom == NULL )
{
delete poGMLFeature;
return NULL;
}
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
continue;
}
/* -------------------------------------------------------------------- */
/* Convert the whole feature into an OGRFeature. */
/* -------------------------------------------------------------------- */
int iField;
int iDstField = 0;
OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() );
poOGRFeature->SetFID( nFID );
if (poDS->ExposeGMLId())
{
if (pszGML_FID)
poOGRFeature->SetField( iDstField, pszGML_FID );
iDstField ++;
}
for( iField = 0; iField < poFClass->GetPropertyCount(); iField++, iDstField ++ )
{
const GMLProperty *psGMLProperty = poGMLFeature->GetProperty( iField );
if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 )
continue;
switch( poFClass->GetProperty(iField)->GetType() )
{
case GMLPT_Real:
{
poOGRFeature->SetField( iDstField, CPLAtof(psGMLProperty->papszSubProperties[0]) );
}
break;
case GMLPT_IntegerList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
int i;
for( i = 0; i < nCount; i++ )
panIntList[i] = atoi(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_RealList:
{
int nCount = psGMLProperty->nSubProperties;
double *padfList = (double *)CPLMalloc(sizeof(double)*nCount);
int i;
for( i = 0; i < nCount; i++ )
padfList[i] = CPLAtof(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iDstField, nCount, padfList );
CPLFree( padfList );
}
break;
case GMLPT_StringList:
{
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties );
}
break;
default:
poOGRFeature->SetField( iDstField, psGMLProperty->papszSubProperties[0] );
break;
}
}
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poOGRFeature ) )
{
delete poOGRFeature;
continue;
}
/* -------------------------------------------------------------------- */
/* Wow, we got our desired feature. Return it. */
/* -------------------------------------------------------------------- */
delete poGMLFeature;
poOGRFeature->SetGeometryDirectly( poGeom );
return poOGRFeature;
}
return NULL;
}
OGRFeature *OGRSOSILayer::GetNextFeature() {
short nName, nNumLines;
long nNumCoo;
unsigned short nInfo;
/* iterate through the SOSI groups*/
while (LC_NextBgr(poNextSerial,LC_FRAMGR)) {
nName = LC_RxGr(&oNextSerial, LES_OPTIMALT, &nNumLines, &nNumCoo, &nInfo);
S2S oHeaders;
S2S::iterator iHeaders;
/* extract reference strings from group header */
CPLString osKey, osValue;
for (short i=1; i<=nNumLines; i++) {
char *pszLine = LC_GetGi(i);
if (pszLine[0] == '!') continue; /* If we have a comment line, skip it. */
if ((pszLine[0] == ':')||(pszLine[0] == '(')) { /* if we have a continued REF line... */
osValue.append(CPLString(pszLine)); /* append to previous line. */
oHeaders.insert(std::pair<CPLString,CPLString>(osKey,osValue));
continue;
}
while (pszLine[0] == '.') pszLine++; /* skipping the dots at the beginning of a SOSI line */
char *pszUTFLine = CPLRecode(pszLine, poParent->pszEncoding, CPL_ENC_UTF8); /* switch to UTF encoding here */
char *pszPos = strstr(pszUTFLine, " ");
if (pszPos != NULL) {
osKey = CPLString(std::string(pszUTFLine,pszPos));
osValue = CPLString(pszPos+1);
oHeaders.insert(std::pair<CPLString,CPLString>(osKey,osValue));
}
CPLFree(pszUTFLine);
}
/* get Feature from fyba, according to feature definition */
OGRGeometry *poGeom = NULL;
OGRwkbGeometryType oGType = wkbUnknown;
switch (nName) {
case INGEN_GRUPPE: { /* No group */
CPLDebug( "[GetNextFeature]", "Could not load further groups - FYBA reported INGEN_GRUPPE.");
break;
}
case L_FLATE: { /* Area */
oGType = wkbPolygon;
OGRLinearRing *poOuter = new OGRLinearRing(); /* Initialize a new closed polygon */
long nRefNr;
unsigned char nRefStatus;
long nRefCount;
bool correct = true;
LC_GRF_STATUS oGrfStat;
// Iterate through all objects that constitute this area.
LC_InitGetRefFlate(&oGrfStat);
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_YTRE, &nRefNr, &nRefStatus, 1);
while (nRefCount > 0) {
if (poParent->papoBuiltGeometries[nRefNr] == NULL) {
// This should not happen under normal operation.
CPLError( CE_Warning, CPLE_AppDefined, "Feature %li referenced by %li, but it was not initialized. Geometry may be broken.", nRefNr, oNextSerial.lNr);
correct = false;
//return NULL;
break;
}
OGRGeometry *geom = poParent->papoBuiltGeometries[nRefNr];
if (geom->getGeometryType() == wkbLineString) {
OGRLineString *poCurve = (OGRLineString*)geom;
if (nRefStatus == LC_MED_DIG) { /* clockwise */
poOuter->addSubLineString(poCurve);
} else if (nRefStatus == LC_MOT_DIG) { /* counter-clockwise */
poOuter->addSubLineString(poCurve,poCurve->getNumPoints()-1,0);
} else {
CPLError( CE_Failure, CPLE_OpenFailed, "Internal error: GRF_*_OY encountered.");
return NULL;
}
} else {
CPLError( CE_Warning, CPLE_AppDefined, "Element %li composed of non-linestrings (REF %li of type %i). Ignored.", oNextSerial.lNr, nRefNr, geom->getGeometryType());
}
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_YTRE, &nRefNr, &nRefStatus, 1);
}
if (correct) {
OGRPolygon *poLy = new OGRPolygon();
poOuter->closeRings();
poLy->addRingDirectly(poOuter);
OGRLinearRing *poInner = 0;
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_INDRE, &nRefNr, &nRefStatus, 1);
while (nRefCount > 0) {
if (nRefNr == -1) {
if (poInner && (poInner->getNumPoints()>2)) { /* If this is not the first polygon, terminate and add the last */
poInner->closeRings();
poLy->addRingDirectly(poInner);
}
poInner = new OGRLinearRing(); /* Initialize a new closed polygon */
} else {
if (poParent->papoBuiltGeometries[nRefNr] == NULL) { /* this shouldn't happen under normal operation */
CPLError( CE_Fatal, CPLE_AppDefined, "Feature %li referenced by %li, but it was not initialized.", nRefNr, oNextSerial.lNr);
return NULL;
}
OGRGeometry *geom = poParent->papoBuiltGeometries[nRefNr];
if (geom->getGeometryType() == wkbLineString) {
OGRLineString *poCurve = (OGRLineString*)geom;
if (nRefStatus == LC_MED_DIG) { /* clockwise */
poInner->addSubLineString(poCurve);
} else if (nRefStatus == LC_MOT_DIG) { /* counter-clockwise */
poInner->addSubLineString(poCurve,poCurve->getNumPoints()-1,0);
} else {
CPLError( CE_Failure, CPLE_OpenFailed, "Internal error: GRF_*_OY encountered.");
return NULL;
}
} else {
CPLError( CE_Warning, CPLE_AppDefined, "Element %li composed of non-linestrings (REF %li of type %i). Ignored.", oNextSerial.lNr, nRefNr, geom->getGeometryType());
}
}
nRefCount = LC_GetRefFlate(&oGrfStat, GRF_INDRE, &nRefNr, &nRefStatus, 1);
}
poGeom = poLy;
}
break;
}
case L_KURVE: /* curve */
case L_LINJE: /* curve, not simplifyable */
case L_BUEP: { /* curve, interpolated from circular arc */
oGType = wkbLineString;
OGRLineString *poCurve = (OGRLineString*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poCurve == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Curve %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poCurve->clone();
break;
}
case L_TEKST: { /* text */
oGType = wkbMultiPoint;
OGRMultiPoint *poMP = (OGRMultiPoint*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poMP == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Tekst %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poMP->clone();
break;
}
case L_SYMBOL: {
//CPLError( CE_Warning, CPLE_OpenFailed, "Geometry of type SYMBOL treated as point (PUNKT).");
}
case L_PUNKT: { /* point */
oGType = wkbPoint;
OGRPoint *poPoint = (OGRPoint*)(poParent->papoBuiltGeometries[oNextSerial.lNr]);
if (poPoint == NULL) {
CPLError( CE_Fatal, CPLE_AppDefined, "Point %li was not initialized.", oNextSerial.lNr);
return NULL;
}
poGeom = poPoint->clone();
break;
}
case L_DEF: /* skip user definitions and headers here */
case L_HODE: {
break;
}
default: { /* complain a bit about anything else that is not implemented */
CPLError( CE_Failure, CPLE_OpenFailed, "Unrecognized geometry of type %i.", nName);
break;
}
}
if (poGeom == NULL) continue; /* skipping L_HODE and unrecognized groups */
if (oGType != poFeatureDefn->GetGeomType()) {
if (poGeom != NULL) delete poGeom;
continue; /* skipping features that are not the correct geometry */
}
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
/* set all headers found in this group - we export everything, just in case */
for (iHeaders = oHeaders.begin(); iHeaders != oHeaders.end(); iHeaders++) {
OGRSOSIDataType *poType = SOSIGetType(iHeaders->first);
OGRSOSISimpleDataType *poElements = poType->getElements();
const char *pszLine = iHeaders->second.c_str();
char** tokens = CSLTokenizeString(iHeaders->second.c_str());
for (int k=0; k<poType->getElementCount(); k++) {
if (tokens[k] == 0) break;
if (strcmp(poElements[k].GetName(),"")==0) continue;
int iHNr = poHeaderDefn->find(poElements[k].GetName())->second;
if (iHNr == -1) {
CPLError( CE_Warning, CPLE_AppDefined, "Could not find field definition for %s.", poElements[k].GetName());
continue;
}
OGRFieldType nType = poElements[k].GetType();
switch (nType) {
case OFTInteger: {
poFeature->SetField( iHNr, SOSITypeToInt(tokens[k]));
break;
}
case OFTDate: {
int date[3];
SOSITypeToDate(tokens[k], date);
poFeature->SetField( iHNr, date[0], date[1], date[2]);
break;
}
case OFTDateTime: {
int date[6];
SOSITypeToDateTime(tokens[k], date);
if (date[0]>0)
poFeature->SetField( iHNr, date[0], date[1], date[2], date[3], date[4], static_cast<float>(date[5]), 1);
break;
}
case OFTReal: {
poFeature->SetField( iHNr, SOSITypeToReal(tokens[k]));
break;
}
default: {
if ((k==0)&&((pszLine[0] == '\'')||(pszLine[0] == '\"'))) { /* If the value is quoted, ignore these */
int nLen = static_cast<int>(strlen(pszLine));
char *pszNline = (char*)CPLMalloc(nLen-1);
strncpy(pszNline, pszLine+1, nLen-2);
pszNline[nLen-2] = '\0';
poFeature->SetField( iHNr, pszNline);
CPLFree(pszNline);
} else {
poFeature->SetField( iHNr, tokens[k]);
}
break;
}
}
}
CSLDestroy(tokens);
}
if( poGeom != NULL )
poGeom->assignSpatialReference(poParent->poSRS);
poFeature->SetGeometryDirectly( poGeom );
poFeature->SetFID( nNextFID++ );
/* Loop until we have a feature that matches the definition */
if ( (m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
return NULL;
}
OGRFeature *OGRNASLayer::GetNextFeature()
{
GMLFeature *poNASFeature = NULL;
OGRGeometry *poGeom = NULL;
if( iNextNASId == 0 )
ResetReading();
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( TRUE )
{
/* -------------------------------------------------------------------- */
/* Cleanup last feature, and get a new raw nas feature. */
/* -------------------------------------------------------------------- */
delete poNASFeature;
delete poGeom;
poNASFeature = NULL;
poGeom = NULL;
poNASFeature = poDS->GetReader()->NextFeature();
if( poNASFeature == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Is it of the proper feature class? */
/* -------------------------------------------------------------------- */
// We count reading low level NAS features as a feature read for
// work checking purposes, though at least we didn't necessary
// have to turn it into an OGRFeature.
m_nFeaturesRead++;
if( poNASFeature->GetClass() != poFClass )
continue;
iNextNASId++;
/* -------------------------------------------------------------------- */
/* Does it satisfy the spatial query, if there is one? */
/* -------------------------------------------------------------------- */
const CPLXMLNode* const * papsGeometry = poNASFeature->GetGeometryList();
if (papsGeometry[0] != NULL)
{
poGeom = (OGRGeometry*) OGR_G_CreateFromGMLTree(papsGeometry[0]);
// We assume the createFromNAS() function would have already
// reported the error.
if( poGeom == NULL )
{
delete poNASFeature;
return NULL;
}
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
continue;
}
/* -------------------------------------------------------------------- */
/* Convert the whole feature into an OGRFeature. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() );
poOGRFeature->SetFID( iNextNASId );
for( iField = 0; iField < poFClass->GetPropertyCount(); iField++ )
{
const GMLProperty *psGMLProperty = poNASFeature->GetProperty( iField );
if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 )
continue;
switch( poFClass->GetProperty(iField)->GetType() )
{
case GMLPT_Real:
{
poOGRFeature->SetField( iField, CPLAtof(psGMLProperty->papszSubProperties[0]) );
}
break;
case GMLPT_IntegerList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
int i;
for( i = 0; i < nCount; i++ )
panIntList[i] = atoi(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_RealList:
{
int nCount = psGMLProperty->nSubProperties;
double *padfList = (double *)CPLMalloc(sizeof(double)*nCount);
int i;
for( i = 0; i < nCount; i++ )
padfList[i] = CPLAtof(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iField, nCount, padfList );
CPLFree( padfList );
}
break;
case GMLPT_StringList:
{
poOGRFeature->SetField( iField, psGMLProperty->papszSubProperties );
}
break;
default:
poOGRFeature->SetField( iField, psGMLProperty->papszSubProperties[0] );
break;
}
}
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poOGRFeature ) )
{
delete poOGRFeature;
continue;
}
/* -------------------------------------------------------------------- */
/* Wow, we got our desired feature. Return it. */
/* -------------------------------------------------------------------- */
delete poNASFeature;
poOGRFeature->SetGeometryDirectly( poGeom );
return poOGRFeature;
}
return NULL;
}
void OGRJMLLayer::endElementCbk(const char *pszName)
{
if (bStopParsing) return;
nWithoutEventCounter = 0;
currentDepth--;
if( nAttributeElementDepth == currentDepth )
{
if( nElementValueLen )
poFeature->SetField(iAttr, pszElementValue);
else if( iAttr >= 0 )
poFeature->SetFieldNull(iAttr);
nAttributeElementDepth = 0;
StopAccumulate();
}
else if( nGeometryElementDepth > 0 && currentDepth > nGeometryElementDepth )
{
AddStringToElementValue("</", 2);
AddStringToElementValue(pszName, static_cast<int>(strlen(pszName)));
AddStringToElementValue(">", 1);
}
else if( nGeometryElementDepth == currentDepth )
{
if( nElementValueLen )
{
OGRGeometry* poGeom = reinterpret_cast<OGRGeometry *>(
OGR_G_CreateFromGML(pszElementValue) );
if( poGeom != nullptr &&
poGeom->getGeometryType() == wkbGeometryCollection &&
poGeom->IsEmpty() )
{
delete poGeom;
}
else
poFeature->SetGeometryDirectly(poGeom);
}
nGeometryElementDepth = 0;
StopAccumulate();
}
else if( nFeatureElementDepth == currentDepth )
{
/* Builds a style string from R_G_B if we don't already have a */
/* style string */
OGRGeometry* poGeom = poFeature->GetGeometryRef();
unsigned int R = 0;
unsigned int G = 0;
unsigned int B = 0;
if( iRGBField >= 0 && poFeature->IsFieldSetAndNotNull(iRGBField) &&
poFeature->GetStyleString() == nullptr && poGeom != nullptr &&
sscanf(poFeature->GetFieldAsString(iRGBField),
"%02X%02X%02X", &R, &G, &B) == 3 )
{
const OGRwkbGeometryType eGeomType
= wkbFlatten(poGeom->getGeometryType());
if( eGeomType == wkbPoint || eGeomType == wkbMultiPoint ||
eGeomType == wkbLineString || eGeomType == wkbMultiLineString )
{
poFeature->SetStyleString(
CPLSPrintf("PEN(c:#%02X%02X%02X)", R, G, B));
}
else if( eGeomType == wkbPolygon || eGeomType == wkbMultiPolygon )
{
poFeature->SetStyleString(
CPLSPrintf("BRUSH(fc:#%02X%02X%02X)", R, G, B));
}
}
poFeature->SetFID(nNextFID++);
if( (m_poFilterGeom == nullptr
|| FilterGeometry( poGeom ) )
&& (m_poAttrQuery == nullptr
|| m_poAttrQuery->Evaluate( poFeature )) )
{
ppoFeatureTab = static_cast<OGRFeature**>(
CPLRealloc(ppoFeatureTab,
sizeof(OGRFeature*) * (nFeatureTabLength + 1)) );
ppoFeatureTab[nFeatureTabLength] = poFeature;
nFeatureTabLength++;
}
else
{
delete poFeature;
}
poFeature = nullptr;
iAttr = -1;
nFeatureElementDepth = 0;
}
else if( nFeatureCollectionDepth == currentDepth )
{
nFeatureCollectionDepth = 0;
}
}