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; }
int GMLFeatureClass::InitializeFromXML( CPLXMLNode *psRoot ) { /* -------------------------------------------------------------------- */ /* Do some rudimentary checking that this is a well formed */ /* node. */ /* -------------------------------------------------------------------- */ if( psRoot == NULL || psRoot->eType != CXT_Element || !EQUAL(psRoot->pszValue,"GMLFeatureClass") ) { CPLError( CE_Failure, CPLE_AppDefined, "GMLFeatureClass::InitializeFromXML() called on %s node!", psRoot->pszValue ); return FALSE; } if( CPLGetXMLValue( psRoot, "Name", NULL ) == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "GMLFeatureClass has no <Name> element." ); return FALSE; } /* -------------------------------------------------------------------- */ /* Collect base info. */ /* -------------------------------------------------------------------- */ CPLFree( m_pszName ); m_pszName = CPLStrdup( CPLGetXMLValue( psRoot, "Name", NULL ) ); n_nNameLen = strlen(m_pszName); SetElementName( CPLGetXMLValue( psRoot, "ElementPath", m_pszName ) ); /* -------------------------------------------------------------------- */ /* Collect geometry properties. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psThis; int bHasValidGeometryName = FALSE; int bHasValidGeometryElementPath = FALSE; int bHasFoundGeomType = FALSE; int bHasFoundGeomElements = FALSE; const char* pszGName = ""; const char* pszGPath = ""; int nGeomType = wkbUnknown; for( psThis = psRoot->psChild; psThis != NULL; psThis = psThis->psNext ) { if( psThis->eType == CXT_Element && EQUAL(psThis->pszValue, "GeomPropertyDefn") ) { const char *pszName = CPLGetXMLValue( psThis, "Name", "" ); const char *pszElementPath = CPLGetXMLValue( psThis, "ElementPath", "" ); const char *pszType = CPLGetXMLValue( psThis, "Type", NULL ); int bNullable = CSLTestBoolean(CPLGetXMLValue( psThis, "Nullable", "true") ); nGeomType = wkbUnknown; if( pszType != NULL && !EQUAL(pszType, "0") ) { nGeomType = atoi(pszType); OGRwkbGeometryType nFlattenGeomType = wkbFlatten(nGeomType); if( nGeomType != 0 && !(nFlattenGeomType >= wkbPoint && nFlattenGeomType <= wkbMultiSurface) ) { nGeomType = wkbUnknown; CPLError(CE_Warning, CPLE_AppDefined, "Unrecognised geometry type : %s", pszType); } else if( nGeomType == 0 ) nGeomType = OGRFromOGCGeomType(pszType); } bHasFoundGeomElements = TRUE; AddGeometryProperty( new GMLGeometryPropertyDefn( pszName, pszElementPath, nGeomType, -1, bNullable ) ); bHasValidGeometryName = FALSE; bHasValidGeometryElementPath = FALSE; bHasFoundGeomType = FALSE; } else if( psThis->eType == CXT_Element && strcmp(psThis->pszValue, "GeometryName") == 0 ) { bHasFoundGeomElements = TRUE; if( bHasValidGeometryName ) { AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) ); bHasValidGeometryName = FALSE; bHasValidGeometryElementPath = FALSE; bHasFoundGeomType = FALSE; pszGPath = ""; nGeomType = wkbUnknown; } pszGName = CPLGetXMLValue( psThis, NULL, "" ); bHasValidGeometryName = TRUE; } else if( psThis->eType == CXT_Element && strcmp(psThis->pszValue, "GeometryElementPath") == 0 ) { bHasFoundGeomElements = TRUE; if( bHasValidGeometryElementPath ) { AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) ); bHasValidGeometryName = FALSE; bHasValidGeometryElementPath = FALSE; bHasFoundGeomType = FALSE; pszGName = ""; nGeomType = wkbUnknown; } pszGPath = CPLGetXMLValue( psThis, NULL, "" ); bHasValidGeometryElementPath = TRUE; } else if( psThis->eType == CXT_Element && strcmp(psThis->pszValue, "GeometryType") == 0 ) { bHasFoundGeomElements = TRUE; if( bHasFoundGeomType ) { AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) ); bHasValidGeometryName = FALSE; bHasValidGeometryElementPath = FALSE; bHasFoundGeomType = FALSE; pszGName = ""; pszGPath = ""; nGeomType = wkbUnknown; } const char* pszGeometryType = CPLGetXMLValue( psThis, NULL, NULL ); nGeomType = wkbUnknown; if( pszGeometryType != NULL && !EQUAL(pszGeometryType, "0") ) { nGeomType = atoi(pszGeometryType); OGRwkbGeometryType nFlattenGeomType = wkbFlatten(nGeomType); if( nGeomType == 100 || EQUAL(pszGeometryType, "NONE") ) { bHasValidGeometryElementPath = FALSE; bHasFoundGeomType = FALSE; break; } else if( nGeomType != 0 && !(nFlattenGeomType >= wkbPoint && nFlattenGeomType <= wkbMultiSurface) ) { nGeomType = wkbUnknown; CPLError(CE_Warning, CPLE_AppDefined, "Unrecognised geometry type : %s", pszGeometryType); } else if( nGeomType == 0 ) nGeomType = OGRFromOGCGeomType(pszGeometryType); } bHasFoundGeomType = TRUE; } } /* If there was a dangling <GeometryElementPath> or <GeometryType> or */ /* that no explicit geometry information has been found, then add */ /* a geometry field */ if( bHasValidGeometryElementPath || bHasFoundGeomType || !bHasFoundGeomElements ) { AddGeometryProperty( new GMLGeometryPropertyDefn( pszGName, pszGPath, nGeomType, -1, TRUE ) ); } SetSRSName( CPLGetXMLValue( psRoot, "SRSName", NULL ) ); /* -------------------------------------------------------------------- */ /* Collect dataset specific info. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psDSI = CPLGetXMLNode( psRoot, "DatasetSpecificInfo" ); if( psDSI != NULL ) { const char *pszValue; pszValue = CPLGetXMLValue( psDSI, "FeatureCount", NULL ); if( pszValue != NULL ) SetFeatureCount( CPLAtoGIntBig(pszValue) ); // Eventually we should support XML subtrees. pszValue = CPLGetXMLValue( psDSI, "ExtraInfo", NULL ); if( pszValue != NULL ) SetExtraInfo( pszValue ); if( CPLGetXMLValue( psDSI, "ExtentXMin", NULL ) != NULL && CPLGetXMLValue( psDSI, "ExtentXMax", NULL ) != NULL && CPLGetXMLValue( psDSI, "ExtentYMin", NULL ) != NULL && CPLGetXMLValue( psDSI, "ExtentYMax", NULL ) != NULL ) { SetExtents( CPLAtof(CPLGetXMLValue( psDSI, "ExtentXMin", "0.0" )), CPLAtof(CPLGetXMLValue( psDSI, "ExtentXMax", "0.0" )), CPLAtof(CPLGetXMLValue( psDSI, "ExtentYMin", "0.0" )), CPLAtof(CPLGetXMLValue( psDSI, "ExtentYMax", "0.0" )) ); } } /* -------------------------------------------------------------------- */ /* Collect property definitions. */ /* -------------------------------------------------------------------- */ for( psThis = psRoot->psChild; psThis != NULL; psThis = psThis->psNext ) { if( psThis->eType == CXT_Element && EQUAL(psThis->pszValue, "PropertyDefn") ) { const char *pszName = CPLGetXMLValue( psThis, "Name", NULL ); const char *pszType = CPLGetXMLValue( psThis, "Type", "Untyped" ); const char *pszSubType = CPLGetXMLValue( psThis, "Subtype", "" ); const char *pszCondition = CPLGetXMLValue( psThis, "Condition", NULL ); int bNullable = CSLTestBoolean(CPLGetXMLValue( psThis, "Nullable", "true") ); GMLPropertyDefn *poPDefn; if( pszName == NULL ) { CPLError( CE_Failure, CPLE_AppDefined, "GMLFeatureClass %s has a PropertyDefn without a <Name>..", m_pszName ); return FALSE; } poPDefn = new GMLPropertyDefn( pszName, CPLGetXMLValue( psThis, "ElementPath", NULL ) ); poPDefn->SetNullable(bNullable); if( EQUAL(pszType,"Untyped") ) poPDefn->SetType( GMLPT_Untyped ); else if( EQUAL(pszType,"String") ) { if( EQUAL(pszSubType, "Boolean") ) { poPDefn->SetType( GMLPT_Boolean ); poPDefn->SetWidth( 1 ); } else { poPDefn->SetType( GMLPT_String ); poPDefn->SetWidth( atoi( CPLGetXMLValue( psThis, "Width", "0" ) ) ); } } else if( EQUAL(pszType,"Integer") ) { if( EQUAL(pszSubType, "Short") ) { poPDefn->SetType( GMLPT_Short ); } else if( EQUAL(pszSubType, "Integer64") ) { poPDefn->SetType( GMLPT_Integer64 ); } else { poPDefn->SetType( GMLPT_Integer ); } poPDefn->SetWidth( atoi( CPLGetXMLValue( psThis, "Width", "0" ) ) ); } else if( EQUAL(pszType,"Real") ) { if( EQUAL(pszSubType, "Float") ) { poPDefn->SetType( GMLPT_Float ); } else { poPDefn->SetType( GMLPT_Real ); } poPDefn->SetWidth( atoi( CPLGetXMLValue( psThis, "Width", "0" ) ) ); poPDefn->SetPrecision( atoi( CPLGetXMLValue( psThis, "Precision", "0" ) ) ); } else if( EQUAL(pszType,"StringList") ) { if( EQUAL(pszSubType, "Boolean") ) poPDefn->SetType( GMLPT_BooleanList ); else poPDefn->SetType( GMLPT_StringList ); } else if( EQUAL(pszType,"IntegerList") ) { if( EQUAL(pszSubType, "Integer64") ) poPDefn->SetType( GMLPT_Integer64List ); else poPDefn->SetType( GMLPT_IntegerList ); } else if( EQUAL(pszType,"RealList") ) poPDefn->SetType( GMLPT_RealList ); else if( EQUAL(pszType,"Complex") ) poPDefn->SetType( GMLPT_Complex ); else if( EQUAL(pszType,"FeatureProperty") ) poPDefn->SetType( GMLPT_FeatureProperty ); else if( EQUAL(pszType,"FeaturePropertyList") ) poPDefn->SetType( GMLPT_FeaturePropertyList ); else { CPLError( CE_Failure, CPLE_AppDefined, "Unrecognised property type %s.", pszType ); delete poPDefn; return FALSE; } if( pszCondition != NULL ) poPDefn->SetCondition(pszCondition); AddProperty( poPDefn ); } } return TRUE; }