static
int GetSimpleTypeProperties(CPLXMLNode *psTypeNode,
GMLPropertyType *pGMLType,
int *pnWidth,
int *pnPrecision)
{
const char *pszBase =
StripNS( CPLGetXMLValue( psTypeNode,
"restriction.base", "" ));
if( EQUAL(pszBase,"decimal") )
{
*pGMLType = GMLPT_Real;
const char *pszWidth =
CPLGetXMLValue( psTypeNode,
"restriction.totalDigits.value", "0" );
const char *pszPrecision =
CPLGetXMLValue( psTypeNode,
"restriction.fractionDigits.value", "0" );
*pnWidth = atoi(pszWidth);
*pnPrecision = atoi(pszPrecision);
return TRUE;
}
else if( EQUAL(pszBase,"float")
|| EQUAL(pszBase,"double") )
{
*pGMLType = GMLPT_Real;
return TRUE;
}
else if( EQUAL(pszBase,"integer") )
{
*pGMLType = GMLPT_Integer;
const char *pszWidth =
CPLGetXMLValue( psTypeNode,
"restriction.totalDigits.value", "0" );
*pnWidth = atoi(pszWidth);
return TRUE;
}
else if( EQUAL(pszBase,"string") )
{
*pGMLType = GMLPT_String;
const char *pszWidth =
CPLGetXMLValue( psTypeNode,
"restriction.maxLength.value", "0" );
*pnWidth = atoi(pszWidth);
return TRUE;
}
/* TODO: Would be nice to have a proper date type */
else if( EQUAL(pszBase,"date") ||
EQUAL(pszBase,"dateTime") )
{
*pGMLType = GMLPT_String;
return TRUE;
}
return FALSE;
}
int GMLParseXSD( const char *pszFile,
std::vector<GMLFeatureClass*> & aosClasses)
{
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;
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") &&
!EQUAL(pszSubGroup, "AbstractFeature") /* AbstractFeature used by GML 3.2 */ )
{
continue;
}
/* -------------------------------------------------------------------- */
/* Get name */
/* -------------------------------------------------------------------- */
const char *pszName;
pszName = CPLGetXMLValue( psThis, "name", NULL );
if( pszName == NULL )
{
continue;
}
/* -------------------------------------------------------------------- */
/* Get type and verify relationship with name. */
/* -------------------------------------------------------------------- */
const char *pszType;
pszType = CPLGetXMLValue( psThis, "type", NULL );
if (pszType == NULL)
{
CPLXMLNode *psComplexType = CPLGetXMLNode( psThis, "complexType" );
if (psComplexType)
{
GMLFeatureClass* poClass =
GMLParseFeatureType(psSchemaNode, pszName, psComplexType);
if (poClass)
aosClasses.push_back(poClass);
}
continue;
}
if( strstr( pszType, ":" ) != NULL )
pszType = strstr( pszType, ":" ) + 1;
if( EQUAL(pszType, pszName) )
{
/* A few WFS servers return a type name which is the element name */
/* without any _Type or Type suffix */
/* e.g. : http://apollo.erdas.com/erdas-apollo/vector/Cherokee?SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&TYPENAME=iwfs:Air */
}
else if( !EQUALN(pszType,pszName,strlen(pszName))
|| !(EQUAL(pszType+strlen(pszName),"_Type") ||
EQUAL(pszType+strlen(pszName),"Type")) )
{
continue;
}
/* CanVec .xsd contains weird types that are not used in the related GML */
if (strncmp(pszName, "XyZz", 4) == 0 ||
strncmp(pszName, "XyZ1", 4) == 0 ||
strncmp(pszName, "XyZ2", 4) == 0)
continue;
GMLFeatureClass* poClass =
GMLParseFeatureType(psSchemaNode, pszName, pszType);
if (poClass)
aosClasses.push_back(poClass);
}
CPLDestroyXMLNode( psXSDTree );
if( aosClasses.size() > 0 )
{
return TRUE;
}
else
return FALSE;
}
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::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;
}
bool GMLParseXSD( const char *pszFile,
std::vector<GMLFeatureClass*> & aosClasses,
bool& bFullyUnderstood)
{
bFullyUnderstood = false;
if( pszFile == NULL )
return false;
/* -------------------------------------------------------------------- */
/* Load the raw XML file. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psXSDTree = GMLParseXMLFile( 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 include directive. */
/* ==================================================================== */
CPLXMLSchemaResolveInclude( pszFile, psSchemaNode );
//CPLSerializeXMLTreeToFile(psSchemaNode, "/vsistdout/");
bFullyUnderstood = true;
/* ==================================================================== */
/* Process each feature class definition. */
/* ==================================================================== */
CPLXMLNode *psThis = psSchemaNode->psChild;
for( ; 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") &&
!EQUAL(pszSubGroup, "AbstractFeature") /* AbstractFeature used by GML 3.2 */ )
{
continue;
}
/* -------------------------------------------------------------------- */
/* Get name */
/* -------------------------------------------------------------------- */
const char *pszName = CPLGetXMLValue( psThis, "name", NULL );
if( pszName == NULL )
{
continue;
}
/* -------------------------------------------------------------------- */
/* Get type and verify relationship with name. */
/* -------------------------------------------------------------------- */
const char *pszType = CPLGetXMLValue( psThis, "type", NULL );
if (pszType == NULL)
{
CPLXMLNode *psComplexType = CPLGetXMLNode( psThis, "complexType" );
if (psComplexType)
{
GMLFeatureClass* poClass =
GMLParseFeatureType(psSchemaNode, pszName, psComplexType);
if (poClass)
aosClasses.push_back(poClass);
else
bFullyUnderstood = false;
}
continue;
}
if( strstr( pszType, ":" ) != NULL )
pszType = strstr( pszType, ":" ) + 1;
if( EQUAL(pszType, pszName) )
{
/* A few WFS servers return a type name which is the element name */
/* without any _Type or Type suffix */
/* e.g. : http://apollo.erdas.com/erdas-apollo/vector/Cherokee?SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&TYPENAME=iwfs:Air */
}
/* <element name="RekisteriyksikonPalstanTietoja" type="ktjkiiwfs:PalstanTietojaType" substitutionGroup="gml:_Feature" /> */
else if( strlen(pszType) > 4 &&
strcmp(pszType + strlen(pszType) - 4, "Type") == 0 &&
strlen(pszName) > strlen(pszType) - 4 &&
strncmp(pszName + strlen(pszName) - (strlen(pszType) - 4),
pszType,
strlen(pszType) - 4) == 0 ) {
}
else if( !EQUALN(pszType,pszName,strlen(pszName))
|| !(EQUAL(pszType+strlen(pszName),"_Type") ||
EQUAL(pszType+strlen(pszName),"Type")) )
{
continue;
}
/* CanVec .xsd contains weird types that are not used in the related GML */
if (STARTS_WITH(pszName, "XyZz") ||
STARTS_WITH(pszName, "XyZ1") ||
STARTS_WITH(pszName, "XyZ2"))
continue;
GMLFeatureClass* poClass =
GMLParseFeatureType(psSchemaNode, pszName, pszType);
if (poClass)
aosClasses.push_back(poClass);
else
bFullyUnderstood = false;
}
CPLDestroyXMLNode( psXSDTree );
if( aosClasses.size() > 0 )
{
return true;
}
else
return false;
}
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;
}