int NASReader::IsAttributeElement( const char *pszElement )
{
if( m_poState->m_poFeature == NULL )
return FALSE;
GMLFeatureClass *poClass = m_poState->m_poFeature->GetClass();
// If the schema is not yet locked, then any simple element
// is potentially an attribute.
if( !poClass->IsSchemaLocked() )
return TRUE;
// Otherwise build the path to this element into a single string
// and compare against known attributes.
CPLString osElemPath;
if( m_poState->m_nPathLength == 0 )
osElemPath = pszElement;
else
{
osElemPath = m_poState->m_pszPath;
osElemPath += "|";
osElemPath += pszElement;
}
for( int i = 0; i < poClass->GetPropertyCount(); i++ )
if( EQUAL(poClass->GetProperty(i)->GetSrcElement(),osElemPath) )
return TRUE;
return FALSE;
}
int GMLReader::SaveClasses( const char *pszFile )
{
// Add logic later to determine reasonable default schema file.
if( pszFile == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Create in memory schema tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot;
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "GMLFeatureClassList" );
for( int iClass = 0; iClass < GetClassCount(); iClass++ )
{
GMLFeatureClass *poClass = GetClass( iClass );
CPLAddXMLChild( psRoot, poClass->SerializeToXML() );
}
/* -------------------------------------------------------------------- */
/* Serialize to disk. */
/* -------------------------------------------------------------------- */
FILE *fp;
int bSuccess = TRUE;
char *pszWholeText = CPLSerializeXMLTree( psRoot );
CPLDestroyXMLNode( psRoot );
fp = VSIFOpen( pszFile, "wb" );
if( fp == NULL )
bSuccess = FALSE;
else if( VSIFWrite( pszWholeText, strlen(pszWholeText), 1, fp ) != 1 )
bSuccess = FALSE;
else
VSIFClose( fp );
CPLFree( pszWholeText );
return bSuccess;
}
int GMLReader::IsAttributeElement( const char *pszElement )
{
if( m_poState->m_poFeature == NULL )
return FALSE;
if( m_poState->m_nPathLength > 0 )
return FALSE;
GMLFeatureClass *poClass = m_poState->m_poFeature->GetClass();
if( !poClass->IsSchemaLocked() )
return TRUE;
for( int i = 0; i < poClass->GetPropertyCount(); i++ )
if( EQUAL(poClass->GetProperty(i)->GetSrcElement(),pszElement) )
return TRUE;
return FALSE;
}
void GMLReader::SetFeatureProperty( const char *pszElement,
const char *pszValue )
{
GMLFeature *poFeature = GetState()->m_poFeature;
CPLAssert( poFeature != NULL );
/* -------------------------------------------------------------------- */
/* Does this property exist in the feature class? If not, add */
/* it. */
/* -------------------------------------------------------------------- */
GMLFeatureClass *poClass = poFeature->GetClass();
int iProperty;
for( iProperty=0; iProperty < poClass->GetPropertyCount(); iProperty++ )
{
if( EQUAL(poClass->GetProperty( iProperty )->GetSrcElement(),
pszElement ) )
break;
}
if( iProperty == poClass->GetPropertyCount() )
{
if( poClass->IsSchemaLocked() )
{
CPLDebug("GML","Encountered property missing from class schema.");
return;
}
GMLPropertyDefn *poPDefn = new GMLPropertyDefn(pszElement,pszElement);
if( EQUAL(CPLGetConfigOption( "GML_FIELDTYPES", ""), "ALWAYS_STRING") )
poPDefn->SetType( GMLPT_String );
poClass->AddProperty( poPDefn );
}
/* -------------------------------------------------------------------- */
/* Set the property */
/* -------------------------------------------------------------------- */
poFeature->SetProperty( iProperty, pszValue );
/* -------------------------------------------------------------------- */
/* Do we need to update the property type? */
/* -------------------------------------------------------------------- */
if( !poClass->IsSchemaLocked() )
poClass->GetProperty( iProperty )->AnalysePropertyValue(pszValue);
}
void gmlUpdateFeatureClasses ( GFSTemplateList *pCC,
GMLReader *pReader,
int *pbSequentialLayers )
{
/* updating the FeatureClass list */
int clIdx;
for (clIdx = 0; clIdx < pReader->GetClassCount(); clIdx++)
{
GMLFeatureClass* poClass = pReader->GetClass( clIdx );
if (poClass != NULL)
poClass->SetFeatureCount( 0 );
}
int m_bValid = FALSE;
GFSTemplateItem *pItem = pCC->GetFirst();
while ( pItem != NULL )
{
/* updating Classes */
GMLFeatureClass* poClass = pReader->GetClass( pItem->GetName() );
if (poClass != NULL)
{
poClass->SetFeatureCount( pItem->GetCount() );
if ( pItem->GetGeomCount() != 0 && poClass->GetGeometryPropertyCount() == 0 )
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( "", "", wkbUnknown ) );
m_bValid = TRUE;
}
pItem = pItem->GetNext();
}
if ( m_bValid == TRUE && pCC->HaveSequentialLayers() == TRUE )
*pbSequentialLayers = TRUE;
}
int GMLReader::PrescanForTemplate ()
{
int iCount = 0;
GMLFeature *poFeature;
//int bSequentialLayers = TRUE;
GFSTemplateList *pCC = new GFSTemplateList();
/* processing GML features */
while( (poFeature = NextFeature()) != NULL )
{
GMLFeatureClass *poClass = poFeature->GetClass();
const CPLXMLNode* const * papsGeomList = poFeature->GetGeometryList();
int b_has_geom = FALSE;
if( papsGeomList != NULL )
{
int i = 0;
const CPLXMLNode *psNode = papsGeomList[i];
while( psNode != NULL )
{
b_has_geom = TRUE;
i++;
psNode = papsGeomList[i];
}
}
pCC->Update( poClass->GetElementName(), b_has_geom );
delete poFeature;
}
gmlUpdateFeatureClasses( pCC, this, &m_bSequentialLayers );
if ( m_bSequentialLayers == TRUE )
ReArrangeTemplateClasses( pCC );
iCount = pCC->GetClassCount();
delete pCC;
CleanupParser();
return iCount > 0;
}
int GMLReader::PrescanForSchema( int bGetExtents )
{
GMLFeature *poFeature;
if( m_pszFilename == NULL )
return FALSE;
SetClassListLocked( FALSE );
ClearClasses();
if( !SetupParser() )
return FALSE;
while( (poFeature = NextFeature()) != NULL )
{
GMLFeatureClass *poClass = poFeature->GetClass();
if( poClass->GetFeatureCount() == -1 )
poClass->SetFeatureCount( 1 );
else
poClass->SetFeatureCount( poClass->GetFeatureCount() + 1 );
#ifdef SUPPORT_GEOMETRY
if( bGetExtents )
{
OGRGeometry *poGeometry = NULL;
if( poFeature->GetGeometry() != NULL
&& strlen(poFeature->GetGeometry()) != 0 )
{
poGeometry = OGRGeometryFactory::createFromGML(
poFeature->GetGeometry() );
}
if( poGeometry != NULL )
{
double dfXMin, dfXMax, dfYMin, dfYMax;
OGREnvelope sEnvelope;
poGeometry->getEnvelope( &sEnvelope );
delete poGeometry;
if( poClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax) )
{
dfXMin = MIN(dfXMin,sEnvelope.MinX);
dfXMax = MAX(dfXMax,sEnvelope.MaxX);
dfYMin = MIN(dfYMin,sEnvelope.MinY);
dfYMax = MAX(dfYMax,sEnvelope.MaxY);
}
else
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
}
poClass->SetExtents( dfXMin, dfXMax, dfYMin, dfYMax );
}
#endif /* def SUPPORT_GEOMETRY */
}
delete poFeature;
}
CleanupParser();
return GetClassCount() > 0;
}
int GMLReader::LoadClasses( const char *pszFile )
{
// Add logic later to determine reasonable default schema file.
if( pszFile == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Load the raw XML file. */
/* -------------------------------------------------------------------- */
FILE *fp;
int nLength;
char *pszWholeText;
fp = VSIFOpen( pszFile, "rb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open file %s.", pszFile );
return FALSE;
}
VSIFSeek( fp, 0, SEEK_END );
nLength = VSIFTell( fp );
VSIFSeek( fp, 0, SEEK_SET );
pszWholeText = (char *) VSIMalloc(nLength+1);
if( pszWholeText == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to allocate %d byte buffer for %s,\n"
"is this really a GMLFeatureClassList file?",
nLength, pszFile );
VSIFClose( fp );
return FALSE;
}
if( VSIFRead( pszWholeText, nLength, 1, fp ) != 1 )
{
VSIFree( pszWholeText );
VSIFClose( fp );
CPLError( CE_Failure, CPLE_AppDefined,
"Read failed on %s.", pszFile );
return FALSE;
}
pszWholeText[nLength] = '\0';
VSIFClose( fp );
if( strstr( pszWholeText, "<GMLFeatureClassList>" ) == NULL )
{
VSIFree( pszWholeText );
CPLError( CE_Failure, CPLE_AppDefined,
"File %s does not contain a GMLFeatureClassList tree.",
pszFile );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Convert to XML parse tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot;
psRoot = CPLParseXMLString( pszWholeText );
VSIFree( pszWholeText );
// We assume parser will report errors via CPL.
if( psRoot == NULL )
return FALSE;
if( psRoot->eType != CXT_Element
|| !EQUAL(psRoot->pszValue,"GMLFeatureClassList") )
{
CPLDestroyXMLNode(psRoot);
CPLError( CE_Failure, CPLE_AppDefined,
"File %s is not a GMLFeatureClassList document.",
pszFile );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Extract feature classes for all definitions found. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psThis;
for( psThis = psRoot->psChild; psThis != NULL; psThis = psThis->psNext )
{
if( psThis->eType == CXT_Element
&& EQUAL(psThis->pszValue,"GMLFeatureClass") )
{
GMLFeatureClass *poClass;
poClass = new GMLFeatureClass();
if( !poClass->InitializeFromXML( psThis ) )
{
delete poClass;
CPLDestroyXMLNode( psRoot );
return FALSE;
}
poClass->SetSchemaLocked( TRUE );
AddClass( poClass );
}
}
CPLDestroyXMLNode( psRoot );
SetClassListLocked( TRUE );
return TRUE;
}
static
GMLFeatureClass* GMLParseFeatureType(CPLXMLNode *psSchemaNode,
const char* pszName,
CPLXMLNode *psComplexType)
{
/* -------------------------------------------------------------------- */
/* Grab the sequence of extensions greatgrandchild. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psAttrSeq =
CPLGetXMLNode( psComplexType,
"complexContent.extension.sequence" );
if( psAttrSeq == NULL )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* We are pretty sure this going to be a valid Feature class */
/* now, so create it. */
/* -------------------------------------------------------------------- */
GMLFeatureClass *poClass = new GMLFeatureClass( pszName );
/* -------------------------------------------------------------------- */
/* Loop over each of the attribute elements being defined for */
/* this feature class. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psAttrDef;
int nAttributeIndex = 0;
int bGotUnrecognizedType = FALSE;
for( psAttrDef = psAttrSeq->psChild;
psAttrDef != NULL;
psAttrDef = psAttrDef->psNext )
{
if( strcmp(psAttrDef->pszValue,"group") == 0 )
{
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
if( !EQUAL(psAttrDef->pszValue,"element") )
continue;
/* MapServer WFS writes element type as an attribute of element */
/* not as a simpleType definition */
const char* pszType = CPLGetXMLValue( psAttrDef, "type", NULL );
const char* pszElementName = CPLGetXMLValue( psAttrDef, "name", NULL );
if (pszType != NULL)
{
const char* pszStrippedNSType = StripNS(pszType);
int nWidth = 0, nPrecision = 0;
GMLPropertyType gmlType = GMLPT_Untyped;
if (EQUAL(pszStrippedNSType, "string") ||
EQUAL(pszStrippedNSType, "Character"))
gmlType = GMLPT_String;
/* TODO: Would be nice to have a proper date type */
else if (EQUAL(pszStrippedNSType, "date") ||
EQUAL(pszStrippedNSType, "dateTime"))
gmlType = GMLPT_String;
else if (EQUAL(pszStrippedNSType, "real") ||
EQUAL(pszStrippedNSType, "double") ||
EQUAL(pszStrippedNSType, "float") ||
EQUAL(pszStrippedNSType, "decimal"))
gmlType = GMLPT_Real;
else if (EQUAL(pszStrippedNSType, "short") ||
EQUAL(pszStrippedNSType, "int") ||
EQUAL(pszStrippedNSType, "integer") ||
EQUAL(pszStrippedNSType, "long"))
gmlType = GMLPT_Integer;
else if (strncmp(pszType, "gml:", 4) == 0)
{
const AssocNameType* psIter = apsPropertyTypes;
while(psIter->pszName)
{
if (strncmp(pszType + 4, psIter->pszName, strlen(psIter->pszName)) == 0)
{
if (poClass->GetGeometryAttributeIndex() != -1)
{
CPLDebug("GML", "Geometry field already found ! Ignoring the following ones");
}
else
{
poClass->SetGeometryElement(pszElementName);
poClass->SetGeometryType(psIter->eType);
poClass->SetGeometryAttributeIndex( nAttributeIndex );
nAttributeIndex ++;
}
break;
}
psIter ++;
}
if (psIter->pszName == NULL)
{
/* Can be a non geometry gml type */
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
if (poClass->GetGeometryAttributeIndex() == -1)
bGotUnrecognizedType = TRUE;
continue;
}
/* Integraph stuff */
else if (strcmp(pszType, "G:Point_MultiPointPropertyType") == 0 ||
strcmp(pszType, "gmgml:Point_MultiPointPropertyType") == 0)
{
poClass->SetGeometryElement(pszElementName);
poClass->SetGeometryType(wkbMultiPoint);
poClass->SetGeometryAttributeIndex( nAttributeIndex );
nAttributeIndex ++;
continue;
}
else if (strcmp(pszType, "G:LineString_MultiLineStringPropertyType") == 0 ||
strcmp(pszType, "gmgml:LineString_MultiLineStringPropertyType") == 0)
{
poClass->SetGeometryElement(pszElementName);
poClass->SetGeometryType(wkbMultiLineString);
poClass->SetGeometryAttributeIndex( nAttributeIndex );
nAttributeIndex ++;
continue;
}
else if (strcmp(pszType, "G:Polygon_MultiPolygonPropertyType") == 0 ||
strcmp(pszType, "gmgml:Polygon_MultiPolygonPropertyType") == 0 ||
strcmp(pszType, "gmgml:Polygon_Surface_MultiSurface_CompositeSurfacePropertyType") == 0)
{
poClass->SetGeometryElement(pszElementName);
poClass->SetGeometryType(wkbMultiPolygon);
poClass->SetGeometryAttributeIndex( nAttributeIndex );
nAttributeIndex ++;
continue;
}
/* ERDAS Apollo stuff (like in http://apollo.erdas.com/erdas-apollo/vector/WORLDWIDE?SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&TYPENAME=wfs:cntry98) */
else if (strcmp(pszType, "wfs:MixedPolygonPropertyType") == 0)
{
poClass->SetGeometryElement(pszElementName);
poClass->SetGeometryType(wkbMultiPolygon);
poClass->SetGeometryAttributeIndex( nAttributeIndex );
nAttributeIndex ++;
continue;
}
else
{
gmlType = GMLPT_Untyped;
if ( ! LookForSimpleType(psSchemaNode, pszStrippedNSType,
&gmlType, &nWidth, &nPrecision) )
{
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
}
if (pszElementName == NULL)
pszElementName = "unnamed";
GMLPropertyDefn *poProp = new GMLPropertyDefn(
pszElementName, pszElementName );
poProp->SetType( gmlType );
poProp->SetAttributeIndex( nAttributeIndex );
poProp->SetWidth( nWidth );
poProp->SetPrecision( nPrecision );
if (poClass->AddProperty( poProp ) < 0)
delete poProp;
else
nAttributeIndex ++;
continue;
}
// For now we skip geometries .. fixup later.
CPLXMLNode* psSimpleType = CPLGetXMLNode( psAttrDef, "simpleType" );
if( psSimpleType == NULL )
{
const char* pszRef = CPLGetXMLValue( psAttrDef, "ref", NULL );
/* FME .xsd */
if (pszRef != NULL && strncmp(pszRef, "gml:", 4) == 0)
{
const AssocNameType* psIter = apsRefTypes;
while(psIter->pszName)
{
if (strncmp(pszRef + 4, psIter->pszName, strlen(psIter->pszName)) == 0)
{
if (poClass->GetGeometryAttributeIndex() != -1)
{
OGRwkbGeometryType eNewType = psIter->eType;
OGRwkbGeometryType eOldType = (OGRwkbGeometryType)poClass->GetGeometryType();
if ((eNewType == wkbMultiPoint && eOldType == wkbPoint) ||
(eNewType == wkbMultiLineString && eOldType == wkbLineString) ||
(eNewType == wkbMultiPolygon && eOldType == wkbPolygon))
{
poClass->SetGeometryType(eNewType);
}
else
{
CPLDebug("GML", "Geometry field already found ! Ignoring the following ones");
}
}
else
{
poClass->SetGeometryElement(pszElementName);
poClass->SetGeometryType(psIter->eType);
poClass->SetGeometryAttributeIndex( nAttributeIndex );
nAttributeIndex ++;
}
break;
}
psIter ++;
}
if (psIter->pszName == NULL)
{
/* Can be a non geometry gml type */
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
if (poClass->GetGeometryAttributeIndex() == -1)
bGotUnrecognizedType = TRUE;
continue;
}
/* Parse stuff like the following found in http://199.29.1.81:8181/miwfs/GetFeature.ashx?REQUEST=GetFeature&MAXFEATURES=1&SERVICE=WFS&VERSION=1.0.0&TYPENAME=miwfs:World :
<xs:element name="Obj" minOccurs="0" maxOccurs="1">
<xs:complexType>
<xs:sequence>
<xs:element ref="gml:_Geometry"/>
</xs:sequence>
</xs:complexType>
</xs:element>
*/
CPLXMLNode* psComplexType = GetSingleChildElement( psAttrDef, "complexType" );
CPLXMLNode* psComplexTypeSequence = GetSingleChildElement( psComplexType, "sequence" );
CPLXMLNode* psComplexTypeSequenceElement = GetSingleChildElement( psComplexTypeSequence, "element" );
if( pszElementName != NULL &&
CheckMinMaxOccursCardinality(psAttrDef) &&
psComplexTypeSequenceElement != NULL &&
CheckMinMaxOccursCardinality(psComplexTypeSequence) &&
strcmp(CPLGetXMLValue( psComplexTypeSequenceElement, "ref", "" ), "gml:_Geometry") == 0 )
{
poClass->SetGeometryElement(pszElementName);
poClass->SetGeometryType(wkbUnknown);
poClass->SetGeometryAttributeIndex( nAttributeIndex );
nAttributeIndex ++;
continue;
}
else
{
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
}
if (pszElementName == NULL)
pszElementName = "unnamed";
GMLPropertyDefn *poProp = new GMLPropertyDefn(
pszElementName, pszElementName );
GMLPropertyType eType = GMLPT_Untyped;
int nWidth = 0, nPrecision = 0;
GetSimpleTypeProperties(psSimpleType, &eType, &nWidth, &nPrecision);
poProp->SetType( eType );
poProp->SetWidth( nWidth );
poProp->SetPrecision( nPrecision );
poProp->SetAttributeIndex( nAttributeIndex );
if (poClass->AddProperty( poProp ) < 0)
delete poProp;
else
nAttributeIndex ++;
}
/* Only report wkbNone if we didn't find a known geometry type */
/* and there were not any unknown types (in case this unknown type */
/* would be a geometry type) */
if (poClass->GetGeometryAttributeIndex() == -1 &&
!bGotUnrecognizedType)
{
poClass->SetGeometryType(wkbNone);
}
/* -------------------------------------------------------------------- */
/* Class complete, add to reader class list. */
/* -------------------------------------------------------------------- */
poClass->SetSchemaLocked( TRUE );
return poClass;
}
int GMLReader::ReArrangeTemplateClasses ( GFSTemplateList *pCC )
{
/* rearranging the final FeatureClass list [SEQUENTIAL] */
int m_nSavedClassCount = GetClassCount();
/* saving the previous FeatureClass list */
GMLFeatureClass **m_papoSavedClass = (GMLFeatureClass **)
CPLMalloc( sizeof(void*) * m_nSavedClassCount );
int clIdx;
for (clIdx = 0; clIdx < GetClassCount(); clIdx++)
{
/* tranferring any previous FeatureClass */
m_papoSavedClass[clIdx] = m_papoClass[clIdx];
}
/* cleaning the previous FeatureClass list */
SetClassListLocked( FALSE );
CPLFree( m_papoClass );
m_nClassCount = 0;
m_papoClass = NULL;
GFSTemplateItem *pItem = pCC->GetFirst();
while ( pItem != NULL )
{
/*
* re-inserting any required FeatureClassup
* accordingly to actual SEQUENTIAL layout
*/
GMLFeatureClass* poClass = NULL;
for( int iClass = 0; iClass < m_nSavedClassCount; iClass++ )
{
GMLFeatureClass* poItem = m_papoSavedClass[iClass];
if( EQUAL(poItem->GetName(), pItem->GetName() ))
{
poClass = poItem;
break;
}
}
if (poClass != NULL)
{
if (poClass->GetFeatureCount() > 0)
AddClass( poClass );
}
pItem = pItem->GetNext();
}
SetClassListLocked( TRUE );
/* destroying the saved List and any unused FeatureClass */
for( int iClass = 0; iClass < m_nSavedClassCount; iClass++ )
{
int bUnused = TRUE;
GMLFeatureClass* poClass = m_papoSavedClass[iClass];
for( int iClass2 = 0; iClass2 < m_nClassCount; iClass2++ )
{
if (m_papoClass[iClass2] == poClass)
{
bUnused = FALSE;
break;
}
}
if ( bUnused == TRUE )
delete poClass;
}
CPLFree( m_papoSavedClass );
return 1;
}
int GMLReader::ParseXSD( const char *pszFile )
{
if( pszFile == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Load the raw XML file. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psXSDTree = CPLParseXMLFile( pszFile );
if( psXSDTree == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Strip off any namespace qualifiers. */
/* -------------------------------------------------------------------- */
CPLStripXMLNamespace( psXSDTree, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* Find <schema> root element. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psSchemaNode = CPLGetXMLNode( psXSDTree, "=schema" );
if( psSchemaNode == NULL )
{
CPLDestroyXMLNode( psXSDTree );
return FALSE;
}
/* ==================================================================== */
/* Process each feature class definition. */
/* ==================================================================== */
CPLXMLNode *psThis;
int bIsLevel0 = TRUE;
for( psThis = psSchemaNode->psChild;
psThis != NULL; psThis = psThis->psNext )
{
/* -------------------------------------------------------------------- */
/* Check for <xs:element> node. */
/* -------------------------------------------------------------------- */
if( psThis->eType != CXT_Element
|| !EQUAL(psThis->pszValue,"element") )
continue;
/* -------------------------------------------------------------------- */
/* Check the substitution group. */
/* -------------------------------------------------------------------- */
const char *pszSubGroup =
StripNS(CPLGetXMLValue(psThis,"substitutionGroup",""));
// Old OGR produced elements for the feature collection.
if( EQUAL(pszSubGroup, "_FeatureCollection") )
continue;
if( !EQUAL(pszSubGroup, "_Feature") )
{
bIsLevel0 = FALSE;
break;
}
/* -------------------------------------------------------------------- */
/* Get name */
/* -------------------------------------------------------------------- */
const char *pszName;
pszName = CPLGetXMLValue( psThis, "name", NULL );
if( pszName == NULL )
{
bIsLevel0 = FALSE;
break;
}
/* -------------------------------------------------------------------- */
/* Get type and verify relationship with name. */
/* -------------------------------------------------------------------- */
const char *pszType;
pszType = CPLGetXMLValue( psThis, "type", NULL );
if( strstr( pszType, ":" ) != NULL )
pszType = strstr( pszType, ":" ) + 1;
if( pszType == NULL || !EQUALN(pszType,pszName,strlen(pszName))
|| !(EQUAL(pszType+strlen(pszName),"_Type") ||
EQUAL(pszType+strlen(pszName),"Type")) )
{
bIsLevel0 = FALSE;
break;
}
/* -------------------------------------------------------------------- */
/* The very next element should be the corresponding */
/* complexType declaration for the element. */
/* -------------------------------------------------------------------- */
psThis = psThis->psNext;
while( psThis != NULL && psThis->eType == CXT_Comment )
psThis = psThis->psNext;
if( psThis == NULL
|| psThis->eType != CXT_Element
|| !EQUAL(psThis->pszValue,"complexType")
|| !EQUAL(CPLGetXMLValue(psThis,"name",""),pszType) )
{
bIsLevel0 = FALSE;
break;
}
/* -------------------------------------------------------------------- */
/* Grab the sequence of extensions greatgrandchild. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psAttrSeq =
CPLGetXMLNode( psThis,
"complexContent.extension.sequence" );
if( psAttrSeq == NULL )
{
bIsLevel0 = FALSE;
break;
}
/* -------------------------------------------------------------------- */
/* We are pretty sure this going to be a valid Feature class */
/* now, so create it. */
/* -------------------------------------------------------------------- */
GMLFeatureClass *poClass = new GMLFeatureClass( pszName );
/* -------------------------------------------------------------------- */
/* Loop over each of the attribute elements being defined for */
/* this feature class. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psAttrDef;
for( psAttrDef = psAttrSeq->psChild;
psAttrDef != NULL;
psAttrDef = psAttrDef->psNext )
{
if( !EQUAL(psAttrDef->pszValue,"element") )
continue;
// For now we skip geometries .. fixup later.
if( CPLGetXMLNode( psAttrDef, "simpleType" ) == NULL )
continue;
GMLPropertyDefn *poProp = new GMLPropertyDefn(
CPLGetXMLValue( psAttrDef, "name", "unnamed" ),
CPLGetXMLValue( psAttrDef, "name", "unnamed" ) );
const char *pszBase =
StripNS( CPLGetXMLValue( psAttrDef,
"simpleType.restriction.base", "" ));
if( EQUAL(pszBase,"decimal") )
{
poProp->SetType( GMLPT_Real );
const char *pszWidth =
CPLGetXMLValue( psAttrDef,
"simpleType.restriction.totalDigits.value", "0" );
const char *pszPrecision =
CPLGetXMLValue( psAttrDef,
"simpleType.restriction.fractionDigits.value", "0" );
poProp->SetWidth( atoi(pszWidth) );
poProp->SetPrecision( atoi(pszPrecision) );
}
else if( EQUAL(pszBase,"float")
|| EQUAL(pszBase,"double") )
poProp->SetType( GMLPT_Real );
else if( EQUAL(pszBase,"integer") )
{
poProp->SetType( GMLPT_Integer );
const char *pszWidth =
CPLGetXMLValue( psAttrDef,
"simpleType.restriction.totalDigits.value", "0" );
poProp->SetWidth( atoi(pszWidth) );
}
else if( EQUAL(pszBase,"string") )
{
poProp->SetType( GMLPT_String );
const char *pszWidth =
CPLGetXMLValue( psAttrDef,
"simpleType.restriction.maxLength.value", "0" );
poProp->SetWidth( atoi(pszWidth) );
}
else
poProp->SetType( GMLPT_Untyped );
poClass->AddProperty( poProp );
}
/* -------------------------------------------------------------------- */
/* Class complete, add to reader class list. */
/* -------------------------------------------------------------------- */
poClass->SetSchemaLocked( TRUE );
AddClass( poClass );
}
CPLDestroyXMLNode( psXSDTree );
if( m_nClassCount > 0 )
{
SetClassListLocked( TRUE );
return TRUE;
}
else
return FALSE;
}
int NASReader::PrescanForSchema( int bGetExtents )
{
GMLFeature *poFeature;
if( m_pszFilename == NULL )
return FALSE;
SetClassListLocked( FALSE );
ClearClasses();
if( !SetupParser() )
return FALSE;
while( (poFeature = NextFeature()) != NULL )
{
GMLFeatureClass *poClass = poFeature->GetClass();
if( poClass->GetFeatureCount() == -1 )
poClass->SetFeatureCount( 1 );
else
poClass->SetFeatureCount( poClass->GetFeatureCount() + 1 );
#ifdef SUPPORT_GEOMETRY
if( bGetExtents )
{
OGRGeometry *poGeometry = NULL;
if( poFeature->GetGeometry() != NULL
&& strlen(poFeature->GetGeometry()) != 0 )
{
poGeometry = (OGRGeometry *) OGR_G_CreateFromGML(
poFeature->GetGeometry() );
}
if( poGeometry != NULL )
{
double dfXMin, dfXMax, dfYMin, dfYMax;
OGREnvelope sEnvelope;
OGRwkbGeometryType eGType = (OGRwkbGeometryType)
poClass->GetGeometryType();
// Merge geometry type into layer.
if( poClass->GetFeatureCount() == 1 && eGType == wkbUnknown )
eGType = wkbNone;
poClass->SetGeometryType(
(int) OGRMergeGeometryTypes(
eGType, poGeometry->getGeometryType() ) );
// merge extents.
poGeometry->getEnvelope( &sEnvelope );
delete poGeometry;
if( poClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax) )
{
dfXMin = MIN(dfXMin,sEnvelope.MinX);
dfXMax = MAX(dfXMax,sEnvelope.MaxX);
dfYMin = MIN(dfYMin,sEnvelope.MinY);
dfYMax = MAX(dfYMax,sEnvelope.MaxY);
}
else
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
}
poClass->SetExtents( dfXMin, dfXMax, dfYMin, dfYMax );
}
else
{
if( poClass->GetGeometryType() == (int) wkbUnknown
&& poClass->GetFeatureCount() == 1 )
poClass->SetGeometryType( wkbNone );
}
#endif /* def SUPPORT_GEOMETRY */
}
delete poFeature;
}
CleanupParser();
return GetClassCount() > 0;
}
void NASReader::SetFeatureProperty( const char *pszElement,
const char *pszValue )
{
GMLFeature *poFeature = GetState()->m_poFeature;
CPLAssert( poFeature != NULL );
/* -------------------------------------------------------------------- */
/* Does this property exist in the feature class? If not, add */
/* it. */
/* -------------------------------------------------------------------- */
GMLFeatureClass *poClass = poFeature->GetClass();
int iProperty;
for( iProperty=0; iProperty < poClass->GetPropertyCount(); iProperty++ )
{
if( EQUAL(poClass->GetProperty( iProperty )->GetSrcElement(),
pszElement ) )
break;
}
if( iProperty == poClass->GetPropertyCount() )
{
if( poClass->IsSchemaLocked() )
{
CPLDebug("GML","Encountered property missing from class schema.");
return;
}
CPLString osFieldName;
if( strchr(pszElement,'|') == NULL )
osFieldName = pszElement;
else
{
osFieldName = strrchr(pszElement,'|') + 1;
if( poClass->GetPropertyIndex(osFieldName) != -1 )
osFieldName = pszElement;
}
// Does this conflict with an existing property name?
while( poClass->GetProperty(osFieldName) != NULL )
{
osFieldName += "_";
}
GMLPropertyDefn *poPDefn = new GMLPropertyDefn(osFieldName,pszElement);
if( EQUAL(CPLGetConfigOption( "GML_FIELDTYPES", ""), "ALWAYS_STRING") )
poPDefn->SetType( GMLPT_String );
poClass->AddProperty( poPDefn );
}
/* -------------------------------------------------------------------- */
/* Set the property */
/* -------------------------------------------------------------------- */
poFeature->SetProperty( iProperty, pszValue );
/* -------------------------------------------------------------------- */
/* Do we need to update the property type? */
/* -------------------------------------------------------------------- */
if( !poClass->IsSchemaLocked() )
{
poClass->GetProperty(iProperty)->AnalysePropertyValue(
poFeature->GetProperty(iProperty));
}
}
int NASReader::PrescanForSchema( int bGetExtents )
{
GMLFeature *poFeature;
if( m_pszFilename == NULL )
return FALSE;
SetClassListLocked( FALSE );
ClearClasses();
if( !SetupParser() )
return FALSE;
std::string osWork;
while( (poFeature = NextFeature()) != NULL )
{
GMLFeatureClass *poClass = poFeature->GetClass();
if( poClass->GetFeatureCount() == -1 )
poClass->SetFeatureCount( 1 );
else
poClass->SetFeatureCount( poClass->GetFeatureCount() + 1 );
#ifdef SUPPORT_GEOMETRY
if( bGetExtents )
{
OGRGeometry *poGeometry = NULL;
const CPLXMLNode* const * papsGeometry = poFeature->GetGeometryList();
if( papsGeometry[0] != NULL )
{
poGeometry = (OGRGeometry*) OGR_G_CreateFromGMLTree(papsGeometry[0]);
}
if( poGeometry != NULL )
{
double dfXMin, dfXMax, dfYMin, dfYMax;
OGREnvelope sEnvelope;
OGRwkbGeometryType eGType = (OGRwkbGeometryType)
poClass->GetGeometryType();
// Merge SRSName into layer.
const char* pszSRSName = GML_ExtractSrsNameFromGeometry(papsGeometry, osWork, FALSE);
// if (pszSRSName != NULL)
// m_bCanUseGlobalSRSName = FALSE;
poClass->MergeSRSName(pszSRSName);
// Merge geometry type into layer.
if( poClass->GetFeatureCount() == 1 && eGType == wkbUnknown )
eGType = wkbNone;
poClass->SetGeometryType(
(int) OGRMergeGeometryTypes(
eGType, poGeometry->getGeometryType() ) );
// merge extents.
poGeometry->getEnvelope( &sEnvelope );
delete poGeometry;
if( poClass->GetExtents(&dfXMin, &dfXMax, &dfYMin, &dfYMax) )
{
dfXMin = MIN(dfXMin,sEnvelope.MinX);
dfXMax = MAX(dfXMax,sEnvelope.MaxX);
dfYMin = MIN(dfYMin,sEnvelope.MinY);
dfYMax = MAX(dfYMax,sEnvelope.MaxY);
}
else
{
dfXMin = sEnvelope.MinX;
dfXMax = sEnvelope.MaxX;
dfYMin = sEnvelope.MinY;
dfYMax = sEnvelope.MaxY;
}
poClass->SetExtents( dfXMin, dfXMax, dfYMin, dfYMax );
}
else
{
if( poClass->GetGeometryType() == (int) wkbUnknown
&& poClass->GetFeatureCount() == 1 )
poClass->SetGeometryType( wkbNone );
}
#endif /* def SUPPORT_GEOMETRY */
}
delete poFeature;
}
CleanupParser();
return GetClassCount() > 0;
}
void NASReader::SetFeaturePropertyDirectly( const char *pszElement,
char *pszValue )
{
GMLFeature *poFeature = GetState()->m_poFeature;
CPLAssert( poFeature != NULL );
/* -------------------------------------------------------------------- */
/* Does this property exist in the feature class? If not, add */
/* it. */
/* -------------------------------------------------------------------- */
GMLFeatureClass *poClass = poFeature->GetClass();
int iProperty;
for( iProperty=0; iProperty < poClass->GetPropertyCount(); iProperty++ )
{
if( EQUAL(poClass->GetProperty( iProperty )->GetSrcElement(),
pszElement ) )
break;
}
if( iProperty == poClass->GetPropertyCount() )
{
if( poClass->IsSchemaLocked() )
{
CPLDebug("NAS","Encountered property missing from class schema.");
CPLFree(pszValue);
return;
}
CPLString osFieldName;
if( strchr(pszElement,'|') == NULL )
osFieldName = pszElement;
else
{
osFieldName = strrchr(pszElement,'|') + 1;
if( poClass->GetPropertyIndex(osFieldName) != -1 )
osFieldName = pszElement;
}
// Does this conflict with an existing property name?
while( poClass->GetProperty(osFieldName) != NULL )
{
osFieldName += "_";
}
GMLPropertyDefn *poPDefn = new GMLPropertyDefn(osFieldName,pszElement);
if( EQUAL(CPLGetConfigOption( "GML_FIELDTYPES", ""), "ALWAYS_STRING") )
poPDefn->SetType( GMLPT_String );
poClass->AddProperty( poPDefn );
}
/* -------------------------------------------------------------------- */
/* We want to handle <lage> specially to ensure it is zero */
/* filled, and treated as a string depspite the numeric */
/* content. https://trac.wheregroup.com/PostNAS/ticket/9 */
/* -------------------------------------------------------------------- */
if( strcmp(poClass->GetProperty(iProperty)->GetName(),"lage") == 0 )
{
if( strlen(pszValue) < 5 )
{
CPLString osValue = "00000";
osValue += pszValue;
poFeature->SetPropertyDirectly( iProperty, CPLStrdup(osValue + osValue.size() - 5) );
CPLFree(pszValue);
}
else
poFeature->SetPropertyDirectly( iProperty, pszValue );
if( !poClass->IsSchemaLocked() )
{
poClass->GetProperty(iProperty)->SetWidth( 5 );
poClass->GetProperty(iProperty)->SetType( GMLPT_String );
}
return;
}
/* -------------------------------------------------------------------- */
/* Set the property */
/* -------------------------------------------------------------------- */
poFeature->SetPropertyDirectly( iProperty, pszValue );
/* -------------------------------------------------------------------- */
/* Do we need to update the property type? */
/* -------------------------------------------------------------------- */
if( !poClass->IsSchemaLocked() )
{
// Special handling for punktkennung per NAS #12
if( strcmp(poClass->GetProperty(iProperty)->GetName(),
"punktkennung") == 0)
{
poClass->GetProperty(iProperty)->SetWidth( 15 );
poClass->GetProperty(iProperty)->SetType( GMLPT_String );
}
// Special handling for artDerFlurstuecksgrenze per http://trac.osgeo.org/gdal/ticket/4255
else if( strcmp(poClass->GetProperty(iProperty)->GetName(),
"artDerFlurstuecksgrenze") == 0)
{
poClass->GetProperty(iProperty)->SetType( GMLPT_IntegerList );
}
else
poClass->GetProperty(iProperty)->AnalysePropertyValue(
poFeature->GetProperty(iProperty));
}
}
static
GMLFeatureClass* GMLParseFeatureType(CPLXMLNode *psSchemaNode,
const char* pszName,
CPLXMLNode *psComplexType)
{
/* -------------------------------------------------------------------- */
/* Grab the sequence of extensions greatgrandchild. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psAttrSeq =
CPLGetXMLNode( psComplexType,
"complexContent.extension.sequence" );
if( psAttrSeq == NULL )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* We are pretty sure this going to be a valid Feature class */
/* now, so create it. */
/* -------------------------------------------------------------------- */
GMLFeatureClass *poClass = new GMLFeatureClass( pszName );
/* -------------------------------------------------------------------- */
/* Loop over each of the attribute elements being defined for */
/* this feature class. */
/* -------------------------------------------------------------------- */
int nAttributeIndex = 0;
bool bGotUnrecognizedType = false;
CPLXMLNode *psAttrDef = psAttrSeq->psChild;
for( ; psAttrDef != NULL; psAttrDef = psAttrDef->psNext )
{
if( strcmp(psAttrDef->pszValue,"group") == 0 )
{
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
/* Parse stuff like :
<xs:choice>
<xs:element ref="gml:polygonProperty"/>
<xs:element ref="gml:multiPolygonProperty"/>
</xs:choice>
as found in https://downloadagiv.blob.core.windows.net/overstromingsgebieden-en-oeverzones/2014_01/Overstromingsgebieden_en_oeverzones_2014_01_GML.zip
*/
if( strcmp(psAttrDef->pszValue,"choice") == 0 )
{
CPLXMLNode* psChild = psAttrDef->psChild;
bool bPolygon = false;
bool bMultiPolygon = false;
for( ; psChild; psChild = psChild->psNext )
{
if( psChild->eType != CXT_Element )
continue;
if( strcmp(psChild->pszValue,"element") == 0 )
{
const char* pszRef = CPLGetXMLValue( psChild, "ref", NULL );
if( pszRef != NULL )
{
if( strcmp(pszRef, "gml:polygonProperty") == 0 )
bPolygon = true;
else if( strcmp(pszRef, "gml:multiPolygonProperty") == 0 )
bMultiPolygon = true;
else
{
delete poClass;
return NULL;
}
}
else
{
delete poClass;
return NULL;
}
}
}
if( bPolygon && bMultiPolygon )
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
"", "", wkbMultiPolygon, nAttributeIndex, true ) );
nAttributeIndex ++;
}
continue;
}
if( !EQUAL(psAttrDef->pszValue,"element") )
continue;
/* MapServer WFS writes element type as an attribute of element */
/* not as a simpleType definition */
const char* pszType = CPLGetXMLValue( psAttrDef, "type", NULL );
const char* pszElementName = CPLGetXMLValue( psAttrDef, "name", NULL );
bool bNullable = EQUAL(CPLGetXMLValue( psAttrDef, "minOccurs", "1" ), "0");
const char* pszMaxOccurs = CPLGetXMLValue( psAttrDef, "maxOccurs", NULL );
if (pszType != NULL)
{
const char* pszStrippedNSType = StripNS(pszType);
int nWidth = 0, nPrecision = 0;
GMLPropertyType gmlType = GMLPT_Untyped;
if (EQUAL(pszStrippedNSType, "string") ||
EQUAL(pszStrippedNSType, "Character"))
gmlType = GMLPT_String;
/* TODO: Would be nice to have a proper date type */
else if (EQUAL(pszStrippedNSType, "date") ||
EQUAL(pszStrippedNSType, "dateTime"))
gmlType = GMLPT_String;
else if (EQUAL(pszStrippedNSType, "real") ||
EQUAL(pszStrippedNSType, "double") ||
EQUAL(pszStrippedNSType, "decimal"))
gmlType = GMLPT_Real;
else if (EQUAL(pszStrippedNSType, "float") )
gmlType = GMLPT_Float;
else if (EQUAL(pszStrippedNSType, "int") ||
EQUAL(pszStrippedNSType, "integer"))
gmlType = GMLPT_Integer;
else if (EQUAL(pszStrippedNSType, "long"))
gmlType = GMLPT_Integer64;
else if (EQUAL(pszStrippedNSType, "short") )
gmlType = GMLPT_Short;
else if (EQUAL(pszStrippedNSType, "boolean") )
gmlType = GMLPT_Boolean;
else if (strcmp(pszType, "gml:FeaturePropertyType") == 0 )
{
gmlType = GMLPT_FeatureProperty;
}
else if (STARTS_WITH(pszType, "gml:"))
{
const AssocNameType* psIter = apsPropertyTypes;
while(psIter->pszName)
{
if (strncmp(pszType + 4, psIter->pszName, strlen(psIter->pszName)) == 0)
{
OGRwkbGeometryType eType = psIter->eType;
/* Look if there's a comment restricting to subclasses */
if( psAttrDef->psNext != NULL && psAttrDef->psNext->eType == CXT_Comment )
{
if( strstr(psAttrDef->psNext->pszValue, "restricted to Polygon") )
eType = wkbPolygon;
else if( strstr(psAttrDef->psNext->pszValue, "restricted to LineString") )
eType = wkbLineString;
else if( strstr(psAttrDef->psNext->pszValue, "restricted to MultiPolygon") )
eType = wkbMultiPolygon;
else if( strstr(psAttrDef->psNext->pszValue, "restricted to MultiLineString") )
eType = wkbMultiLineString;
}
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
pszElementName, pszElementName, eType, nAttributeIndex, bNullable ) );
nAttributeIndex ++;
break;
}
psIter ++;
}
if (psIter->pszName == NULL)
{
/* Can be a non geometry gml type */
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
if (poClass->GetGeometryPropertyCount() == 0)
bGotUnrecognizedType = true;
continue;
}
/* Integraph stuff */
else if (strcmp(pszType, "G:Point_MultiPointPropertyType") == 0 ||
strcmp(pszType, "gmgml:Point_MultiPointPropertyType") == 0)
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
pszElementName, pszElementName, wkbMultiPoint, nAttributeIndex,
bNullable ) );
nAttributeIndex ++;
continue;
}
else if (strcmp(pszType, "G:LineString_MultiLineStringPropertyType") == 0 ||
strcmp(pszType, "gmgml:LineString_MultiLineStringPropertyType") == 0)
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
pszElementName, pszElementName, wkbMultiLineString, nAttributeIndex,
bNullable ) );
nAttributeIndex ++;
continue;
}
else if (strcmp(pszType, "G:Polygon_MultiPolygonPropertyType") == 0 ||
strcmp(pszType, "gmgml:Polygon_MultiPolygonPropertyType") == 0 ||
strcmp(pszType, "gmgml:Polygon_Surface_MultiSurface_CompositeSurfacePropertyType") == 0)
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
pszElementName, pszElementName, wkbMultiPolygon, nAttributeIndex,
bNullable ) );
nAttributeIndex ++;
continue;
}
/* ERDAS Apollo stuff (like in http://apollo.erdas.com/erdas-apollo/vector/WORLDWIDE?SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&TYPENAME=wfs:cntry98) */
else if (strcmp(pszType, "wfs:MixedPolygonPropertyType") == 0)
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
pszElementName, pszElementName, wkbMultiPolygon, nAttributeIndex,
bNullable) );
nAttributeIndex ++;
continue;
}
else
{
gmlType = GMLPT_Untyped;
if ( ! LookForSimpleType(psSchemaNode, pszStrippedNSType,
&gmlType, &nWidth, &nPrecision) )
{
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
}
if (pszElementName == NULL)
pszElementName = "unnamed";
const char* pszPropertyName = pszElementName;
if( gmlType == GMLPT_FeatureProperty )
{
pszPropertyName = CPLSPrintf("%s_href", pszElementName);
}
GMLPropertyDefn *poProp = new GMLPropertyDefn(
pszPropertyName, pszElementName );
if( pszMaxOccurs != NULL && strcmp(pszMaxOccurs, "1") != 0 )
gmlType = GetListTypeFromSingleType(gmlType);
poProp->SetType( gmlType );
poProp->SetWidth( nWidth );
poProp->SetPrecision( nPrecision );
poProp->SetNullable( bNullable );
if (poClass->AddProperty( poProp ) < 0)
delete poProp;
else
nAttributeIndex ++;
continue;
}
// For now we skip geometries .. fixup later.
CPLXMLNode* psSimpleType = CPLGetXMLNode( psAttrDef, "simpleType" );
if( psSimpleType == NULL )
{
const char* pszRef = CPLGetXMLValue( psAttrDef, "ref", NULL );
/* FME .xsd */
if (pszRef != NULL && STARTS_WITH(pszRef, "gml:"))
{
const AssocNameType* psIter = apsRefTypes;
while(psIter->pszName)
{
if (strncmp(pszRef + 4, psIter->pszName, strlen(psIter->pszName)) == 0)
{
if (poClass->GetGeometryPropertyCount() > 0)
{
OGRwkbGeometryType eNewType = psIter->eType;
OGRwkbGeometryType eOldType = (OGRwkbGeometryType)poClass->GetGeometryProperty(0)->GetType();
if ((eNewType == wkbMultiPoint && eOldType == wkbPoint) ||
(eNewType == wkbMultiLineString && eOldType == wkbLineString) ||
(eNewType == wkbMultiPolygon && eOldType == wkbPolygon))
{
poClass->GetGeometryProperty(0)->SetType(eNewType);
}
else
{
CPLDebug("GML", "Geometry field already found ! Ignoring the following ones");
}
}
else
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
pszElementName, pszElementName, psIter->eType, nAttributeIndex, true ) );
nAttributeIndex ++;
}
break;
}
psIter ++;
}
if (psIter->pszName == NULL)
{
/* Can be a non geometry gml type */
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
if (poClass->GetGeometryPropertyCount() == 0)
bGotUnrecognizedType = true;
continue;
}
/* Parse stuff like the following found in http://199.29.1.81:8181/miwfs/GetFeature.ashx?REQUEST=GetFeature&MAXFEATURES=1&SERVICE=WFS&VERSION=1.0.0&TYPENAME=miwfs:World :
<xs:element name="Obj" minOccurs="0" maxOccurs="1">
<xs:complexType>
<xs:sequence>
<xs:element ref="gml:_Geometry"/>
</xs:sequence>
</xs:complexType>
</xs:element>
*/
CPLXMLNode* l_psComplexType = GetSingleChildElement( psAttrDef, "complexType" );
CPLXMLNode* psComplexTypeSequence = GetSingleChildElement( l_psComplexType, "sequence" );
CPLXMLNode* psComplexTypeSequenceElement = GetSingleChildElement( psComplexTypeSequence, "element" );
if( pszElementName != NULL &&
CheckMinMaxOccursCardinality(psAttrDef) &&
psComplexTypeSequenceElement != NULL &&
CheckMinMaxOccursCardinality(psComplexTypeSequence) &&
strcmp(CPLGetXMLValue( psComplexTypeSequenceElement, "ref", "" ), "gml:_Geometry") == 0 )
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn(
pszElementName, pszElementName, wkbUnknown, nAttributeIndex, bNullable ) );
nAttributeIndex ++;
continue;
}
else
{
/* Too complex schema for us. Aborts parsing */
delete poClass;
return NULL;
}
}
if (pszElementName == NULL)
pszElementName = "unnamed";
GMLPropertyDefn *poProp = new GMLPropertyDefn(
pszElementName, pszElementName );
GMLPropertyType eType = GMLPT_Untyped;
int nWidth = 0, nPrecision = 0;
GetSimpleTypeProperties(psSimpleType, &eType, &nWidth, &nPrecision);
if( pszMaxOccurs != NULL && strcmp(pszMaxOccurs, "1") != 0 )
eType = GetListTypeFromSingleType(eType);
poProp->SetType( eType );
poProp->SetWidth( nWidth );
poProp->SetPrecision( nPrecision );
poProp->SetNullable( bNullable );
if (poClass->AddProperty( poProp ) < 0)
delete poProp;
else
nAttributeIndex ++;
}
/* If we have found an unknown types, let's be on the side of caution and */
/* create a geometry field */
if( poClass->GetGeometryPropertyCount() == 0 &&
bGotUnrecognizedType )
{
poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( "", "", wkbUnknown, -1, true ) );
}
/* -------------------------------------------------------------------- */
/* Class complete, add to reader class list. */
/* -------------------------------------------------------------------- */
poClass->SetSchemaLocked( true );
return poClass;
}
