OGRErr GMLHandler::endElementAttribute()
{
GMLReadState *poState = m_poReader->GetState();
if (m_bInCurField)
{
if (m_pszCurField == NULL)
{
if (m_pszValue != NULL)
{
m_poReader->SetFeaturePropertyDirectly( poState->osPath.c_str(),
m_pszValue, -1 );
m_pszValue = NULL;
}
}
else
{
m_poReader->SetFeaturePropertyDirectly( poState->osPath.c_str(),
m_pszCurField,
m_nAttributeIndex );
m_pszCurField = NULL;
}
if (m_pszHref != NULL)
{
CPLString osPropNameHref = poState->osPath + "_href";
m_poReader->SetFeaturePropertyDirectly( osPropNameHref, m_pszHref, -1 );
m_pszHref = NULL;
}
if (m_pszUom != NULL)
{
CPLString osPropNameUom = poState->osPath + "_uom";
m_poReader->SetFeaturePropertyDirectly( osPropNameUom, m_pszUom, -1 );
m_pszUom = NULL;
}
m_nCurFieldLen = m_nCurFieldAlloc = 0;
m_bInCurField = FALSE;
m_nAttributeIndex = -1;
CPLFree( m_pszValue );
m_pszValue = NULL;
}
poState->PopPath();
if( m_nAttributeDepth == m_nDepth )
{
POP_STATE();
}
return OGRERR_NONE;
}
void NASHandler::endElement( const XMLCh* const /* uri */ ,
const XMLCh* const localname,
const XMLCh* const /* qname */)
{
char szElementName[MAX_TOKEN_SIZE];
GMLReadState *poState = m_poReader->GetState();
tr_strcpy( szElementName, localname );
m_nDepth --;
if (m_bIgnoreFeature && m_nDepth >= m_nDepthFeature)
{
if (m_nDepth == m_nDepthFeature)
{
m_bIgnoreFeature = false;
m_nDepthFeature = 0;
}
return;
}
if ( m_osIgnoredElement != "" && m_nDepth >= m_nDepthElement )
{
if ( m_nDepth == m_nDepthElement )
{
m_osIgnoredElement = "";
m_nDepthElement = 0;
}
return;
}
#ifdef DEBUG_VERBOSE
CPLDebug("NAS",
"%*sendElement %s m_bIgnoreFeature:%d depth:%d depthFeature:%d featureClass:%s",
m_nDepth, "", szElementName,
m_bIgnoreFeature, m_nDepth, m_nDepthFeature,
poState->m_poFeature ? poState->m_poFeature->GetClass()->GetElementName() : "(no feature)"
);
#endif
if( m_bInUpdateProperty )
{
if( EQUAL( szElementName, "Name" ) )
{
CPLAssert( m_osLastPropertyName == "" );
m_osLastPropertyName = m_pszCurField;
m_pszCurField = NULL;
}
else if( EQUAL( szElementName, "Value" ) )
{
CPLAssert( m_osLastPropertyValue == "" );
m_osLastPropertyValue = m_pszCurField;
m_pszCurField = NULL;
}
else if( EQUAL( szElementName, "Property" ) )
{
if( EQUAL( m_osLastPropertyName, "adv:lebenszeitintervall/adv:AA_Lebenszeitintervall/adv:endet" ) )
{
CPLAssert( m_osLastPropertyValue != "" );
m_osLastEnded = m_osLastPropertyValue;
}
else if( EQUAL( m_osLastPropertyName, "adv:anlass" ) )
{
CPLAssert( m_osLastPropertyValue != "" );
m_osLastOccasion = m_osLastPropertyValue;
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"NAS: Expected property name or value instead of %s",
m_osLastPropertyName.c_str() );
}
m_osLastPropertyName = "";
m_osLastPropertyValue = "";
m_bInUpdateProperty = false;
}
poState->PopPath();
return;
}
if ( m_bInUpdate && EQUAL( szElementName, "Update" ) )
{
m_bInUpdate = false;
}
/* -------------------------------------------------------------------- */
/* Is this closing off an attribute value? We assume so if */
/* we are collecting an attribute value and got to this point. */
/* We don't bother validating that the closing tag matches the */
/* opening tag. */
/* -------------------------------------------------------------------- */
if( m_pszCurField != NULL )
{
CPLAssert( poState->m_poFeature != NULL );
m_poReader->SetFeaturePropertyDirectly( poState->osPath.c_str(), m_pszCurField );
m_pszCurField = NULL;
}
/* -------------------------------------------------------------------- */
/* If we are collecting Geometry than store it, and consider if */
/* this is the end of the geometry. */
/* -------------------------------------------------------------------- */
if( m_pszGeometry != NULL )
{
int nLNLen = tr_strlen( localname );
/* should save attributes too! */
if( m_nGeomLen + nLNLen + 4 > m_nGeomAlloc )
{
m_nGeomAlloc = (int) (m_nGeomAlloc * 1.3 + nLNLen + 1000);
m_pszGeometry = (char *)
CPLRealloc( m_pszGeometry, m_nGeomAlloc);
}
strcat( m_pszGeometry+m_nGeomLen, "</" );
tr_strcpy( m_pszGeometry+m_nGeomLen+2, localname );
strcat( m_pszGeometry+m_nGeomLen+nLNLen+2, ">" );
m_nGeomLen += static_cast<int>(strlen(m_pszGeometry+m_nGeomLen));
if( poState->m_nPathLength == m_nGeometryDepth+1 )
{
if( poState->m_poFeature != NULL )
{
CPLXMLNode* psNode = CPLParseXMLString(m_pszGeometry);
if (psNode)
{
/* workaround for common malformed gml:pos with just a
* elevation value instead of a full 3D coordinate:
*
* <gml:Point gml:id="BII2H">
* <gml:pos srsName="urn:adv:crs:ETRS89_h">41.394</gml:pos>
* </gml:Point>
*
*/
const char *pszPos;
if( (pszPos = CPLGetXMLValue( psNode, "=Point.pos", NULL ) ) != NULL
&& strstr(pszPos, " ") == NULL )
{
CPLSetXMLValue( psNode, "pos", CPLSPrintf("0 0 %s", pszPos) );
}
if ( poState->m_poFeature->GetGeometryList() &&
poState->m_poFeature->GetGeometryList()[0] )
{
int iId = poState->m_poFeature->GetClass()->GetPropertyIndex( "gml_id" );
const GMLProperty *poIdProp = poState->m_poFeature->GetProperty(iId);
#ifdef DEBUG_VERBOSE
char *pszOldGeom = CPLSerializeXMLTree( poState->m_poFeature->GetGeometryList()[0] );
CPLDebug("NAS", "Overwriting other geometry (%s; replace:%s; with:%s)",
poIdProp && poIdProp->nSubProperties>0 && poIdProp->papszSubProperties[0] ? poIdProp->papszSubProperties[0] : "(null)",
m_pszGeometry,
pszOldGeom
);
CPLFree( pszOldGeom );
#else
CPLError( CE_Warning, CPLE_AppDefined, "NAS: Overwriting other geometry (%s)",
poIdProp && poIdProp->nSubProperties>0 && poIdProp->papszSubProperties[0] ? poIdProp->papszSubProperties[0] : "(null)" );
#endif
}
poState->m_poFeature->SetGeometryDirectly( psNode );
}
else
CPLError( CE_Warning, CPLE_AppDefined, "NAS: Invalid geometry skipped" );
}
else
CPLError( CE_Warning, CPLE_AppDefined, "NAS: Skipping geometry without feature" );
CPLFree( m_pszGeometry );
m_pszGeometry = NULL;
m_nGeomAlloc = m_nGeomLen = 0;
}
}
/* -------------------------------------------------------------------- */
/* If we are collecting a feature, and this element tag matches */
/* element name for the class, then we have finished the */
/* feature, and we pop the feature read state. */
/* -------------------------------------------------------------------- */
const char *pszLast = NULL;
if( m_nDepth == m_nDepthFeature && poState->m_poFeature != NULL
&& EQUAL(szElementName,
poState->m_poFeature->GetClass()->GetElementName()) )
{
m_nDepthFeature = 0;
m_poReader->PopState();
}
/* -------------------------------------------------------------------- */
/* Ends of a wfs:Delete or wfs:Update should be triggered on the */
/* close of the <Filter> element. */
/* -------------------------------------------------------------------- */
else if( m_nDepth == m_nDepthFeature
&& poState->m_poFeature != NULL
&& EQUAL(szElementName,"Filter")
&& (pszLast=poState->m_poFeature->GetClass()->GetElementName())
!= NULL
&& ( EQUAL(pszLast, "Delete") || EQUAL(pszLast, "Update") ) )
{
m_nDepthFeature = 0;
m_poReader->PopState();
}
/* -------------------------------------------------------------------- */
/* Otherwise, we just pop the element off the local read states */
/* element stack. */
/* -------------------------------------------------------------------- */
else
{
if( EQUAL(szElementName,poState->GetLastComponent()) )
poState->PopPath();
else
{
CPLAssert( false );
}
}
}
void NASHandler::startElement( const XMLCh* const /* uri */,
const XMLCh* const localname,
const XMLCh* const /* qname */,
const Attributes& attrs )
{
char szElementName[MAX_TOKEN_SIZE];
GMLReadState *poState = m_poReader->GetState();
tr_strcpy( szElementName, localname );
if ( ( m_bIgnoreFeature && m_nDepth >= m_nDepthFeature ) ||
( m_osIgnoredElement != "" && m_nDepth >= m_nDepthElement ) )
{
m_nDepth ++;
return;
}
// ignore attributes of external references and "objektkoordinaten"
// (see PostNAS #3 and #15)
if ( EQUAL( szElementName, "zeigtAufExternes" ) ||
EQUAL( szElementName, "objektkoordinaten" ) )
{
m_osIgnoredElement = szElementName;
m_nDepthElement = m_nDepth;
m_nDepth ++;
return;
}
#ifdef DEBUG_VERBOSE
CPLDebug( "NAS",
"%*sstartElement %s m_bIgnoreFeature:%d depth:%d "
"depthFeature:%d featureClass:%s",
m_nDepth, "", szElementName,
m_bIgnoreFeature, m_nDepth, m_nDepthFeature,
poState->m_poFeature ? poState->m_poFeature->
GetClass()->GetElementName() : "(no feature)"
);
#endif
/* -------------------------------------------------------------------- */
/* If we are in the midst of collecting a feature attribute */
/* value, then this must be a complex attribute which we don't */
/* try to collect for now, so just terminate the field */
/* collection. */
/* -------------------------------------------------------------------- */
if( m_pszCurField != NULL )
{
CPLFree( m_pszCurField );
m_pszCurField = NULL;
}
/* -------------------------------------------------------------------- */
/* If we are collecting geometry, or if we determine this is a */
/* geometry element then append to the geometry info. */
/* -------------------------------------------------------------------- */
const char *pszLast = NULL;
if( m_pszGeometry != NULL
|| IsGeometryElement( szElementName ) )
{
const int nLNLen = tr_strlen( localname );
CPLString osAttributes = GetAttributes( &attrs );
/* should save attributes too! */
if( m_pszGeometry == NULL )
m_nGeometryDepth = poState->m_nPathLength;
if( m_pszGeometry == NULL ||
m_nGeomLen + nLNLen + 4 + (int)osAttributes.size() > m_nGeomAlloc )
{
m_nGeomAlloc = (int) (m_nGeomAlloc * 1.3 + nLNLen + osAttributes.size() + 1000);
m_pszGeometry = (char *)
CPLRealloc( m_pszGeometry, m_nGeomAlloc);
}
strcpy( m_pszGeometry+m_nGeomLen, "<" );
tr_strcpy( m_pszGeometry+m_nGeomLen+1, localname );
if( osAttributes.size() > 0 )
{
strcat( m_pszGeometry+m_nGeomLen, " " );
strcat( m_pszGeometry+m_nGeomLen, osAttributes );
}
strcat( m_pszGeometry+m_nGeomLen, ">" );
m_nGeomLen += static_cast<int>(strlen(m_pszGeometry+m_nGeomLen));
}
/* -------------------------------------------------------------------- */
/* Is this the ogc:Filter element in a update operation */
/* (wfs:Delete, wfsext:Replace or wfs:Update)? */
/* specialized sort of feature. */
/* -------------------------------------------------------------------- */
else if( EQUAL(szElementName,"Filter")
&& (pszLast = m_poReader->GetState()->GetLastComponent()) != NULL
&& (EQUAL(pszLast,"Delete") || EQUAL(pszLast,"Replace") ||
EQUAL(pszLast,"Update")) )
{
const char* pszFilteredClassName = m_poReader->GetFilteredClassName();
if ( pszFilteredClassName != NULL &&
strcmp("Delete", pszFilteredClassName) != 0 )
{
m_bIgnoreFeature = true;
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return;
}
if( m_osLastTypeName == "" )
{
CPLError( CE_Failure, CPLE_AssertionFailed,
"m_osLastTypeName == \"\"");
m_bIgnoreFeature = true;
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return;
}
if( EQUAL( pszLast, "Replace" ) &&
( m_osLastReplacingFID == "" || m_osLastSafeToIgnore == "" ) )
{
CPLError( CE_Failure, CPLE_AssertionFailed,
"m_osLastReplacingFID == \"\" || "
"m_osLastSafeToIgnore == \"\"" );
m_bIgnoreFeature = true;
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return;
}
if( EQUAL( pszLast, "Update" ) &&
( m_osLastEnded == "" || m_osLastOccasion == "" ) )
{
CPLError( CE_Failure, CPLE_AssertionFailed,
"m_osLastEnded == \"\" || m_osLastOccasion == \"\"" );
m_bIgnoreFeature = true;
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return;
}
m_bIgnoreFeature = false;
m_poReader->PushFeature( "Delete", attrs );
m_nDepthFeature = m_nDepth;
m_nDepth ++;
m_poReader->SetFeaturePropertyDirectly(
"typeName", CPLStrdup(m_osLastTypeName) );
m_poReader->SetFeaturePropertyDirectly( "context", CPLStrdup(pszLast) );
if( EQUAL( pszLast, "Replace" ) )
{
//CPLAssert( m_osLastReplacingFID != "" );
//CPLAssert( m_osLastSafeToIgnore != "" );
m_poReader->SetFeaturePropertyDirectly(
"replacedBy", CPLStrdup(m_osLastReplacingFID) );
m_poReader->SetFeaturePropertyDirectly(
"safeToIgnore", CPLStrdup(m_osLastSafeToIgnore) );
}
else if( EQUAL( pszLast, "Update" ) )
{
//CPLAssert( m_osLastEnded != "" );
//CPLAssert( m_osLastOccasion != "" );
m_poReader->SetFeaturePropertyDirectly(
"endet", CPLStrdup(m_osLastEnded) );
m_poReader->SetFeaturePropertyDirectly(
"anlass", CPLStrdup(m_osLastOccasion) );
m_osLastEnded = "";
m_osLastOccasion = "";
}
return;
}
/* -------------------------------------------------------------------- */
/* Is it a feature? If so push a whole new state, and return. */
/* -------------------------------------------------------------------- */
else if( m_poReader->IsFeatureElement( szElementName ) )
{
m_osLastTypeName = szElementName;
const char* pszFilteredClassName = m_poReader->GetFilteredClassName();
pszLast = m_poReader->GetState()->GetLastComponent();
if( pszLast != NULL && EQUAL(pszLast,"Replace") )
{
XMLCh Name[100];
tr_strcpy( Name, "gml:id" );
int nIndex = attrs.getIndex( Name );
if( nIndex == -1 || m_osLastReplacingFID !="" )
{
CPLError( CE_Failure, CPLE_AssertionFailed,
"nIndex == -1 || m_osLastReplacingFID !=\"\"" );
m_bIgnoreFeature = true;
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return;
}
// Capture "gml:id" attribute as part of the property value -
// primarily this is for the wfsext:Replace operation's attribute.
char *pszReplacingFID = tr_strdup( attrs.getValue( nIndex ) );
m_osLastReplacingFID = pszReplacingFID;
CPLFree( pszReplacingFID );
#ifdef DEBUG_VERBOSE
CPLDebug( "NAS", "%*s### Replace typeName=%s replacedBy=%s",
m_nDepth, "", m_osLastTypeName.c_str(),
m_osLastReplacingFID.c_str() );
#endif
}
if ( pszFilteredClassName != NULL &&
strcmp(szElementName, pszFilteredClassName) != 0 )
{
m_bIgnoreFeature = true;
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return;
}
m_bIgnoreFeature = false;
m_poReader->PushFeature( szElementName, attrs );
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return;
}
/* -------------------------------------------------------------------- */
/* If it is the wfs:Delete or wfs:Update element, then remember */
/* the typeName attribute so we can assign it to the feature that */
/* will be produced when we process the Filter element. */
/* -------------------------------------------------------------------- */
else if( EQUAL(szElementName,"Delete") || EQUAL(szElementName,"Update") )
{
XMLCh Name[100];
tr_strcpy( Name, "typeName" );
int nIndex = attrs.getIndex( Name );
if( nIndex != -1 )
{
char *pszTypeName = tr_strdup( attrs.getValue( nIndex ) );
m_osLastTypeName = pszTypeName;
CPLFree( pszTypeName );
}
m_osLastSafeToIgnore = "";
m_osLastReplacingFID = "";
if( EQUAL(szElementName,"Update") )
{
m_bInUpdate = true;
}
}
else if ( m_bInUpdate && EQUAL(szElementName, "Property") )
{
m_bInUpdateProperty = true;
}
else if ( m_bInUpdateProperty && ( EQUAL(szElementName, "Name" ) ||
EQUAL(szElementName, "Value" ) ) )
{
// collect attribute name or value
CPLFree( m_pszCurField );
m_pszCurField = CPLStrdup("");
}
/* -------------------------------------------------------------------- */
/* If it is the wfsext:Replace element, then remember the */
/* safeToIgnore attribute so we can assign it to the feature */
/* that will be produced when we process the Filter element. */
/* -------------------------------------------------------------------- */
else if( EQUAL(szElementName,"Replace") )
{
XMLCh Name[100];
tr_strcpy( Name, "safeToIgnore" );
int nIndex = attrs.getIndex( Name );
if( nIndex != -1 )
{
char *pszSafeToIgnore = tr_strdup( attrs.getValue( nIndex ) );
m_osLastSafeToIgnore = pszSafeToIgnore;
CPLFree( pszSafeToIgnore );
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"NAS: safeToIgnore attribute missing" );
m_osLastSafeToIgnore = "false";
}
m_osLastReplacingFID = "";
}
/* -------------------------------------------------------------------- */
/* If it is (or at least potentially is) a simple attribute, */
/* then start collecting it. */
/* -------------------------------------------------------------------- */
else if( m_poReader->IsAttributeElement( szElementName ) )
{
CPLFree( m_pszCurField );
m_pszCurField = CPLStrdup("");
// Capture href as OB property.
m_poReader->CheckForRelations( szElementName, attrs, &m_pszCurField );
// Capture "fid" attribute as part of the property value -
// primarily this is for wfs:Delete operation's FeatureId attribute.
if( EQUAL(szElementName,"FeatureId") )
m_poReader->CheckForFID( attrs, &m_pszCurField );
}
/* -------------------------------------------------------------------- */
/* Push the element onto the current state's path. */
/* -------------------------------------------------------------------- */
poState->PushPath( szElementName );
m_nDepth ++;
}
OGRErr GMLHandler::endElement(const char* pszName )
{
m_nDepth --;
if (m_bIgnoreFeature && m_nDepth >= m_nDepthFeature)
{
if (m_nDepth == m_nDepthFeature)
{
m_bIgnoreFeature = FALSE;
m_nDepthFeature = 0;
}
return CE_None;
}
GMLReadState *poState = m_poReader->GetState();
if( m_bInBoundedBy && strcmp(pszName, "boundedBy") == 0 &&
m_inBoundedByDepth == m_nDepth)
{
m_bInBoundedBy = FALSE;
}
else if( m_bInCityGMLGenericAttr )
{
if( m_pszCityGMLGenericAttrName != NULL && m_pszCurField != NULL )
{
CPLAssert( poState->m_poFeature != NULL );
m_poReader->SetFeatureProperty( m_pszCityGMLGenericAttrName, m_pszCurField );
CPLFree( m_pszCurField );
m_pszCurField = NULL;
CPLFree(m_pszCityGMLGenericAttrName);
m_pszCityGMLGenericAttrName = NULL;
}
if( m_inCityGMLGenericAttrDepth == m_nDepth )
{
m_bInCityGMLGenericAttr = FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Is this closing off an attribute value? We assume so if */
/* we are collecting an attribute value and got to this point. */
/* We don't bother validating that the closing tag matches the */
/* opening tag. */
/* -------------------------------------------------------------------- */
else if( m_pszCurField != NULL )
{
CPLAssert( poState->m_poFeature != NULL );
if ( m_pszHref != NULL && (m_pszCurField == NULL || EQUAL(m_pszCurField, "")))
{
CPLString osPropNameHref = CPLSPrintf("%s_href", poState->m_pszPath);
m_poReader->SetFeatureProperty( osPropNameHref, m_pszHref );
}
else
{
if (EQUAL(m_pszCurField, "") && m_pszValue != NULL)
m_poReader->SetFeatureProperty( poState->m_pszPath, m_pszValue );
else
m_poReader->SetFeatureProperty( poState->m_pszPath, m_pszCurField );
if (m_pszHref != NULL)
{
CPLString osPropNameHref = CPLSPrintf("%s_href", poState->m_pszPath);
m_poReader->SetFeatureProperty( osPropNameHref, m_pszHref );
}
}
if (m_pszUom != NULL)
{
CPLString osPropNameUom = CPLSPrintf("%s_uom", poState->m_pszPath);
m_poReader->SetFeatureProperty( osPropNameUom, m_pszUom );
}
CPLFree( m_pszCurField );
m_pszCurField = NULL;
CPLFree( m_pszHref );
m_pszHref = NULL;
CPLFree( m_pszUom );
m_pszUom = NULL;
CPLFree( m_pszValue );
m_pszValue = NULL;
}
/* -------------------------------------------------------------------- */
/* If we are collecting Geometry than store it, and consider if */
/* this is the end of the geometry. */
/* -------------------------------------------------------------------- */
if( m_pszGeometry != NULL )
{
/* should save attributes too! */
size_t nLNLenBytes = strlen(pszName);
if( m_nGeomLen + nLNLenBytes + 4 > m_nGeomAlloc )
{
m_nGeomAlloc = (size_t) (m_nGeomAlloc * 1.3 + nLNLenBytes + 1000);
char* pszNewGeometry = (char *)
VSIRealloc( m_pszGeometry, m_nGeomAlloc);
if (pszNewGeometry == NULL)
{
return CE_Failure;
}
m_pszGeometry = pszNewGeometry;
}
strcat( m_pszGeometry+m_nGeomLen, "</" );
strcpy( m_pszGeometry+m_nGeomLen+2, pszName );
strcat( m_pszGeometry+m_nGeomLen+nLNLenBytes+2, ">" );
m_nGeomLen += nLNLenBytes + 3;
if( m_nDepth == m_nGeometryDepth )
{
if( poState->m_poFeature != NULL )
{
/* AIXM ElevatedPoint. We want to parse this */
/* a bit specially because ElevatedPoint is aixm: stuff and */
/* the srsDimension of the <gml:pos> can be set to TRUE although */
/* they are only 2 coordinates in practice */
if ( m_bIsAIXM && strcmp(pszName, "ElevatedPoint") == 0 )
{
CPLXMLNode *psGML = CPLParseXMLString( m_pszGeometry );
if (psGML)
{
const char* pszElevation =
CPLGetXMLValue( psGML, "elevation", NULL );
if (pszElevation)
{
m_poReader->SetFeatureProperty( "elevation",
pszElevation );
const char* pszElevationUnit =
CPLGetXMLValue( psGML, "elevation.uom", NULL );
if (pszElevationUnit)
{
m_poReader->SetFeatureProperty( "elevation_uom",
pszElevationUnit );
}
}
const char* pszGeoidUndulation =
CPLGetXMLValue( psGML, "geoidUndulation", NULL );
if (pszGeoidUndulation)
{
m_poReader->SetFeatureProperty( "geoidUndulation",
pszGeoidUndulation );
const char* pszGeoidUndulationUnit =
CPLGetXMLValue( psGML, "geoidUndulation.uom", NULL );
if (pszGeoidUndulationUnit)
{
m_poReader->SetFeatureProperty( "geoidUndulation_uom",
pszGeoidUndulationUnit );
}
}
const char* pszPos =
CPLGetXMLValue( psGML, "pos", NULL );
const char* pszCoordinates =
CPLGetXMLValue( psGML, "coordinates", NULL );
if (pszPos != NULL)
{
char* pszNewGeometry = CPLStrdup(CPLSPrintf(
"<gml:Point><gml:pos>%s</gml:pos></gml:Point>",
pszPos));
CPLFree(m_pszGeometry);
m_pszGeometry = pszNewGeometry;
}
else if (pszCoordinates != NULL)
{
char* pszNewGeometry = CPLStrdup(CPLSPrintf(
"<gml:Point><gml:coordinates>%s</gml:coordinates></gml:Point>",
pszCoordinates));
CPLFree(m_pszGeometry);
m_pszGeometry = pszNewGeometry;
}
else
{
CPLFree(m_pszGeometry);
m_pszGeometry = NULL;
}
CPLDestroyXMLNode( psGML );
}
else
{
CPLFree(m_pszGeometry);
m_pszGeometry = NULL;
}
}
if (m_pszGeometry)
{
if (m_poReader->FetchAllGeometries())
poState->m_poFeature->AddGeometry( m_pszGeometry );
else
poState->m_poFeature->SetGeometryDirectly( m_pszGeometry );
}
}
else
CPLFree( m_pszGeometry );
m_pszGeometry = NULL;
m_nGeomAlloc = m_nGeomLen = 0;
}
}
if ( m_nGeometryDepth != 0 && m_nDepth == m_nGeometryDepth )
m_nGeometryDepth = 0;
/* -------------------------------------------------------------------- */
/* If we are collecting a feature, and this element tag matches */
/* element name for the class, then we have finished the */
/* feature, and we pop the feature read state. */
/* -------------------------------------------------------------------- */
if( m_nDepth == m_nDepthFeature && poState->m_poFeature != NULL
&& strcmp(pszName,
poState->m_poFeature->GetClass()->GetElementName()) == 0 )
{
m_nDepthFeature = 0;
m_poReader->PopState();
}
/* -------------------------------------------------------------------- */
/* Otherwise, we just pop the element off the local read states */
/* element stack. */
/* -------------------------------------------------------------------- */
else
{
if( strcmp(pszName,poState->GetLastComponent()) == 0 )
poState->PopPath();
else
{
CPLAssert( FALSE );
}
}
return CE_None;
}
OGRErr GMLHandler::startElement(const char *pszName, void* attr )
{
GMLReadState *poState = m_poReader->GetState();
if (m_bIgnoreFeature && m_nDepth >= m_nDepthFeature)
{
m_nDepth ++;
return CE_None;
}
if ( m_nDepth == 0 )
{
if (strcmp(pszName, "CityModel") == 0 )
{
m_bIsCityGML = TRUE;
}
else if (strcmp(pszName, "AIXMBasicMessage") == 0)
{
m_bIsAIXM = m_bReportHref = TRUE;
}
}
else if ( m_nDepth == 2 && m_bInBoundedBy )
{
if ( strcmp(pszName, "Envelope") == 0 )
{
char* pszGlobalSRSName = GetAttributeValue(attr, "srsName");
if (pszGlobalSRSName != NULL &&
strncmp(pszGlobalSRSName, "EPSG:", 5) == 0 &&
CSLTestBoolean(CPLGetConfigOption("GML_CONSIDER_EPSG_AS_URN", "NO")))
{
char* pszNew = CPLStrdup(CPLSPrintf("urn:ogc:def:crs:EPSG::%s", pszGlobalSRSName+5));
CPLFree(pszGlobalSRSName);
pszGlobalSRSName = pszNew;
}
m_poReader->SetGlobalSRSName(pszGlobalSRSName);
CPLFree(pszGlobalSRSName);
}
}
/* -------------------------------------------------------------------- */
/* If we are in the midst of collecting a feature attribute */
/* value, then this must be a complex attribute which we don't */
/* try to collect for now, so just terminate the field */
/* collection. */
/* -------------------------------------------------------------------- */
if( m_pszCurField != NULL )
{
CPLFree( m_pszCurField );
m_pszCurField = NULL;
}
if ( m_bInCityGMLGenericAttr )
{
if( strcmp(pszName, "value") == 0 )
{
CPLFree( m_pszCurField );
m_pszCurField = CPLStrdup("");
}
}
/* -------------------------------------------------------------------- */
/* If we are collecting geometry, or if we determine this is a */
/* geometry element then append to the geometry info. */
/* -------------------------------------------------------------------- */
else if( poState->m_poFeature != NULL &&
(m_pszGeometry != NULL
|| IsGeometryElement( pszName )
|| (m_bIsAIXM && strcmp( pszName, "ElevatedPoint") == 0)) )
{
int bReadGeometry;
if( m_pszGeometry == NULL )
{
/* If the <GeometryElementPath> is defined in the .gfs, use it */
/* to read the appropriate geometry element */
const char* pszGeometryElement = (poState->m_poFeature) ?
poState->m_poFeature->GetClass()->GetGeometryElement() : NULL;
if (pszGeometryElement != NULL)
bReadGeometry = strcmp(poState->m_pszPath, pszGeometryElement) == 0;
else
{
/* AIXM special case: for RouteSegment, we only want to read Curve geometries */
/* not 'start' and 'end' geometries */
if (m_bIsAIXM &&
strcmp(poState->m_poFeature->GetClass()->GetName(), "RouteSegment") == 0)
bReadGeometry = strcmp( pszName, "Curve") == 0;
else
bReadGeometry = TRUE;
}
CPLAssert(m_nGeometryDepth == 0);
m_nGeometryDepth = m_nDepth;
}
else
bReadGeometry = TRUE;
if (bReadGeometry)
{
char* pszAttributes = GetAttributes(attr);
size_t nLNLenBytes = strlen(pszName);
/* Some CityGML lack a srsDimension="3" in posList, such as in */
/* http://www.citygml.org/fileadmin/count.php?f=fileadmin%2Fcitygml%2Fdocs%2FFrankfurt_Street_Setting_LOD3.zip */
/* So we have to add it manually */
if (m_bIsCityGML && strcmp(pszName, "posList") == 0 &&
strstr(pszAttributes, "srsDimension") == NULL)
{
CPLFree(pszAttributes);
pszAttributes = CPLStrdup(" srsDimension=\"3\"");
}
if( m_nGeomLen + nLNLenBytes + 4 + strlen( pszAttributes ) >
m_nGeomAlloc )
{
m_nGeomAlloc = (size_t) (m_nGeomAlloc * 1.3 + nLNLenBytes + 1000 +
strlen( pszAttributes ));
char* pszNewGeometry = (char *)
VSIRealloc( m_pszGeometry, m_nGeomAlloc);
if (pszNewGeometry == NULL)
{
CPLFree(pszAttributes);
return CE_Failure;
}
m_pszGeometry = pszNewGeometry;
}
strcpy( m_pszGeometry+m_nGeomLen++, "<" );
strcpy( m_pszGeometry+m_nGeomLen, pszName );
m_nGeomLen += nLNLenBytes;
/* saving attributes */
strcat( m_pszGeometry + m_nGeomLen, pszAttributes );
m_nGeomLen += strlen( pszAttributes );
CPLFree(pszAttributes);
strcat( m_pszGeometry + (m_nGeomLen++), ">" );
}
}
else if (m_nGeometryDepth != 0 && m_nDepth > m_nGeometryDepth)
{
;
}
else if( m_bInBoundedBy)
{
;
}
/* -------------------------------------------------------------------- */
/* Is it a feature? If so push a whole new state, and return. */
/* -------------------------------------------------------------------- */
else if( m_nDepthFeature == 0 &&
m_poReader->IsFeatureElement( pszName ) )
{
const char* pszFilteredClassName = m_poReader->GetFilteredClassName();
if ( pszFilteredClassName != NULL &&
strcmp(pszName, pszFilteredClassName) != 0 )
{
m_bIgnoreFeature = TRUE;
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return CE_None;
}
m_bIgnoreFeature = FALSE;
char* pszFID = GetFID(attr);
m_poReader->PushFeature( pszName, pszFID);
CPLFree(pszFID);
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return CE_None;
}
else if( strcmp(pszName, "boundedBy") == 0 )
{
m_bInBoundedBy = TRUE;
m_inBoundedByDepth = m_nDepth;
}
/* -------------------------------------------------------------------- */
/* Is it a CityGML generic attribute ? */
/* -------------------------------------------------------------------- */
else if( m_poReader->IsCityGMLGenericAttributeElement( pszName, attr ) )
{
m_bInCityGMLGenericAttr = TRUE;
CPLFree(m_pszCityGMLGenericAttrName);
m_pszCityGMLGenericAttrName = GetAttributeValue(attr, "name");
m_inCityGMLGenericAttrDepth = m_nDepth;
}
/* -------------------------------------------------------------------- */
/* If it is (or at least potentially is) a simple attribute, */
/* then start collecting it. */
/* -------------------------------------------------------------------- */
else if( m_poReader->IsAttributeElement( pszName ) )
{
CPLFree( m_pszCurField );
m_pszCurField = CPLStrdup("");
if (m_bReportHref)
{
CPLFree(m_pszHref);
m_pszHref = GetAttributeValue(attr, "xlink:href");
}
CPLFree(m_pszUom);
m_pszUom = GetAttributeValue(attr, "uom");
CPLFree(m_pszValue);
m_pszValue = GetAttributeValue(attr, "value");
}
else if( m_bReportHref && m_poReader->IsAttributeElement( CPLSPrintf("%s_href", pszName ) ) )
{
CPLFree( m_pszCurField );
m_pszCurField = CPLStrdup("");
CPLFree(m_pszHref);
m_pszHref = GetAttributeValue(attr, "xlink:href");
}
/* -------------------------------------------------------------------- */
/* Push the element onto the current state's path. */
/* -------------------------------------------------------------------- */
poState->PushPath( pszName );
m_nDepth ++;
return CE_None;
}
OGRErr GMLHandler::endElement(const char* pszName )
{
m_nDepth --;
GMLReadState *poState = m_poReader->GetState();
int nLNLenBytes = strlen(pszName);
/* -------------------------------------------------------------------- */
/* Is this closing off an attribute value? We assume so if */
/* we are collecting an attribute value and got to this point. */
/* We don't bother validating that the closing tag matches the */
/* opening tag. */
/* -------------------------------------------------------------------- */
if( m_pszCurField != NULL )
{
CPLAssert( poState->m_poFeature != NULL );
m_poReader->SetFeatureProperty( pszName, m_pszCurField );
CPLFree( m_pszCurField );
m_pszCurField = NULL;
}
/* -------------------------------------------------------------------- */
/* If we are collecting Geometry than store it, and consider if */
/* this is the end of the geometry. */
/* -------------------------------------------------------------------- */
if( m_pszGeometry != NULL )
{
/* should save attributes too! */
if( m_nGeomLen + nLNLenBytes + 4 > m_nGeomAlloc )
{
m_nGeomAlloc = (int) (m_nGeomAlloc * 1.3 + nLNLenBytes + 1000);
char* pszNewGeometry = (char *)
VSIRealloc( m_pszGeometry, m_nGeomAlloc);
if (pszNewGeometry == NULL)
{
return CE_Failure;
}
m_pszGeometry = pszNewGeometry;
}
strcat( m_pszGeometry+m_nGeomLen, "</" );
strcpy( m_pszGeometry+m_nGeomLen+2, pszName );
strcat( m_pszGeometry+m_nGeomLen+nLNLenBytes+2, ">" );
m_nGeomLen += nLNLenBytes + 3;
if( poState->m_nPathLength == m_nGeometryDepth+1 )
{
if( poState->m_poFeature != NULL )
poState->m_poFeature->SetGeometryDirectly( m_pszGeometry );
else
CPLFree( m_pszGeometry );
m_pszGeometry = NULL;
m_nGeomAlloc = m_nGeomLen = 0;
}
}
/* -------------------------------------------------------------------- */
/* If we are collecting a feature, and this element tag matches */
/* element name for the class, then we have finished the */
/* feature, and we pop the feature read state. */
/* -------------------------------------------------------------------- */
if( m_nDepth == m_nDepthFeature && poState->m_poFeature != NULL
&& strcmp(pszName,
poState->m_poFeature->GetClass()->GetElementName()) == 0 )
{
m_poReader->PopState();
}
/* -------------------------------------------------------------------- */
/* Otherwise, we just pop the element off the local read states */
/* element stack. */
/* -------------------------------------------------------------------- */
else
{
if( strcmp(pszName,poState->GetLastComponent()) == 0 )
poState->PopPath();
else
{
CPLAssert( FALSE );
}
}
return CE_None;
}
OGRErr GMLHandler::startElement(const char *pszName, void* attr )
{
GMLReadState *poState = m_poReader->GetState();
int nLNLenBytes = strlen(pszName);
/* -------------------------------------------------------------------- */
/* If we are in the midst of collecting a feature attribute */
/* value, then this must be a complex attribute which we don't */
/* try to collect for now, so just terminate the field */
/* collection. */
/* -------------------------------------------------------------------- */
if( m_pszCurField != NULL )
{
CPLFree( m_pszCurField );
m_pszCurField = NULL;
}
/* -------------------------------------------------------------------- */
/* If we are collecting geometry, or if we determine this is a */
/* geometry element then append to the geometry info. */
/* -------------------------------------------------------------------- */
if( m_pszGeometry != NULL
|| IsGeometryElement( pszName ) )
{
/* should save attributes too! */
if( m_pszGeometry == NULL )
m_nGeometryDepth = poState->m_nPathLength;
char* pszAttributes = GetAttributes(attr);
if( m_nGeomLen + nLNLenBytes + 4 + strlen( pszAttributes ) >
m_nGeomAlloc )
{
m_nGeomAlloc = (int) (m_nGeomAlloc * 1.3 + nLNLenBytes + 1000 +
strlen( pszAttributes ));
char* pszNewGeometry = (char *)
VSIRealloc( m_pszGeometry, m_nGeomAlloc);
if (pszNewGeometry == NULL)
{
CPLFree(pszAttributes);
return CE_Failure;
}
m_pszGeometry = pszNewGeometry;
}
strcpy( m_pszGeometry+m_nGeomLen++, "<" );
strcpy( m_pszGeometry+m_nGeomLen, pszName );
m_nGeomLen += nLNLenBytes;
/* saving attributes */
strcat( m_pszGeometry + m_nGeomLen, pszAttributes );
m_nGeomLen += strlen( pszAttributes );
CPLFree(pszAttributes);
strcat( m_pszGeometry + (m_nGeomLen++), ">" );
}
/* -------------------------------------------------------------------- */
/* Is it a feature? If so push a whole new state, and return. */
/* -------------------------------------------------------------------- */
else if( m_poReader->IsFeatureElement( pszName ) )
{
char* pszFID = GetFID(attr);
m_poReader->PushFeature( pszName, pszFID);
CPLFree(pszFID);
m_nDepthFeature = m_nDepth;
m_nDepth ++;
return CE_None;
}
/* -------------------------------------------------------------------- */
/* If it is (or at least potentially is) a simple attribute, */
/* then start collecting it. */
/* -------------------------------------------------------------------- */
else if( m_poReader->IsAttributeElement( pszName ) )
{
CPLFree( m_pszCurField );
m_pszCurField = CPLStrdup("");
}
/* -------------------------------------------------------------------- */
/* Push the element onto the current state's path. */
/* -------------------------------------------------------------------- */
poState->PushPath( pszName );
m_nDepth ++;
return CE_None;
}
OGRErr GMLHandler::startElementFeatureAttribute(const char *pszName, int nLenName, void* attr )
{
/* Reset flag */
m_bInCurField = FALSE;
GMLReadState *poState = m_poReader->GetState();
/* -------------------------------------------------------------------- */
/* If we are collecting geometry, or if we determine this is a */
/* geometry element then append to the geometry info. */
/* -------------------------------------------------------------------- */
if( IsGeometryElement( pszName ) )
{
int bReadGeometry;
/* If the <GeometryElementPath> is defined in the .gfs, use it */
/* to read the appropriate geometry element */
const char* pszGeometryElement = poState->m_poFeature->GetClass()->GetGeometryElement();
if (pszGeometryElement != NULL)
bReadGeometry = strcmp(poState->osPath.c_str(), pszGeometryElement) == 0;
else
{
/* AIXM special case: for RouteSegment, we only want to read Curve geometries */
/* not 'start' and 'end' geometries */
if (m_bIsAIXM &&
strcmp(poState->m_poFeature->GetClass()->GetName(), "RouteSegment") == 0)
bReadGeometry = strcmp( pszName, "Curve") == 0;
else
bReadGeometry = TRUE;
}
if (bReadGeometry)
{
m_nGeometryDepth = m_nDepth;
CPLAssert(apsXMLNode.size() == 0);
NodeLastChild sNodeLastChild;
sNodeLastChild.psNode = NULL;
sNodeLastChild.psLastChild = NULL;
apsXMLNode.push_back(sNodeLastChild);
PUSH_STATE(STATE_GEOMETRY);
return startElementGeometry(pszName, nLenName, attr);
}
}
else if( nLenName == 9 && strcmp(pszName, "boundedBy") == 0 )
{
m_inBoundedByDepth = m_nDepth;
PUSH_STATE(STATE_BOUNDED_BY);
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Is it a CityGML generic attribute ? */
/* -------------------------------------------------------------------- */
else if( m_bIsCityGML &&
m_poReader->IsCityGMLGenericAttributeElement( pszName, attr ) )
{
CPLFree(m_pszCityGMLGenericAttrName);
m_pszCityGMLGenericAttrName = GetAttributeValue(attr, "name");
m_inCityGMLGenericAttrDepth = m_nDepth;
PUSH_STATE(STATE_CITYGML_ATTRIBUTE);
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* If it is (or at least potentially is) a simple attribute, */
/* then start collecting it. */
/* -------------------------------------------------------------------- */
else if( (m_nAttributeIndex =
m_poReader->GetAttributeElementIndex( pszName, nLenName )) != -1 )
{
if(m_pszCurField)
{
CPLFree(m_pszCurField);
m_pszCurField = NULL;
m_nCurFieldLen = m_nCurFieldAlloc = 0;
}
m_bInCurField = TRUE;
if (m_bReportHref)
{
CPLFree(m_pszHref);
m_pszHref = GetAttributeValue(attr, "xlink:href");
}
CPLFree(m_pszUom);
m_pszUom = GetAttributeValue(attr, "uom");
CPLFree(m_pszValue);
m_pszValue = GetAttributeValue(attr, "value");
if (stateStack[nStackDepth] != STATE_PROPERTY)
{
m_nAttributeDepth = m_nDepth;
PUSH_STATE(STATE_PROPERTY);
}
}
else if( m_bReportHref && (m_nAttributeIndex =
m_poReader->GetAttributeElementIndex( CPLSPrintf("%s_href", pszName ),
nLenName + 5 )) != -1 )
{
if(m_pszCurField)
{
CPLFree(m_pszCurField);
m_pszCurField = NULL;
m_nCurFieldLen = m_nCurFieldAlloc = 0;
}
m_bInCurField = TRUE;
CPLFree(m_pszHref);
m_pszHref = GetAttributeValue(attr, "xlink:href");
if (stateStack[nStackDepth] != STATE_PROPERTY)
{
m_nAttributeDepth = m_nDepth;
PUSH_STATE(STATE_PROPERTY);
}
}
poState->PushPath( pszName, nLenName );
return OGRERR_NONE;
}