/****************************************************************************** * Project: OGR * Purpose: OGRGMLASDriver implementation * Author: Even Rouault, * * Initial development funded by the European Earth observation programme * Copernicus * ****************************************************************************** * Copyright (c) 2016, Even Rouault, * * SPDX-License-Identifier: MIT ****************************************************************************/ #include "xercesc_headers.h" // Hack to avoid bool, possibly redefined to pedantic bool class, being later // used static XSModel *getGrammarPool(XMLGrammarPool *pool) { bool changed; return pool->getXSModel(changed); } #include "ogr_gmlas.h" #include "ogr_pgdump.h" #include static OGRwkbGeometryType GetOGRGeometryType(XSTypeDefinition *poTypeDef); /************************************************************************/ /* IsCompatibleOfArray() */ /************************************************************************/ static bool IsCompatibleOfArray(GMLASFieldType eType) { return eType == GMLAS_FT_STRING || eType == GMLAS_FT_BOOLEAN || eType == GMLAS_FT_SHORT || eType == GMLAS_FT_INT32 || eType == GMLAS_FT_INT64 || eType == GMLAS_FT_FLOAT || eType == GMLAS_FT_DOUBLE || eType == GMLAS_FT_DECIMAL || eType == GMLAS_FT_ANYURI; } /************************************************************************/ /* GMLASPrefixMappingHander */ /************************************************************************/ class GMLASPrefixMappingHander : public DefaultHandler { std::map &m_oMapURIToPrefix; const std::map &m_oMapDocNSURIToPrefix; CPLString &m_osGMLVersionFound; public: GMLASPrefixMappingHander( std::map &oMapURIToPrefix, const std::map &oMapDocNSURIToPrefix, CPLString &osGMLVersionFound) : m_oMapURIToPrefix(oMapURIToPrefix), m_oMapDocNSURIToPrefix(oMapDocNSURIToPrefix), m_osGMLVersionFound(osGMLVersionFound) { } virtual void startElement(const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname, const Attributes &attrs) override; virtual void startPrefixMapping(const XMLCh *const prefix, const XMLCh *const uri) override; }; /************************************************************************/ /* startElement() */ /************************************************************************/ void GMLASPrefixMappingHander::startElement(const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const /*qname*/, const Attributes &attrs) { if (!m_osGMLVersionFound.empty()) return; const CPLString osURI(transcode(uri)); const CPLString osLocalname(transcode(localname)); if (osURI == szXS_URI && osLocalname == "schema") { bool bIsGML = false; std::string osVersion; for (unsigned int i = 0; i < attrs.getLength(); i++) { const std::string osAttrLocalName(transcode(attrs.getLocalName(i))); if (osAttrLocalName == "targetNamespace") { bIsGML = transcode(attrs.getValue(i)) == szGML_URI; } else if (osAttrLocalName == "version") { osVersion = transcode(attrs.getValue(i)); } } if (bIsGML && !osVersion.empty()) { m_osGMLVersionFound = std::move(osVersion); } } } /************************************************************************/ /* startPrefixMapping() */ /************************************************************************/ void GMLASPrefixMappingHander::startPrefixMapping(const XMLCh *const prefix, const XMLCh *const uri) { const CPLString osURI(transcode(uri)); CPLString osPrefix(transcode(prefix)); if (osPrefix.empty()) { const auto oIter = m_oMapDocNSURIToPrefix.find(osURI); if (oIter != m_oMapDocNSURIToPrefix.end()) { osPrefix = oIter->second; } } if (!osPrefix.empty()) { const auto oIter = m_oMapURIToPrefix.find(osURI); if (oIter == m_oMapURIToPrefix.end()) { m_oMapURIToPrefix[osURI] = osPrefix; CPLDebug("GMLAS", "Registering prefix=%s for uri=%s", osPrefix.c_str(), osURI.c_str()); } else if (oIter->second != osPrefix) { CPLDebug("GMLAS", "Existing prefix=%s for uri=%s (new prefix %s not used)", oIter->second.c_str(), osURI.c_str(), osPrefix.c_str()); } } } /************************************************************************/ /* CollectNamespacePrefixes() */ /************************************************************************/ static void CollectNamespacePrefixes( const char *pszXSDFilename, const std::shared_ptr &fpXSD, std::map &oMapURIToPrefix, const std::map &oMapDocNSURIToPrefix, CPLString &osGMLVersionFound) { GMLASInputSource oSource(pszXSDFilename, fpXSD); // This is a bit silly but the startPrefixMapping() callback only gets // called when using SAX2XMLReader::parse(), and not when using // loadGrammar(), so we have to parse the doc twice. SAX2XMLReader *poReader = XMLReaderFactory::createXMLReader(); GMLASPrefixMappingHander contentHandler( oMapURIToPrefix, oMapDocNSURIToPrefix, osGMLVersionFound); poReader->setContentHandler(&contentHandler); GMLASErrorHandler oErrorHandler; poReader->setErrorHandler(&oErrorHandler); poReader->setFeature(XMLUni::fgXercesDisableDefaultEntityResolution, true); std::string osErrorMsg; try { poReader->parse(oSource); } catch (const SAXException &e) { osErrorMsg += transcode(e.getMessage()); } catch (const XMLException &e) { osErrorMsg += transcode(e.getMessage()); } catch (const OutOfMemoryException &e) { if (strstr(CPLGetLastErrorMsg(), "configuration option") == nullptr) { osErrorMsg += transcode(e.getMessage()); } } catch (const DOMException &e) { osErrorMsg += transcode(e.getMessage()); } if (!osErrorMsg.empty()) { CPLError(CE_Failure, CPLE_AppDefined, "%s", osErrorMsg.c_str()); } delete poReader; } /************************************************************************/ /* GMLASAnalyzerEntityResolver */ /************************************************************************/ class GMLASAnalyzerEntityResolver final : public GMLASBaseEntityResolver { std::map &m_oMapURIToPrefix; const std::map &m_oMapDocNSURIToPrefix; public: GMLASAnalyzerEntityResolver( const CPLString &osBasePath, std::map &oMapURIToPrefix, const std::map &oMapDocNSURIToPrefix, GMLASXSDCache &oCache) : GMLASBaseEntityResolver(osBasePath, oCache), m_oMapURIToPrefix(oMapURIToPrefix), m_oMapDocNSURIToPrefix(oMapDocNSURIToPrefix) { } virtual void DoExtraSchemaProcessing( const CPLString &osFilename, const std::shared_ptr &fp) override; }; /************************************************************************/ /* DoExtraSchemaProcessing() */ /************************************************************************/ void GMLASAnalyzerEntityResolver::DoExtraSchemaProcessing( const CPLString &osFilename, const std::shared_ptr &fp) { CollectNamespacePrefixes(osFilename, fp, m_oMapURIToPrefix, m_oMapDocNSURIToPrefix, m_osGMLVersionFound); fp->Seek(0, SEEK_SET); } /************************************************************************/ /* GMLASSchemaAnalyzer() */ /************************************************************************/ GMLASSchemaAnalyzer::GMLASSchemaAnalyzer( GMLASXPathMatcher &oIgnoredXPathMatcher, GMLASXPathMatcher &oChildrenElementsConstraintsXPathMatcher, const std::map> &oMapChildrenElementsConstraints, GMLASXPathMatcher &oForcedFlattenedXPathMatcher, GMLASXPathMatcher &oDisabledFlattenedXPathMatcher) : m_oIgnoredXPathMatcher(oIgnoredXPathMatcher), m_oChildrenElementsConstraintsXPathMatcher( oChildrenElementsConstraintsXPathMatcher), m_oForcedFlattenedXPathMatcher(oForcedFlattenedXPathMatcher), m_oDisabledFlattenedXPathMatcher(oDisabledFlattenedXPathMatcher), m_oMapChildrenElementsConstraints(oMapChildrenElementsConstraints), m_bUseArrays(true), m_bUseNullState(false), m_bInstantiateGMLFeaturesOnly(true), m_nIdentifierMaxLength(0), m_bCaseInsensitiveIdentifier(CASE_INSENSITIVE_IDENTIFIER_DEFAULT), m_bPGIdentifierLaundering(PG_IDENTIFIER_LAUNDERING_DEFAULT), m_nMaximumFieldsForFlattening(MAXIMUM_FIELDS_FLATTENING_DEFAULT), m_bAlwaysGenerateOGRId(ALWAYS_GENERATE_OGR_ID_DEFAULT) { // A few hardcoded namespace uri->prefix mappings m_oMapURIToPrefix[szXMLNS_URI] = szXMLNS_PREFIX; m_oMapURIToPrefix[szXSI_URI] = szXSI_PREFIX; } /************************************************************************/ /* GetPrefix() */ /************************************************************************/ CPLString GMLASSchemaAnalyzer::GetPrefix(const CPLString &osNamespaceURI) { if (osNamespaceURI.empty()) return ""; const auto oIter = m_oMapURIToPrefix.find(osNamespaceURI); if (oIter != m_oMapURIToPrefix.end()) return oIter->second; else if (!osNamespaceURI.empty()) { // If the schema doesn't define a xmlns:MYPREFIX=myuri, then forge a // fake prefix for conveniency CPLString osPrefix; if (osNamespaceURI.find(szOPENGIS_URL) == 0) osPrefix = osNamespaceURI.substr(strlen(szOPENGIS_URL)); else if (osNamespaceURI.find("http://") == 0) osPrefix = osNamespaceURI.substr(strlen("http://")); else osPrefix = osNamespaceURI; for (size_t i = 0; i < osPrefix.size(); i++) { if (!isalnum(static_cast(osPrefix[i]))) osPrefix[i] = '_'; } m_oMapURIToPrefix[osNamespaceURI] = osPrefix; CPLDebug("GMLAS", "Cannot find prefix for ns='%s'. Forging %s", osNamespaceURI.c_str(), osPrefix.c_str()); return osPrefix; } else { CPLDebug("GMLAS", "Cannot find prefix for ns='%s'.", osNamespaceURI.c_str()); return ""; } } /************************************************************************/ /* MakeXPath() */ /************************************************************************/ CPLString GMLASSchemaAnalyzer::MakeXPath(const CPLString &osNamespaceURI, const CPLString &osName) { const CPLString osPrefix(GetPrefix(osNamespaceURI)); if (osPrefix.empty()) return osName; return osPrefix + ":" + osName; } /************************************************************************/ /* GetNSOfLastXPathComponent() */ /************************************************************************/ // Return the namespace (if any) of the last component of the XPath static CPLString GetNSOfLastXPathComponent(const CPLString &osXPath) { size_t nPos = osXPath.rfind('@'); if (nPos != std::string::npos) nPos++; else { nPos = osXPath.rfind('/'); if (nPos != std::string::npos) nPos++; else nPos = 0; } size_t nPosColumn = osXPath.find(':', nPos); if (nPosColumn == std::string::npos) return CPLString(); return CPLString(osXPath.substr(nPos, nPosColumn - nPos)); } /************************************************************************/ /* LaunderFieldNames() */ /************************************************************************/ // Make sure that field names are unique within the class bool GMLASSchemaAnalyzer::LaunderFieldNames(GMLASFeatureClass &oClass) { std::vector &aoFields = oClass.GetFields(); // Duplicates can happen if a class has both an element and an attribute // with same name, and/or attributes/elements with same name in different // namespaces. // Detect duplicated field names std::map> oMapNameToFieldIndex; for (int i = 0; i < static_cast(aoFields.size()); i++) { if (aoFields[i].GetCategory() == GMLASField::REGULAR) { oMapNameToFieldIndex[aoFields[i].GetName()].push_back(i); } } std::set oSetDuplicates; for (const auto &oIter : oMapNameToFieldIndex) { // Has it duplicates ? const size_t nOccurrences = oIter.second.size(); if (nOccurrences > 1) { oSetDuplicates.insert(oIter.first); } } while (!oSetDuplicates.empty()) { // Iterate over the unique names auto oIterSet = oSetDuplicates.begin(); while (oIterSet != oSetDuplicates.end()) { auto oIterSetNext = oIterSet; ++oIterSetNext; auto oIterMap = oMapNameToFieldIndex.find(*oIterSet); CPLAssert(oIterMap != oMapNameToFieldIndex.end()); auto &list = oIterMap->second; const CPLString oClassNS = GetNSOfLastXPathComponent(oClass.GetXPath()); bool bHasDoneRenamingForThatCase = false; auto oIterList = list.begin(); // Update oMapNameToFieldIndex and oSetDuplicates with the // new field name, and removing the old one. const auto updateSetAndMapWithNewName = [&oIterList, &list, &oMapNameToFieldIndex, &oSetDuplicates](int nFieldIdx, const std::string &osNewName) { list.erase(oIterList); auto &newList = oMapNameToFieldIndex[osNewName]; newList.push_back(nFieldIdx); if (newList.size() > 1) oSetDuplicates.insert(osNewName); }; while (oIterList != list.end()) { auto oIterListNext = oIterList; ++oIterListNext; const int nFieldIdx = *oIterList; GMLASField &oField = aoFields[nFieldIdx]; // CPLDebug("GMLAS", "%s", oField.GetXPath().c_str() ); const CPLString oNS( GetNSOfLastXPathComponent(oField.GetXPath())); // If the field has a namespace that is not the one of its // class, then prefix its name with its namespace if (!oNS.empty() && oNS != oClassNS && !STARTS_WITH(oField.GetName(), (oNS + "_").c_str())) { bHasDoneRenamingForThatCase = true; const auto osNewName = oNS + "_" + oField.GetName(); oField.SetName(osNewName); updateSetAndMapWithNewName(nFieldIdx, osNewName); break; } // If it is an attribute without a particular namespace, // then suffix with _attr else if (oNS.empty() && oField.GetXPath().find('@') != std::string::npos && oField.GetName().find("_attr") == std::string::npos) { bHasDoneRenamingForThatCase = true; const auto osNewName = oField.GetName() + "_attr"; oField.SetName(osNewName); updateSetAndMapWithNewName(nFieldIdx, osNewName); break; } oIterList = oIterListNext; } // If none of the above renaming strategies have worked, then // append a counter to the duplicates. if (!bHasDoneRenamingForThatCase) { int i = 0; oIterList = list.begin(); while (oIterList != list.end()) { auto oIterListNext = oIterList; ++oIterListNext; const int nFieldIdx = *oIterList; GMLASField &oField = aoFields[nFieldIdx]; if (i > 0) { const auto osNewName = oField.GetName() + CPLSPrintf("%d", static_cast(i) + 1); oField.SetName(osNewName); updateSetAndMapWithNewName(nFieldIdx, osNewName); } ++i; oIterList = oIterListNext; } } // Update oSetDuplicates and oMapNameToFieldIndex if we have // no longer duplicates for the current name if (list.size() <= 1) { if (list.empty()) { oMapNameToFieldIndex.erase(oIterMap); } oSetDuplicates.erase(oIterSet); } oIterSet = oIterSetNext; } } #ifdef DEBUG { // Check that the above algorithm managed to deduplicate names std::set oSetNames; for (const auto &oField : aoFields) { if (oField.GetCategory() == GMLASField::REGULAR) { const auto &osName = oField.GetName(); CPLAssert(oSetNames.find(osName) == oSetNames.end()); oSetNames.insert(osName); } } } #endif // Now check if we must truncate names if (m_nIdentifierMaxLength >= MIN_VALUE_OF_MAX_IDENTIFIER_LENGTH) { for (size_t i = 0; i < aoFields.size(); i++) { int nNameSize = static_cast(aoFields[i].GetName().size()); /* Somewhat arbitrary limitation to avoid performance issues in */ /* OGRGMLASTruncateIdentifier() */ if (nNameSize > 1024) { CPLError(CE_Failure, CPLE_NotSupported, "Field name with excessive length (%d) found", nNameSize); return false; } if (nNameSize > m_nIdentifierMaxLength) { aoFields[i].SetName(OGRGMLASTruncateIdentifier( aoFields[i].GetName(), m_nIdentifierMaxLength)); } } } if (m_bPGIdentifierLaundering) { for (size_t i = 0; i < aoFields.size(); i++) { char *pszLaundered = OGRPGCommonLaunderName(aoFields[i].GetName(), "GMLAS", false); aoFields[i].SetName(pszLaundered); CPLFree(pszLaundered); } } // Detect duplicated field names std::map> oSetNames; for (int i = 0; i < static_cast(aoFields.size()); i++) { if (aoFields[i].GetCategory() == GMLASField::REGULAR) { CPLString osName(aoFields[i].GetName()); if (m_bCaseInsensitiveIdentifier) osName.toupper(); oSetNames[osName].push_back(i); } } // Iterate over the unique names for (const auto &oIter : oSetNames) { // Has it duplicates ? const size_t nOccurrences = oIter.second.size(); if (nOccurrences > 1) { for (size_t i = 0; i < nOccurrences; i++) { GMLASField &oField = aoFields[oIter.second[i]]; oField.SetName(OGRGMLASAddSerialNumber( oField.GetName(), static_cast(i + 1), nOccurrences, m_nIdentifierMaxLength)); } } } // Recursively process nested classes std::vector &aoNestedClasses = oClass.GetNestedClasses(); for (size_t i = 0; i < aoNestedClasses.size(); i++) { if (!LaunderFieldNames(aoNestedClasses[i])) return false; } return true; } /************************************************************************/ /* CollectClassesReferences() */ /************************************************************************/ void GMLASSchemaAnalyzer::CollectClassesReferences( GMLASFeatureClass &oClass, std::vector &aoClasses) { aoClasses.push_back(&oClass); std::vector &aoNestedClasses = oClass.GetNestedClasses(); for (size_t i = 0; i < aoNestedClasses.size(); i++) { CollectClassesReferences(aoNestedClasses[i], aoClasses); } } /************************************************************************/ /* LaunderClassNames() */ /************************************************************************/ void GMLASSchemaAnalyzer::LaunderClassNames() { std::vector aoClasses; for (size_t i = 0; i < m_aoClasses.size(); i++) { CollectClassesReferences(m_aoClasses[i], aoClasses); } if (m_nIdentifierMaxLength >= MIN_VALUE_OF_MAX_IDENTIFIER_LENGTH) { for (size_t i = 0; i < aoClasses.size(); i++) { int nNameSize = static_cast(aoClasses[i]->GetName().size()); if (nNameSize > m_nIdentifierMaxLength) { aoClasses[i]->SetName(OGRGMLASTruncateIdentifier( aoClasses[i]->GetName(), m_nIdentifierMaxLength)); } } } if (m_bPGIdentifierLaundering) { for (size_t i = 0; i < aoClasses.size(); i++) { char *pszLaundered = OGRPGCommonLaunderName(aoClasses[i]->GetName(), "GMLAS", false); aoClasses[i]->SetName(pszLaundered); CPLFree(pszLaundered); } } // Detect duplicated names. This should normally not happen in normal // conditions except if you have classes like // prefix_foo, prefix:foo, other_prefix:foo // or if names have been truncated in the previous step std::map> oSetNames; for (int i = 0; i < static_cast(aoClasses.size()); i++) { CPLString osName(aoClasses[i]->GetName()); if (m_bCaseInsensitiveIdentifier) osName.toupper(); oSetNames[osName].push_back(i); } // Iterate over the unique names for (const auto &oIter : oSetNames) { // Has it duplicates ? const size_t nOccurrences = oIter.second.size(); if (nOccurrences > 1) { for (size_t i = 0; i < nOccurrences; i++) { GMLASFeatureClass *poClass = aoClasses[oIter.second[i]]; poClass->SetName(OGRGMLASAddSerialNumber( poClass->GetName(), static_cast(i + 1), nOccurrences, m_nIdentifierMaxLength)); } } } } /************************************************************************/ /* GMLASUniquePtr() */ /************************************************************************/ // Poor-man std::unique_ptr template class GMLASUniquePtr { T *m_p; GMLASUniquePtr(const GMLASUniquePtr &); GMLASUniquePtr &operator=(const GMLASUniquePtr &); public: explicit GMLASUniquePtr(T *p) : m_p(p) { } ~GMLASUniquePtr() { delete m_p; } T *operator->() const { CPLAssert(m_p); return m_p; } T *get() const { return m_p; } T *release() { T *ret = m_p; m_p = NULL; return ret; } }; /************************************************************************/ /* GetTopElementDeclarationFromXPath() */ /************************************************************************/ XSElementDeclaration * GMLASSchemaAnalyzer::GetTopElementDeclarationFromXPath(const CPLString &osXPath, XSModel *poModel) { const char *pszTypename = osXPath.c_str(); const char *pszColon = strrchr(pszTypename, ':'); XSElementDeclaration *poEltDecl = nullptr; if (pszColon != nullptr) { CPLString osNSPrefix = pszTypename; osNSPrefix.resize(pszColon - pszTypename); CPLString osName = pszColon + 1; CPLString osNSURI; for (const auto &oIterNS : m_oMapURIToPrefix) { const CPLString &osIterNSURI(oIterNS.first); const CPLString &osIterNSPrefix(oIterNS.second); if (osNSPrefix == osIterNSPrefix) { osNSURI = osIterNSURI; break; } } XMLCh *xmlNS = nullptr; XMLCh *xmlName = nullptr; try { xmlNS = XMLString::transcode(osNSURI); xmlName = XMLString::transcode(osName); poEltDecl = poModel->getElementDeclaration(xmlName, xmlNS); } catch (const TranscodingException &e) { CPLError(CE_Failure, CPLE_AppDefined, "TranscodingException: %s", transcode(e.getMessage()).c_str()); } XMLString::release(&xmlNS); XMLString::release(&xmlName); } else { try { XMLCh *xmlName = XMLString::transcode(pszTypename); poEltDecl = poModel->getElementDeclaration(xmlName, nullptr); XMLString::release(&xmlName); } catch (const TranscodingException &e) { CPLError(CE_Failure, CPLE_AppDefined, "TranscodingException: %s", transcode(e.getMessage()).c_str()); } } return poEltDecl; } /************************************************************************/ /* IsEltCompatibleOfFC() */ /************************************************************************/ static XSComplexTypeDefinition * IsEltCompatibleOfFC(XSElementDeclaration *poEltDecl) { XSTypeDefinition *poTypeDef = poEltDecl->getTypeDefinition(); if (poTypeDef->getTypeCategory() == XSTypeDefinition::COMPLEX_TYPE && transcode(poEltDecl->getName()) != szFEATURE_COLLECTION) { XSComplexTypeDefinition *poCT = reinterpret_cast(poTypeDef); XSComplexTypeDefinition::CONTENT_TYPE eContentType( poCT->getContentType()); if (eContentType == XSComplexTypeDefinition::CONTENTTYPE_ELEMENT || eContentType == XSComplexTypeDefinition::CONTENTTYPE_MIXED) { return poCT; } } return nullptr; } /************************************************************************/ /* DerivesFromGMLFeature() */ /************************************************************************/ bool GMLASSchemaAnalyzer::DerivesFromGMLFeature(XSElementDeclaration *poEltDecl) { XSElementDeclaration *poIter = poEltDecl; while (true) { XSElementDeclaration *poSubstGroup = poIter->getSubstitutionGroupAffiliation(); if (poSubstGroup == nullptr) break; const CPLString osSubstNS(transcode(poSubstGroup->getNamespace())); const CPLString osSubstName(transcode(poSubstGroup->getName())); if (IsGMLNamespace(osSubstNS) && osSubstName == "_FeatureCollection") { return false; } if (IsGMLNamespace(osSubstNS) && (osSubstName == "AbstractFeature" || osSubstName == "_Feature")) { return true; } poIter = poSubstGroup; } return false; } /************************************************************************/ /* Analyze() */ /************************************************************************/ bool GMLASSchemaAnalyzer::Analyze(GMLASXSDCache &oCache, const CPLString &osBaseDirname, std::vector &aoXSDs, bool bSchemaFullChecking, bool bHandleMultipleImports) { GMLASUniquePtr poGrammarPool( (new XMLGrammarPoolImpl(XMLPlatformUtils::fgMemoryManager))); std::vector aoNamespaces; GMLASAnalyzerEntityResolver oXSDEntityResolver( CPLString(), m_oMapURIToPrefix, m_oMapDocNSURIToPrefix, oCache); // In this first pass we load the schemas that are directly pointed by // the user with the XSD open option, or that we found in the // xsi:schemaLocation attribute The namespaces of those schemas are the // "first choice" namespaces from which we will try to find elements to turn // them into layers aoNamespaces.push_back(""); for (size_t i = 0; i < aoXSDs.size(); i++) { const CPLString osURI(aoXSDs[i].first); const CPLString osXSDFilename(aoXSDs[i].second); GMLASUniquePtr poParser( XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager, poGrammarPool.get())); // Commonly useful configuration. // poParser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true); poParser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes, true); poParser->setFeature(XMLUni::fgSAX2CoreValidation, true); // Enable validation. // poParser->setFeature(XMLUni::fgXercesSchema, true); // coverity[unsafe_xml_parse_config] poParser->setFeature(XMLUni::fgXercesValidationErrorAsFatal, false); // Use the loaded grammar during parsing. // poParser->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, true); // Don't load schemas from any other source (e.g., from XML document's // xsi:schemaLocation attributes). // poParser->setFeature(XMLUni::fgXercesLoadSchema, false); poParser->setFeature(XMLUni::fgXercesDisableDefaultEntityResolution, true); Grammar *poGrammar = nullptr; if (!GMLASReader::LoadXSDInParser( poParser.get(), oCache, oXSDEntityResolver, osBaseDirname, osXSDFilename, &poGrammar, bSchemaFullChecking, bHandleMultipleImports)) { return false; } // Some .xsd like // http://www.opengis.net/gwml-main/2.1 -> // https://wfspoc.brgm-rec.fr/constellation/WS/wfs/BRGM:GWML2?request=DescribeFeatureType&version=2.0.0&service=WFS&namespace=xmlns(ns1=http://www.opengis.net/gwml-main/2.1)&typenames=ns1:GW_Aquifer // do not have a declared targetNamespace, so use the one of the // schemaLocation if the grammar returns an empty namespace. CPLString osGrammarURI(transcode(poGrammar->getTargetNamespace())); if (osGrammarURI.empty()) { if (!osURI.empty()) osGrammarURI = osURI; } if (!osGrammarURI.empty()) { // Patch back the aoXSDs element in case we didn't know the // namespace URI initially if (osURI.empty()) aoXSDs[i].first = osGrammarURI; aoNamespaces.push_back(osGrammarURI); } } m_osGMLVersionFound = oXSDEntityResolver.GetGMLVersionFound(); m_oSetSchemaURLs = oXSDEntityResolver.GetSchemaURLS(); m_oIgnoredXPathMatcher.SetDocumentMapURIToPrefix(m_oMapURIToPrefix); m_oChildrenElementsConstraintsXPathMatcher.SetDocumentMapURIToPrefix( m_oMapURIToPrefix); m_oForcedFlattenedXPathMatcher.SetDocumentMapURIToPrefix(m_oMapURIToPrefix); m_oDisabledFlattenedXPathMatcher.SetDocumentMapURIToPrefix( m_oMapURIToPrefix); XSModel *poModel = getGrammarPool(poGrammarPool.get()); CPLAssert(poModel); // should not be null according to doc #if 0 XSNamespaceItem* nsItem = poModel->getNamespaceItem( loadedGrammar->getTargetNamespace()); if( nsItem == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "getNamespaceItem(%s) failed", transcode(loadedGrammar->getTargetNamespace()).c_str()); return false; } #endif bool bFoundGMLFeature = false; // Second pass, in all namespaces, to figure out inheritance relationships // and group models that have names std::map oMapURIToPrefixWithEmpty(m_oMapURIToPrefix); oMapURIToPrefixWithEmpty[""] = ""; for (const auto &oIterNS : oMapURIToPrefixWithEmpty) { const CPLString &osNSURI(oIterNS.first); if (osNSURI == szXS_URI || osNSURI == szXSI_URI || osNSURI == szXMLNS_URI || osNSURI == szXLINK_URI) { continue; } XMLCh *xmlNamespace = nullptr; try { xmlNamespace = XMLString::transcode(osNSURI.c_str()); } catch (const TranscodingException &e) { CPLError(CE_Failure, CPLE_AppDefined, "TranscodingException: %s", transcode(e.getMessage()).c_str()); return false; } XSNamedMap *poMapModelGroupDefinition = poModel->getComponentsByNamespace( XSConstants::MODEL_GROUP_DEFINITION, xmlNamespace); // Remember group models that have names for (XMLSize_t i = 0; poMapModelGroupDefinition != nullptr && i < poMapModelGroupDefinition->getLength(); i++) { XSModelGroupDefinition *modelGroupDefinition = reinterpret_cast( poMapModelGroupDefinition->item(i)); m_oMapModelGroupToMGD[modelGroupDefinition->getModelGroup()] = modelGroupDefinition; } CPLDebug("GMLAS", "Discovering substitutions of %s (%s)", oIterNS.second.c_str(), osNSURI.c_str()); XSNamedMap *poMapElements = poModel->getComponentsByNamespace( XSConstants::ELEMENT_DECLARATION, xmlNamespace); for (XMLSize_t i = 0; poMapElements != nullptr && i < poMapElements->getLength(); i++) { XSElementDeclaration *poEltDecl = reinterpret_cast( poMapElements->item(i)); XSElementDeclaration *poSubstGroup = poEltDecl->getSubstitutionGroupAffiliation(); const CPLString osEltXPath( MakeXPath(transcode(poEltDecl->getNamespace()), transcode(poEltDecl->getName()))); m_oMapXPathToEltDecl[osEltXPath] = poEltDecl; if (poSubstGroup) { m_oMapParentEltToChildElt[poSubstGroup].push_back(poEltDecl); #ifdef DEBUG_VERBOSE CPLString osParentType( MakeXPath(transcode(poSubstGroup->getNamespace()), transcode(poSubstGroup->getName()))); CPLDebug("GMLAS", "%s is a substitution for %s", osEltXPath.c_str(), osParentType.c_str()); #endif // Check if this element derives from // gml:_Feature/AbstractFeature if (!bFoundGMLFeature && m_bInstantiateGMLFeaturesOnly && !IsGMLNamespace(osNSURI) && DerivesFromGMLFeature(poEltDecl)) { CPLDebug("GMLAS", "Restricting (in first pass) top level " "elements to those deriving from " "gml:_Feature/gml:AbstractFeature (due " "to %s found)", osEltXPath.c_str()); bFoundGMLFeature = true; } } } XMLString::release(&xmlNamespace); } // Check that we can find elements in the namespaces pointed in the // xsi:schemaLocation of the document, then fallback to namespaces // that might be indirectly imported by those first level namespaces bool bFoundElementsInFirstChoiceNamespaces = false; for (size_t iNS = 0; !bFoundElementsInFirstChoiceNamespaces && iNS < aoNamespaces.size(); iNS++) { XMLCh *xmlNamespace = nullptr; try { xmlNamespace = XMLString::transcode(aoNamespaces[iNS].c_str()); } catch (const TranscodingException &e) { CPLError(CE_Failure, CPLE_AppDefined, "TranscodingException: %s", transcode(e.getMessage()).c_str()); return false; } XSNamedMap *poMapElements = poModel->getComponentsByNamespace( XSConstants::ELEMENT_DECLARATION, xmlNamespace); bFoundElementsInFirstChoiceNamespaces = poMapElements != nullptr && poMapElements->getLength() > 0; XMLString::release(&xmlNamespace); } if (!bFoundElementsInFirstChoiceNamespaces) { CPLDebug("GMLAS", "Did not find element in 'first choice' namespaces. " "Falling back to the namespaces they import"); aoNamespaces.clear(); for (const auto &oIterNS : oMapURIToPrefixWithEmpty) { const CPLString &osNSURI(oIterNS.first); if (osNSURI == szXS_URI || osNSURI == szXSI_URI || osNSURI == szXMLNS_URI || osNSURI == szXLINK_URI || osNSURI == szWFS_URI || osNSURI == szWFS20_URI || osNSURI == szGML_URI || osNSURI == szGML32_URI) { // Skip all boring namespaces continue; } aoNamespaces.push_back(osNSURI); } } // Find which elements must be top levels (because referenced several // times) std::set oSetVisitedEltDecl; std::set oSetVisitedModelGroups; std::vector oVectorEltsForTopClass; // For some reason, different XSElementDeclaration* can point to the // same element, but we only want to instantiate a single class. // This is the case for base:SpatialDataSet in // inspire/geologicalunit/geologicalunit.gml test dataset. std::set aoSetXPathEltsForTopClass; // Third and fourth passes for (int iPass = 0; iPass < 2; ++iPass) { for (size_t iNS = 0; iNS < aoNamespaces.size(); iNS++) { XMLCh *xmlNamespace = nullptr; try { xmlNamespace = XMLString::transcode(aoNamespaces[iNS].c_str()); } catch (const TranscodingException &e) { CPLError(CE_Failure, CPLE_AppDefined, "TranscodingException: %s", transcode(e.getMessage()).c_str()); return false; } XSNamedMap *poMapElements = poModel->getComponentsByNamespace( XSConstants::ELEMENT_DECLARATION, xmlNamespace); for (XMLSize_t i = 0; poMapElements != nullptr && i < poMapElements->getLength(); i++) { XSElementDeclaration *poEltDecl = reinterpret_cast( poMapElements->item(i)); XSComplexTypeDefinition *poCT = IsEltCompatibleOfFC(poEltDecl); if (!poEltDecl->getAbstract() && poCT != nullptr) { const CPLString osXPath( MakeXPath(transcode(poEltDecl->getNamespace()), transcode(poEltDecl->getName()))); if (!IsIgnoredXPath(osXPath)) { if (bFoundGMLFeature && m_bInstantiateGMLFeaturesOnly && !DerivesFromGMLFeature(poEltDecl)) { // Do nothing } else if (iPass == 0) { #ifdef DEBUG_VERBOSE CPLDebug( "GMLAS", "%s (%s) must be exposed as " "top-level (is top level in imported schemas)", osXPath.c_str(), transcode( poEltDecl->getTypeDefinition()->getName()) .c_str()); #endif oSetVisitedEltDecl.insert(poEltDecl); if (aoSetXPathEltsForTopClass.find(osXPath) == aoSetXPathEltsForTopClass.end()) { m_oSetEltsForTopClass.insert(poEltDecl); oVectorEltsForTopClass.push_back(poEltDecl); aoSetXPathEltsForTopClass.insert(osXPath); } } else { bool bSimpleEnoughOut = true; int nSubCountSubEltOut = 0; auto poParticle = poCT->getParticle(); if (poParticle) { CPL_IGNORE_RET_VAL( FindElementsWithMustBeToLevel( osXPath, poParticle->getModelGroupTerm(), 0, oSetVisitedEltDecl, oSetVisitedModelGroups, oVectorEltsForTopClass, aoSetXPathEltsForTopClass, poModel, bSimpleEnoughOut, nSubCountSubEltOut)); } } } } } XMLString::release(&xmlNamespace); } } // Find ambiguous class names { for (const auto &oIter : m_oSetEltsForTopClass) { CPLString osName(transcode(oIter->getName())); m_oMapEltNamesToInstanceCount[osName]++; } } // Instantiate all needed typenames for (const auto &poEltDecl : oVectorEltsForTopClass) { const CPLString osXPath(MakeXPath(transcode(poEltDecl->getNamespace()), transcode(poEltDecl->getName()))); bool bError = false; bool bResolvedType = InstantiateClassFromEltDeclaration(poEltDecl, poModel, bError); if (bError) { return false; } if (!bResolvedType) { CPLError( CE_Failure, CPLE_AppDefined, "Couldn't resolve %s (%s)", osXPath.c_str(), transcode(poEltDecl->getTypeDefinition()->getName()).c_str()); return false; } } LaunderClassNames(); return true; } /************************************************************************/ /* GetAnnotationDoc() */ /************************************************************************/ static CPLString GetAnnotationDoc(const XSAnnotation *annotation) { if (!annotation) return CPLString(); CPLString osAnnot(transcode(annotation->getAnnotationString())); CPLXMLNode *psRoot = CPLParseXMLString(osAnnot); CPLStripXMLNamespace(psRoot, nullptr, TRUE); CPLString osDoc(CPLGetXMLValue(psRoot, "=annotation.documentation", "")); CPLDestroyXMLNode(psRoot); return osDoc.Trim(); } /************************************************************************/ /* GetAnnotationDoc() */ /************************************************************************/ static CPLString GetAnnotationDoc(const XSAnnotationList *annotationList) { if (!annotationList) return CPLString(); CPLString osRet; for (size_t i = 0; i < annotationList->size(); ++i) { CPLString osDoc(GetAnnotationDoc(annotationList->elementAt(i))); if (!osDoc.empty()) { if (!osRet.empty()) osRet += "\n"; osRet += osDoc; } } return osRet; } /************************************************************************/ /* GetAnnotationDoc() */ /************************************************************************/ static CPLString GetAnnotationDoc(const XSElementDeclaration *poEltDecl) { XSTypeDefinition *poTypeDef = poEltDecl->getTypeDefinition(); CPLString osDoc = GetAnnotationDoc(poEltDecl->getAnnotation()); XSAnnotationList *list = nullptr; while (poTypeDef != nullptr) { if (poTypeDef->getTypeCategory() == XSTypeDefinition::COMPLEX_TYPE) { XSComplexTypeDefinition *poCT = reinterpret_cast(poTypeDef); list = poCT->getAnnotations(); } else if (poTypeDef->getTypeCategory() == XSTypeDefinition::SIMPLE_TYPE) { XSSimpleTypeDefinition *poST = reinterpret_cast(poTypeDef); list = poST->getAnnotations(); } if (list != nullptr) break; XSTypeDefinition *poNewTypeDef = poTypeDef->getBaseType(); if (poNewTypeDef == poTypeDef) break; poTypeDef = poNewTypeDef; } const CPLString osDoc2 = GetAnnotationDoc(list); if (!osDoc.empty() && !osDoc2.empty()) { osDoc += "\n"; osDoc += osDoc2; } else if (!osDoc2.empty()) osDoc = osDoc2; return osDoc; } /************************************************************************/ /* InstantiateClassFromEltDeclaration() */ /************************************************************************/ bool GMLASSchemaAnalyzer::InstantiateClassFromEltDeclaration( XSElementDeclaration *poEltDecl, XSModel *poModel, bool &bError) { bError = false; XSComplexTypeDefinition *poCT = IsEltCompatibleOfFC(poEltDecl); if (!poEltDecl->getAbstract() && poCT != nullptr) { GMLASFeatureClass oClass; const CPLString osEltName(transcode(poEltDecl->getName())); const CPLString osXPath( MakeXPath(transcode(poEltDecl->getNamespace()), osEltName)); if (IsIgnoredXPath(osXPath)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", osXPath.c_str()); #endif return false; } if (m_oMapEltNamesToInstanceCount[osEltName] > 1) { CPLString osLaunderedXPath(osXPath); osLaunderedXPath.replaceAll(':', '_'); oClass.SetName(osLaunderedXPath); } else oClass.SetName(osEltName); #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "Instantiating element %s", osXPath.c_str()); #endif oClass.SetXPath(osXPath); oClass.SetIsTopLevelElt( GetTopElementDeclarationFromXPath(osXPath, poModel) != nullptr); std::set oSetVisitedModelGroups; oClass.SetDocumentation(GetAnnotationDoc(poEltDecl)); // might be NULL on swe:values for example if (poCT->getParticle() != nullptr) { std::map oMapCountOccurrencesOfSameName; BuildMapCountOccurrencesOfSameName( poCT->getParticle()->getModelGroupTerm(), oMapCountOccurrencesOfSameName); OGRwkbGeometryType eGeomType = wkbUnknown; if (IsGMLNamespace(transcode(poCT->getNamespace())) && (eGeomType = GetOGRGeometryType(poCT)) != wkbNone) { GMLASField oField; oField.SetName("geometry"); oField.SetMinOccurs(1); oField.SetMaxOccurs(1); oField.SetType(GMLAS_FT_GEOMETRY, szFAKEXS_GEOMETRY); oField.SetGeomType(eGeomType); oField.SetXPath(osXPath + szMATCH_ALL); oField.SetIncludeThisEltInBlob(true); oClass.AddField(oField); } else if (!ExploreModelGroup( poCT->getParticle()->getModelGroupTerm(), poCT->getAttributeUses(), oClass, 0, oSetVisitedModelGroups, poModel, oMapCountOccurrencesOfSameName)) { bError = true; return false; } } else { // TODO ? } if (!LaunderFieldNames(oClass)) return false; m_aoClasses.push_back(oClass); return true; } return false; } /************************************************************************/ /* SetFieldTypeAndWidthFromDefinition() */ /************************************************************************/ void GMLASSchemaAnalyzer::SetFieldTypeAndWidthFromDefinition( XSSimpleTypeDefinition *poST, GMLASField &oField) { int nMaxLength = 0; while ( poST->getBaseType() != poST && poST->getBaseType()->getTypeCategory() == XSTypeDefinition::SIMPLE_TYPE && !XMLString::equals(poST->getNamespace(), PSVIUni::fgNamespaceXmlSchema)) { const XMLCh *maxLength = poST->getLexicalFacetValue(XSSimpleTypeDefinition::FACET_LENGTH); if (maxLength == nullptr) { maxLength = poST->getLexicalFacetValue( XSSimpleTypeDefinition::FACET_MAXLENGTH); } if (maxLength != nullptr) nMaxLength = MAX(nMaxLength, atoi(transcode(maxLength))); poST = reinterpret_cast(poST->getBaseType()); } if (XMLString::equals(poST->getNamespace(), PSVIUni::fgNamespaceXmlSchema)) { CPLString osType(transcode(poST->getName())); oField.SetType(GMLASField::GetTypeFromString(osType), osType); } else { CPLError(CE_Warning, CPLE_AppDefined, "Base type is not a xs: one ???"); } oField.SetWidth(nMaxLength); } /************************************************************************/ /* IsSame() */ /* */ /* The objects returned by different PSVI API are not always the same */ /* so do content inspection to figure out if they are equivalent. */ /************************************************************************/ bool GMLASSchemaAnalyzer::IsSame(const XSModelGroup *poModelGroup1, const XSModelGroup *poModelGroup2) { if (poModelGroup1->getCompositor() != poModelGroup2->getCompositor()) return false; const XSParticleList *poParticleList1 = poModelGroup1->getParticles(); const XSParticleList *poParticleList2 = poModelGroup2->getParticles(); if (poParticleList1->size() != poParticleList2->size()) return false; for (size_t i = 0; i < poParticleList1->size(); ++i) { const XSParticle *poParticle1 = poParticleList1->elementAt(i); const XSParticle *poParticle2 = poParticleList2->elementAt(i); if (poParticle1->getTermType() != poParticle2->getTermType() || poParticle1->getMinOccurs() != poParticle2->getMinOccurs() || poParticle1->getMaxOccurs() != poParticle2->getMaxOccurs() || poParticle1->getMaxOccursUnbounded() != poParticle2->getMaxOccursUnbounded()) { return false; } switch (poParticle1->getTermType()) { case XSParticle::TERM_EMPTY: break; case XSParticle::TERM_ELEMENT: { const XSElementDeclaration *poElt1 = const_cast(poParticle1)->getElementTerm(); const XSElementDeclaration *poElt2 = const_cast(poParticle2)->getElementTerm(); // Pointer comparison works here if (poElt1 != poElt2) return false; break; } case XSParticle::TERM_MODELGROUP: { const XSModelGroup *psSubGroup1 = const_cast(poParticle1)->getModelGroupTerm(); const XSModelGroup *psSubGroup2 = const_cast(poParticle2)->getModelGroupTerm(); if (!IsSame(psSubGroup1, psSubGroup2)) return false; break; } case XSParticle::TERM_WILDCARD: { // TODO: check that pointer comparison works const XSWildcard *psWildcard1 = const_cast(poParticle1)->getWildcardTerm(); const XSWildcard *psWildcard2 = const_cast(poParticle2)->getWildcardTerm(); if (psWildcard1 != psWildcard2) return false; break; } default: { CPLAssert(FALSE); return false; } } } return true; } /************************************************************************/ /* GetGroupName() */ /* */ /* The model group object returned when exploring a high level model */ /* group isn't the same object as the one returned by model group */ /* definitions and has no name. So we have to investigate the content */ /* of model groups to figure out if they are the same. */ /************************************************************************/ XSModelGroupDefinition * GMLASSchemaAnalyzer::GetGroupDefinition(const XSModelGroup *poModelGroup) { for (const auto &oIter : m_oMapModelGroupToMGD) { if (IsSame(poModelGroup, oIter.first)) { return oIter.second; } } return nullptr; } /************************************************************************/ /* IsAnyType() */ /************************************************************************/ static bool IsAnyType(XSComplexTypeDefinition *poType) { if (XMLString::equals(poType->getBaseType()->getNamespace(), PSVIUni::fgNamespaceXmlSchema) && transcode(poType->getBaseType()->getName()) == szXS_ANY_TYPE) { XSParticle *poParticle = poType->getParticle(); if (poParticle != nullptr) { XSModelGroup *poGroupTerm = poParticle->getModelGroupTerm(); if (poGroupTerm != nullptr) { XSParticleList *poParticles = poGroupTerm->getParticles(); if (poParticles != nullptr) { return poParticles->size() == 1 && poParticles->elementAt(0)->getTermType() == XSParticle::TERM_WILDCARD; } } } else if (poType->getDerivationMethod() == XSConstants::DERIVATION_EXTENSION) { // swe:values case return true; } } return false; } /************************************************************************/ /* SetFieldFromAttribute() */ /************************************************************************/ bool GMLASSchemaAnalyzer::SetFieldFromAttribute(GMLASField &oField, XSAttributeUse *poAttr, const CPLString &osXPathPrefix, const CPLString &osNamePrefix) { const XSAttributeDeclaration *poAttrDecl = poAttr->getAttrDeclaration(); const CPLString osNS(transcode(poAttrDecl->getNamespace())); const CPLString osName(transcode(poAttrDecl->getName())); if (osNamePrefix.empty()) oField.SetName(osName); else oField.SetName(osNamePrefix + "_" + osName); XSSimpleTypeDefinition *poAttrType = poAttrDecl->getTypeDefinition(); if (!poAttrType) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot get type definition for attribute %s", oField.GetName().c_str()); return false; } SetFieldTypeAndWidthFromDefinition(poAttrType, oField); oField.SetXPath(osXPathPrefix + "/@" + MakeXPath(osNS, osName)); if (poAttr->getRequired()) { oField.SetNotNullable(true); } oField.SetMinOccurs(oField.IsNotNullable() ? 1 : 0); oField.SetMaxOccurs(1); if (poAttr->getConstraintType() == XSConstants::VALUE_CONSTRAINT_FIXED) { oField.SetFixedValue(transcode(poAttr->getConstraintValue())); } else if (poAttr->getConstraintType() == XSConstants::VALUE_CONSTRAINT_DEFAULT) { oField.SetDefaultValue(transcode(poAttr->getConstraintValue())); } const bool bIsList = (poAttrType->getVariety() == XSSimpleTypeDefinition::VARIETY_LIST); if (bIsList) { SetFieldTypeAndWidthFromDefinition(poAttrType->getItemType(), oField); if (m_bUseArrays && IsCompatibleOfArray(oField.GetType())) { oField.SetList(true); oField.SetArray(true); } else { // We should probably create an auxiliary table here, but this // is too corner case for now... oField.SetType(GMLAS_FT_STRING, szXS_STRING); } } oField.SetDocumentation(GetAnnotationDoc(poAttrDecl->getAnnotation())); return true; } /************************************************************************/ /* GetConcreteImplementationTypes() */ /************************************************************************/ void GMLASSchemaAnalyzer::GetConcreteImplementationTypes( XSElementDeclaration *poParentElt, std::vector &apoImplEltList) { const auto oIter = m_oMapParentEltToChildElt.find(poParentElt); if (oIter != m_oMapParentEltToChildElt.end()) { for (size_t j = 0; j < oIter->second.size(); j++) { XSElementDeclaration *poSubElt = oIter->second[j]; if (IsEltCompatibleOfFC(poSubElt)) { if (!poSubElt->getAbstract()) { apoImplEltList.push_back(poSubElt); } } GetConcreteImplementationTypes(poSubElt, apoImplEltList); } } } /************************************************************************/ /* GetConstraintChildrenElements() */ /************************************************************************/ std::vector GMLASSchemaAnalyzer::GetConstraintChildrenElements(const CPLString &osFullXPath) { std::vector oVectorRes; CPLString osMatched; if (m_oChildrenElementsConstraintsXPathMatcher.MatchesRefXPath(osFullXPath, osMatched)) { const std::vector &oVector = m_oMapChildrenElementsConstraints[osMatched]; const std::map &oMapPrefixToURI = m_oChildrenElementsConstraintsXPathMatcher.GetMapPrefixToURI(); for (size_t j = 0; j < oVector.size(); ++j) { const CPLString &osSubElt(oVector[j]); CPLString osSubEltPrefix; CPLString osSubEltURI; CPLString osSubEltType(osSubElt); size_t nPos = osSubElt.find(":"); if (nPos != std::string::npos) { osSubEltPrefix = osSubElt.substr(0, nPos); osSubEltType = osSubElt.substr(nPos + 1); const auto oIter2 = oMapPrefixToURI.find(osSubEltPrefix); if (oIter2 != oMapPrefixToURI.end()) { osSubEltURI = oIter2->second; } else { CPLError(CE_Warning, CPLE_AppDefined, "Cannot find prefix of type constraint %s", osSubElt.c_str()); } } const CPLString osSubEltXPath(MakeXPath(osSubEltURI, osSubEltType)); const auto oIter2 = m_oMapXPathToEltDecl.find(osSubEltXPath); if (oIter2 != m_oMapXPathToEltDecl.end()) { XSElementDeclaration *poSubElt = oIter2->second; if (IsEltCompatibleOfFC(poSubElt)) { oVectorRes.push_back(poSubElt); } } else { CPLError( CE_Warning, CPLE_AppDefined, "Cannot find element declaration of type constraint %s", osSubElt.c_str()); } } } return oVectorRes; } /************************************************************************/ /* GetOGRGeometryType() */ /************************************************************************/ static OGRwkbGeometryType GetOGRGeometryType(XSTypeDefinition *poTypeDef) { const struct MyStruct { const char *pszName; OGRwkbGeometryType eType; } asArray[] = {{"GeometryPropertyType", wkbUnknown}, {"PointPropertyType", wkbPoint}, {"BoundingShapeType", wkbPolygon}, {"PolygonPropertyType", wkbPolygon}, {"LineStringPropertyType", wkbLineString}, {"MultiPointPropertyType", wkbMultiPoint}, {"MultiPolygonPropertyType", wkbMultiPolygon}, {"MultiLineStringPropertyType", wkbMultiLineString}, {"MultiGeometryPropertyType", wkbGeometryCollection}, {"MultiCurvePropertyType", wkbMultiCurve}, {"MultiSurfacePropertyType", wkbMultiSurface}, {"MultiSolidPropertyType", wkbUnknown}, // GeometryArrayPropertyType ? {"GeometricPrimitivePropertyType", wkbUnknown}, {"CurvePropertyType", wkbCurve}, {"SurfacePropertyType", wkbSurface}, // SurfaceArrayPropertyType ? // AbstractRingPropertyType ? // LinearRingPropertyType ? {"CompositeCurvePropertyType", wkbCurve}, {"CompositeSurfacePropertyType", wkbSurface}, {"CompositeSolidPropertyType", wkbUnknown}, {"GeometricComplexPropertyType", wkbUnknown}, {"SolidPropertyType", wkbPolyhedralSurface}}; CPLString osName(transcode(poTypeDef->getName())); for (size_t i = 0; i < CPL_ARRAYSIZE(asArray); ++i) { if (osName == asArray[i].pszName) return asArray[i].eType; } return wkbNone; #if 0 #endif } /************************************************************************/ /* GetOGRGeometryTypeFromGMLEltName() */ /************************************************************************/ static OGRwkbGeometryType GetOGRGeometryTypeFromGMLEltName(const CPLString &osEltName) { const struct MyStruct { const char *pszName; OGRwkbGeometryType eType; } asArray[] = { {"Point", wkbPoint}, {"Polygon", wkbPolygon}, {"Envelope", wkbPolygon}, {"LineString", wkbLineString}, {"MultiPoint", wkbMultiPoint}, {"MultiPolygon", wkbMultiPolygon}, {"MultiLineString", wkbMultiLineString}, {"MultiGeometry", wkbGeometryCollection}, {"MultiCurve", wkbMultiCurve}, {"MultiSurface", wkbMultiSurface}, {"MultiSolid", wkbUnknown}, {"Curve", wkbCurve}, {"Surface", wkbSurface}, {"CompositeCurve", wkbCurve}, {"CompositeSurface", wkbSurface}, {"CompositeSolid", wkbUnknown}, {"GeometricComplex", wkbUnknown}, }; for (size_t i = 0; i < CPL_ARRAYSIZE(asArray); ++i) { if (osEltName == asArray[i].pszName) return asArray[i].eType; } return wkbNone; } /************************************************************************/ /* CreateNonNestedRelationship() */ /************************************************************************/ void GMLASSchemaAnalyzer::CreateNonNestedRelationship( XSElementDeclaration *poElt, std::vector &apoImplEltList, GMLASFeatureClass &oClass, int nMaxOccurs, bool bEltNameWillNeedPrefix, bool bForceJunctionTable, bool bCaseOfConstraintChildren) { const CPLString osEltPrefix(GetPrefix(transcode(poElt->getNamespace()))); const CPLString osEltName(transcode(poElt->getName())); const CPLString osOnlyElementXPath( MakeXPath(transcode(poElt->getNamespace()), osEltName)); const CPLString osElementXPath(oClass.GetXPath() + "/" + osOnlyElementXPath); if (!poElt->getAbstract() && !bCaseOfConstraintChildren) { apoImplEltList.insert(apoImplEltList.begin(), poElt); } std::set aoSetSubEltXPath; if (nMaxOccurs == 1 && !bForceJunctionTable) { // If the field isn't repeated, then we can link to each // potential realization types with a field for (size_t j = 0; j < apoImplEltList.size(); j++) { XSElementDeclaration *poSubElt = apoImplEltList[j]; const CPLString osSubEltName(transcode(poSubElt->getName())); const CPLString osSubEltXPath( MakeXPath(transcode(poSubElt->getNamespace()), osSubEltName)); // For AbstractFeature_SpatialDataSet_pkid in SpatialDataSet_member if (aoSetSubEltXPath.find(osSubEltXPath) != aoSetSubEltXPath.end()) { continue; } aoSetSubEltXPath.insert(osSubEltXPath); const CPLString osRealFullXPath(oClass.GetXPath() + "/" + ((bCaseOfConstraintChildren) ? osOnlyElementXPath + "/" : CPLString("")) + osSubEltXPath); if (IsIgnoredXPath(osRealFullXPath)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", osRealFullXPath.c_str()); #endif continue; } GMLASField oField; if (apoImplEltList.size() > 1 || bCaseOfConstraintChildren) { if (m_oMapEltNamesToInstanceCount[osSubEltName] > 1) { CPLString osLaunderedXPath(osSubEltXPath); osLaunderedXPath.replaceAll(':', '_'); oField.SetName(((bEltNameWillNeedPrefix) ? osEltPrefix + "_" : CPLString()) + transcode(poElt->getName()) + "_" + osLaunderedXPath + "_pkid"); } else { oField.SetName(((bEltNameWillNeedPrefix) ? osEltPrefix + "_" : CPLString()) + transcode(poElt->getName()) + "_" + osSubEltName + "_pkid"); } } else { oField.SetName(transcode(poElt->getName()) + "_pkid"); } oField.SetXPath(osRealFullXPath); oField.SetMinOccurs(0); oField.SetMaxOccurs(nMaxOccurs); oField.SetCategory(GMLASField::PATH_TO_CHILD_ELEMENT_WITH_LINK); oField.SetRelatedClassXPath(osSubEltXPath); oField.SetType(GMLAS_FT_STRING, szXS_STRING); oClass.AddField(oField); } } else { // If the field is repeated, we need to use junction // tables for (size_t j = 0; j < apoImplEltList.size(); j++) { XSElementDeclaration *poSubElt = apoImplEltList[j]; const CPLString osSubEltName(transcode(poSubElt->getName())); const CPLString osSubEltXPath( MakeXPath(transcode(poSubElt->getNamespace()), osSubEltName)); // For AbstractFeature_SpatialDataSet_pkid in SpatialDataSet_member if (aoSetSubEltXPath.find(osSubEltXPath) != aoSetSubEltXPath.end()) { continue; } aoSetSubEltXPath.insert(osSubEltXPath); // Instantiate a junction table GMLASFeatureClass oJunctionTable; if (m_oMapEltNamesToInstanceCount[osSubEltName] > 1) { CPLString osLaunderedXPath(osSubEltXPath); osLaunderedXPath.replaceAll(':', '_'); oJunctionTable.SetName(oClass.GetName() + "_" + transcode(poElt->getName()) + "_" + osLaunderedXPath); } else { oJunctionTable.SetName(oClass.GetName() + "_" + transcode(poElt->getName()) + "_" + osSubEltName); } // Create a fake XPath binding the parent xpath (to an abstract // element) to the child element oJunctionTable.SetXPath( BuildJunctionTableXPath(osElementXPath, osSubEltXPath)); oJunctionTable.SetParentXPath(oClass.GetXPath()); oJunctionTable.SetChildXPath(osSubEltXPath); m_aoClasses.push_back(oJunctionTable); // Add an abstract field GMLASField oField; oField.SetName( ((bEltNameWillNeedPrefix) ? osEltPrefix + "_" : CPLString()) + osEltName + "_" + osSubEltName); oField.SetXPath(oClass.GetXPath() + "/" + ((bCaseOfConstraintChildren) ? osOnlyElementXPath + "/" : CPLString("")) + osSubEltXPath); oField.SetMinOccurs(0); oField.SetMaxOccurs(nMaxOccurs); oField.SetAbstractElementXPath(osElementXPath); oField.SetRelatedClassXPath(osSubEltXPath); oField.SetCategory( GMLASField::PATH_TO_CHILD_ELEMENT_WITH_JUNCTION_TABLE); oClass.AddField(oField); } } #if 0 GMLASField oField; oField.SetName( transcode(poElt->getName()) ); oField.SetXPath( osElementXPath ); oField.SetMinOccurs( poParticle->getMinOccurs() ); oField.SetMaxOccurs( poParticle->getMaxOccursUnbounded() ? MAXOCCURS_UNLIMITED : poParticle->getMaxOccurs() ); for( size_t j = 0; j < apoImplEltList.size(); j++ ) { XSElementDeclaration* poSubElt = apoImplEltList[j]; XSTypeDefinition* poSubEltType = poSubElt->getTypeDefinition(); XSComplexTypeDefinition* poCT = reinterpret_cast(poSubEltType); GMLASFeatureClass oNestedClass; oNestedClass.SetName( oClass.GetName() + "_" + transcode(poSubElt->getName()) ); oNestedClass.SetXPath( oClass.GetXPath() + "/" + MakeXPath(transcode(poSubElt->getNamespace()), transcode(poSubElt->getName())) ); std::set oSetNewVisitedModelGroups(oSetVisitedModelGroups); if( !ExploreModelGroup( poCT->getParticle()->getModelGroupTerm(), NULL, oNestedClass, nRecursionCounter + 1, oSetNewVisitedModelGroups ) ) { return false; } oClass.AddNestedClass( oNestedClass ); } if( !apoImplEltList.empty() ) { oField.SetAbstract(true); } else { oField.SetType( GMLAS_FT_ANYTYPE, "anyType" ); oField.SetXPath( oClass.GetXPath() + "/" + "*" ); oField.SetIncludeThisEltInBlob( true ); } oClass.AddField( oField ); #endif } /************************************************************************/ /* IsIgnoredXPath() */ /************************************************************************/ bool GMLASSchemaAnalyzer::IsIgnoredXPath(const CPLString &osXPath) { CPLString osIgnored; return m_oIgnoredXPathMatcher.MatchesRefXPath(osXPath, osIgnored); } /************************************************************************/ /* FindElementsWithMustBeToLevel() */ /************************************************************************/ bool GMLASSchemaAnalyzer::FindElementsWithMustBeToLevel( const CPLString &osParentXPath, XSModelGroup *poModelGroup, int nRecursionCounter, std::set &oSetVisitedEltDecl, std::set &oSetVisitedModelGroups, std::vector &oVectorEltsForTopClass, std::set &aoSetXPathEltsForTopClass, XSModel *poModel, bool &bSimpleEnoughOut, int &nCountSubEltsOut) { const bool bAlreadyVisitedMG = (oSetVisitedModelGroups.find(poModelGroup) != oSetVisitedModelGroups.end()); oSetVisitedModelGroups.insert(poModelGroup); if (nRecursionCounter == 100) { // Presumably an hostile schema CPLError(CE_Failure, CPLE_AppDefined, "Schema analysis failed due to too deeply nested model"); return false; } { CPLString osIgnored; if (m_oDisabledFlattenedXPathMatcher.MatchesRefXPath(osParentXPath, osIgnored)) { bSimpleEnoughOut = false; } } XSParticleList *poParticles = poModelGroup->getParticles(); for (size_t i = 0; i < poParticles->size(); ++i) { XSParticle *poParticle = poParticles->elementAt(i); const bool bRepeatedParticle = poParticle->getMaxOccursUnbounded() || poParticle->getMaxOccurs() > 1; if (poParticle->getTermType() == XSParticle::TERM_ELEMENT) { XSElementDeclaration *poElt = poParticle->getElementTerm(); XSTypeDefinition *poTypeDef = poElt->getTypeDefinition(); const CPLString osEltName(transcode(poElt->getName())); const CPLString osEltNS(transcode(poElt->getNamespace())); const CPLString osXPath(MakeXPath(osEltNS, osEltName)); const CPLString osFullXPath(osParentXPath + "/" + osXPath); #ifdef DEBUG_SUPER_VERBOSE CPLDebug("GMLAS", "FindElementsWithMustBeToLevel: %s", osFullXPath.c_str()); #endif if (IsIgnoredXPath(osFullXPath)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", osFullXPath.c_str()); #endif continue; } // This could be refined to detect if the repeated element might not // be simplifiable as an array if (bSimpleEnoughOut && bRepeatedParticle) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s not inlinable because %s is repeated", osParentXPath.c_str(), osXPath.c_str()); #endif bSimpleEnoughOut = false; } // We don't want to inline // sub-classes with hundereds of attributes nCountSubEltsOut++; std::vector apoImplEltList; GetConcreteImplementationTypes(poElt, apoImplEltList); std::vector apoChildrenElements = GetConstraintChildrenElements(osFullXPath); // Special case for a GML geometry property if (IsGMLNamespace(transcode(poTypeDef->getNamespace())) && GetOGRGeometryType(poTypeDef) != wkbNone) { // Do nothing } else if (IsGMLNamespace(osEltNS) && GetOGRGeometryTypeFromGMLEltName(osEltName) != wkbNone) { // Do nothing } // Any GML abstract type else if (poElt->getAbstract() && IsGMLNamespace(osEltNS) && osEltName != "_Feature" && osEltName != "AbstractFeature" && osEltName != "AbstractTimeObject") { // Do nothing } // Are there substitution groups for this element ? else if (!apoImplEltList.empty() || !apoChildrenElements.empty()) { if (!apoChildrenElements.empty()) { apoImplEltList = std::move(apoChildrenElements); } else if (!poElt->getAbstract()) { apoImplEltList.insert(apoImplEltList.begin(), poElt); } for (size_t j = 0; j < apoImplEltList.size(); j++) { XSElementDeclaration *poSubElt = apoImplEltList[j]; const CPLString osSubEltXPath( MakeXPath(transcode(poSubElt->getNamespace()), transcode(poSubElt->getName()))); if (IsIgnoredXPath(osParentXPath + "/" + osSubEltXPath)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", (osParentXPath + "/" + osSubEltXPath).c_str()); #endif continue; } // Make sure we will instantiate the referenced element if (m_oSetEltsForTopClass.find(poSubElt) == m_oSetEltsForTopClass.end() && aoSetXPathEltsForTopClass.find(osSubEltXPath) == aoSetXPathEltsForTopClass.end()) { #ifdef DEBUG_VERBOSE CPLDebug( "GMLAS", "%s (%s) must be exposed as " "top-level (%s of %s)", osSubEltXPath.c_str(), transcode(poSubElt->getTypeDefinition()->getName()) .c_str(), apoChildrenElements.empty() ? "derived class" : "child", osParentXPath.c_str()); #endif oSetVisitedEltDecl.insert(poSubElt); m_oSetEltsForTopClass.insert(poSubElt); oVectorEltsForTopClass.push_back(poSubElt); aoSetXPathEltsForTopClass.insert(osSubEltXPath); XSComplexTypeDefinition *poSubEltCT = IsEltCompatibleOfFC(poSubElt); if (!bAlreadyVisitedMG && poSubEltCT != nullptr && poSubEltCT->getParticle() != nullptr) { bool bSubSimpleEnoughOut = true; int nSubCountSubElt = 0; if (!FindElementsWithMustBeToLevel( osSubEltXPath, poSubEltCT->getParticle() ->getModelGroupTerm(), nRecursionCounter + 1, oSetVisitedEltDecl, oSetVisitedModelGroups, oVectorEltsForTopClass, aoSetXPathEltsForTopClass, poModel, bSubSimpleEnoughOut, nSubCountSubElt)) { return false; } } } } } else if (!poElt->getAbstract() && poTypeDef->getTypeCategory() == XSTypeDefinition::COMPLEX_TYPE) { nCountSubEltsOut--; XSComplexTypeDefinition *poEltCT = IsEltCompatibleOfFC(poElt); if (poEltCT) { // Might be a bit extreme, but for now we don't inline // classes that have subclasses. if (bSimpleEnoughOut) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s not inlinable because %s field is complex", osParentXPath.c_str(), osXPath.c_str()); #endif bSimpleEnoughOut = false; } if (oSetVisitedEltDecl.find(poElt) != oSetVisitedEltDecl.end()) { if (m_oSetEltsForTopClass.find(poElt) == m_oSetEltsForTopClass.end() && m_oSetSimpleEnoughElts.find(poElt) == m_oSetSimpleEnoughElts.end() && aoSetXPathEltsForTopClass.find(osXPath) == aoSetXPathEltsForTopClass.end()) { CPLString osIgnored; if (!m_oForcedFlattenedXPathMatcher.MatchesRefXPath( osXPath, osIgnored)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s (%s) must be exposed as " "top-level (multiple time referenced)", osXPath.c_str(), transcode(poTypeDef->getNamespace()) .c_str()); #endif m_oSetEltsForTopClass.insert(poElt); oVectorEltsForTopClass.push_back(poElt); aoSetXPathEltsForTopClass.insert(osXPath); } } } else { oSetVisitedEltDecl.insert(poElt); if (!bAlreadyVisitedMG && poEltCT->getParticle() != nullptr) { int nSubCountSubElt = 0; // Process attributes XSAttributeUseList *poAttrList = poEltCT->getAttributeUses(); const size_t nAttrListSize = (poAttrList != nullptr) ? poAttrList->size() : 0; for (size_t j = 0; j < nAttrListSize; ++j) { XSAttributeUse *poAttr = poAttrList->elementAt(j); GMLASField oField; if (!SetFieldFromAttribute(oField, poAttr, osFullXPath)) { return false; } if (!IsIgnoredXPath(oField.GetXPath()) && oField.GetFixedValue().empty()) { #ifdef DEBUG_SUPER_VERBOSE CPLDebug( "GMLAS", "FindElementsWithMustBeToLevel: %s", oField.GetXPath().c_str()); #endif nSubCountSubElt++; } } bool bSubSimpleEnoughOut = true; if (!FindElementsWithMustBeToLevel( osFullXPath, poEltCT->getParticle()->getModelGroupTerm(), nRecursionCounter + 1, oSetVisitedEltDecl, oSetVisitedModelGroups, oVectorEltsForTopClass, aoSetXPathEltsForTopClass, poModel, bSubSimpleEnoughOut, nSubCountSubElt)) { return false; } if (bSubSimpleEnoughOut) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is inlinable: %d fields", osXPath.c_str(), nSubCountSubElt); #endif m_oSetSimpleEnoughElts.insert(poElt); nCountSubEltsOut += nSubCountSubElt; } else if (bSimpleEnoughOut) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s not inlinable because %s is not " "inlinable", osParentXPath.c_str(), osXPath.c_str()); #endif bSimpleEnoughOut = false; } } } } else { if (transcode(poElt->getName()) != szFEATURE_COLLECTION) { poEltCT = reinterpret_cast( poTypeDef); // Process attributes XSAttributeUseList *poAttrList = poEltCT->getAttributeUses(); const size_t nAttrListSize = (poAttrList != nullptr) ? poAttrList->size() : 0; for (size_t j = 0; bSimpleEnoughOut && j < nAttrListSize; ++j) { XSAttributeUse *poAttr = poAttrList->elementAt(j); GMLASField oField; if (!SetFieldFromAttribute(oField, poAttr, osFullXPath)) { return false; } if (!IsIgnoredXPath(oField.GetXPath()) && oField.GetFixedValue().empty()) { #ifdef DEBUG_SUPER_VERBOSE CPLDebug("GMLAS", "FindElementsWithMustBeToLevel: %s", oField.GetXPath().c_str()); #endif nCountSubEltsOut++; } } } } CPLString osTargetElement; if (poElt->getAnnotation() != nullptr) { CPLString osAnnot(transcode( poElt->getAnnotation()->getAnnotationString())); #ifdef DEBUG_SUPER_VERBOSE CPLDebug("GMLAS", "Annot: %s", osAnnot.c_str()); #endif CPLXMLNode *psRoot = CPLParseXMLString(osAnnot); CPLStripXMLNamespace(psRoot, nullptr, TRUE); osTargetElement = CPLGetXMLValue( psRoot, "=annotation.appinfo.targetElement", ""); CPLDestroyXMLNode(psRoot); #ifdef DEBUG_VERBOSE if (!osTargetElement.empty()) CPLDebug("GMLAS", "targetElement: %s", osTargetElement.c_str()); #endif } // If we have a element of type gml:ReferenceType that has // a targetElement in its annotation.appinfo, then create // a dedicated field to have cross-layer relationships. if (IsGMLNamespace(transcode(poTypeDef->getNamespace())) && transcode(poTypeDef->getName()) == "ReferenceType" && !osTargetElement.empty()) { XSElementDeclaration *poTargetElt = GetTopElementDeclarationFromXPath(osTargetElement, poModel); // TODO: even for non abstract we should probably // handle substitutions if (poTargetElt != nullptr && !poTargetElt->getAbstract()) { const CPLString osTargetEltXPath( MakeXPath(transcode(poTargetElt->getNamespace()), transcode(poTargetElt->getName()))); if (IsIgnoredXPath(osTargetEltXPath)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", osTargetEltXPath.c_str()); #endif continue; } // Make sure we will instantiate the referenced // element if (m_oSetEltsForTopClass.find(poTargetElt) == m_oSetEltsForTopClass.end() && aoSetXPathEltsForTopClass.find(osTargetEltXPath) == aoSetXPathEltsForTopClass.end()) { #ifdef DEBUG_VERBOSE CPLDebug( "GMLAS", "%d: Adding %s as (%s) needed type", __LINE__, osTargetElement.c_str(), transcode( poTargetElt->getTypeDefinition()->getName()) .c_str()); #endif oSetVisitedEltDecl.insert(poTargetElt); m_oSetEltsForTopClass.insert(poTargetElt); oVectorEltsForTopClass.push_back(poTargetElt); aoSetXPathEltsForTopClass.insert(osTargetEltXPath); } XSComplexTypeDefinition *poTargetEltCT = IsEltCompatibleOfFC(poTargetElt); if (!bAlreadyVisitedMG && poTargetEltCT && poTargetEltCT->getParticle() != nullptr) { bool bSubSimpleEnoughOut = true; int nSubCountSubElt = 0; if (!FindElementsWithMustBeToLevel( osTargetEltXPath, poTargetEltCT->getParticle() ->getModelGroupTerm(), nRecursionCounter + 1, oSetVisitedEltDecl, oSetVisitedModelGroups, oVectorEltsForTopClass, aoSetXPathEltsForTopClass, poModel, bSubSimpleEnoughOut, nSubCountSubElt)) { return false; } } } } } } else if (!bAlreadyVisitedMG && poParticle->getTermType() == XSParticle::TERM_MODELGROUP) { // This could be refined to detect if the repeated element might not // be simplifiable as an array if (bSimpleEnoughOut && bRepeatedParticle) { #ifdef DEBUG_VERBOSE CPLDebug( "GMLAS", "%s not inlinable because there is a repeated particle", osParentXPath.c_str()); #endif bSimpleEnoughOut = false; } XSModelGroup *psSubModelGroup = poParticle->getModelGroupTerm(); if (!FindElementsWithMustBeToLevel( osParentXPath, psSubModelGroup, nRecursionCounter + 1, oSetVisitedEltDecl, oSetVisitedModelGroups, oVectorEltsForTopClass, aoSetXPathEltsForTopClass, poModel, bSimpleEnoughOut, nCountSubEltsOut)) { return false; } } else { // This could be refined to detect if the repeated element might not // be simplifiable as an array if (bSimpleEnoughOut && bRepeatedParticle) { #ifdef DEBUG_VERBOSE CPLDebug( "GMLAS", "%s not inlinable because there is a repeated particle", osParentXPath.c_str()); #endif bSimpleEnoughOut = false; } } } if (bSimpleEnoughOut && nCountSubEltsOut > m_nMaximumFieldsForFlattening) { CPLString osIgnored; if (!m_oForcedFlattenedXPathMatcher.MatchesRefXPath(osParentXPath, osIgnored)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s not inlinable because it has more than %d fields", osParentXPath.c_str(), m_nMaximumFieldsForFlattening); #endif bSimpleEnoughOut = false; } } return true; } /************************************************************************/ /* IsGMLNamespace() */ /************************************************************************/ bool GMLASSchemaAnalyzer::IsGMLNamespace(const CPLString &osURI) { if (osURI.find(szGML_URI) == 0) return true; // Below is mostly for unit tests were we use xmlns:gml="http://fake_gml" const auto oIter = m_oMapURIToPrefix.find(osURI); return oIter != m_oMapURIToPrefix.end() && oIter->second == szGML_PREFIX; } /************************************************************************/ /* BuildMapCountOccurrencesOfSameName() */ /************************************************************************/ void GMLASSchemaAnalyzer::BuildMapCountOccurrencesOfSameName( XSModelGroup *poModelGroup, std::map &oMapCountOccurrencesOfSameName) { XSParticleList *poParticles = poModelGroup->getParticles(); for (size_t i = 0; i < poParticles->size(); ++i) { XSParticle *poParticle = poParticles->elementAt(i); if (poParticle->getTermType() == XSParticle::TERM_ELEMENT) { XSElementDeclaration *poElt = poParticle->getElementTerm(); const CPLString osEltName(transcode(poElt->getName())); oMapCountOccurrencesOfSameName[osEltName]++; } else if (poParticle->getTermType() == XSParticle::TERM_MODELGROUP) { XSModelGroup *psSubModelGroup = poParticle->getModelGroupTerm(); BuildMapCountOccurrencesOfSameName(psSubModelGroup, oMapCountOccurrencesOfSameName); } } } /************************************************************************/ /* ComposeMinOccurs() */ /************************************************************************/ static int ComposeMinOccurs(int nVal1, int nVal2) { return nVal1 * nVal2; } /************************************************************************/ /* ComposeMaxOccurs() */ /************************************************************************/ static int ComposeMaxOccurs(int nVal1, int nVal2) { if (nVal1 == MAXOCCURS_UNLIMITED || nVal2 == MAXOCCURS_UNLIMITED) return MAXOCCURS_UNLIMITED; return nVal1 * nVal2; } /************************************************************************/ /* ExploreModelGroup() */ /************************************************************************/ bool GMLASSchemaAnalyzer::ExploreModelGroup( XSModelGroup *poModelGroup, XSAttributeUseList *poMainAttrList, GMLASFeatureClass &oClass, int nRecursionCounter, std::set &oSetVisitedModelGroups, XSModel *poModel, const std::map &oMapCountOccurrencesOfSameName) { if (oSetVisitedModelGroups.find(poModelGroup) != oSetVisitedModelGroups.end()) { CPLError(CE_Failure, CPLE_AppDefined, "%s already visited", oClass.GetXPath().c_str()); return false; } oSetVisitedModelGroups.insert(poModelGroup); if (nRecursionCounter == 100) { // Presumably an hostile schema CPLError(CE_Failure, CPLE_AppDefined, "Schema analysis failed due to too deeply nested model"); return false; } if (poMainAttrList != nullptr) { const size_t nMainAttrListSize = poMainAttrList->size(); for (size_t j = 0; j < nMainAttrListSize; ++j) { GMLASField oField; XSAttributeUse *poAttr = poMainAttrList->elementAt(j); if (!SetFieldFromAttribute(oField, poAttr, oClass.GetXPath())) { return false; } if (IsIgnoredXPath(oField.GetXPath())) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", oField.GetXPath().c_str()); #endif if (!oField.GetFixedValue().empty() || !oField.GetDefaultValue().empty()) { oField.SetIgnored(); } else { continue; } } oClass.AddField(oField); } } XSParticleList *poParticles = poModelGroup->getParticles(); // Special case for GML 3.1.1 where gml:metaDataProperty should be // a sequence of gml:_Metadata but for some reason they have used // a sequence of any. if (oClass.GetXPath() == "gml:metaDataProperty" && poModelGroup->getCompositor() == XSModelGroup::COMPOSITOR_SEQUENCE && poParticles->size() == 1 && poParticles->elementAt(0)->getTermType() == XSParticle::TERM_WILDCARD) { XSElementDeclaration *poGMLMetadata = GetTopElementDeclarationFromXPath("gml:_MetaData", poModel); if (poGMLMetadata != nullptr) { std::vector apoImplEltList; GetConcreteImplementationTypes(poGMLMetadata, apoImplEltList); CreateNonNestedRelationship(poGMLMetadata, apoImplEltList, oClass, 1, false, // doesn't need prefix true, // force junction table false // regular case ); return true; } } const bool bIsChoice = (poModelGroup->getCompositor() == XSModelGroup::COMPOSITOR_CHOICE); int nGroup = 0; for (size_t i = 0; i < poParticles->size(); ++i) { XSParticle *poParticle = poParticles->elementAt(i); const bool bRepeatedParticle = poParticle->getMaxOccursUnbounded() || poParticle->getMaxOccurs() > 1; const int nMinOccurs = static_cast(poParticle->getMinOccurs()); const int nMaxOccurs = poParticle->getMaxOccursUnbounded() ? MAXOCCURS_UNLIMITED : static_cast(poParticle->getMaxOccurs()); if (poParticle->getTermType() == XSParticle::TERM_ELEMENT) { XSElementDeclaration *poElt = poParticle->getElementTerm(); const CPLString osEltName(transcode(poElt->getName())); const auto oIter = oMapCountOccurrencesOfSameName.find(osEltName); const bool bEltNameWillNeedPrefix = oIter != oMapCountOccurrencesOfSameName.end() && oIter->second > 1; const CPLString osEltNS(transcode(poElt->getNamespace())); const CPLString osPrefixedEltName((bEltNameWillNeedPrefix ? GetPrefix(osEltNS) + "_" : CPLString()) + osEltName); const CPLString osOnlyElementXPath(MakeXPath(osEltNS, osEltName)); const CPLString osElementXPath(oClass.GetXPath() + "/" + osOnlyElementXPath); #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "Iterating through %s", osElementXPath.c_str()); #endif if (IsIgnoredXPath(osElementXPath)) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", osElementXPath.c_str()); #endif continue; } CPLString osTargetElement; if (poElt->getAnnotation() != nullptr) { CPLString osAnnot( transcode(poElt->getAnnotation()->getAnnotationString())); #ifdef DEBUG_SUPER_VERBOSE CPLDebug("GMLAS", "Annot: %s", osAnnot.c_str()); #endif CPLXMLNode *psRoot = CPLParseXMLString(osAnnot); CPLStripXMLNamespace(psRoot, nullptr, TRUE); osTargetElement = CPLGetXMLValue( psRoot, "=annotation.appinfo.targetElement", ""); CPLDestroyXMLNode(psRoot); #ifdef DEBUG_VERBOSE if (!osTargetElement.empty()) CPLDebug("GMLAS", "targetElement: %s", osTargetElement.c_str()); #endif } XSTypeDefinition *poTypeDef = poElt->getTypeDefinition(); std::vector apoImplEltList; GetConcreteImplementationTypes(poElt, apoImplEltList); std::vector apoChildrenElements = GetConstraintChildrenElements(osElementXPath); // Special case for a GML geometry property OGRwkbGeometryType eGeomType = wkbNone; // to make Visual Studio happy CPL_IGNORE_RET_VAL(eGeomType); // to make cppcheck happy if (!apoChildrenElements.empty()) { CreateNonNestedRelationship( poElt, apoChildrenElements, oClass, nMaxOccurs, bEltNameWillNeedPrefix, false, // do not force junction table true // special case for children elements ); } else if (IsGMLNamespace(transcode(poTypeDef->getNamespace())) && (eGeomType = GetOGRGeometryType(poTypeDef)) != wkbNone) { GMLASField oField; oField.SetName(osPrefixedEltName); oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); oField.SetType(GMLAS_FT_GEOMETRY, szFAKEXS_GEOMETRY); if (nMaxOccurs > 1 || nMaxOccurs == MAXOCCURS_UNLIMITED) { // Repeated geometry property can happen in some schemas // like // inspire.ec.europa.eu/schemas/ge_gp/4.0/GeophysicsCore.xsd // or // http://ngwd-bdnes.cits.nrcan.gc.ca/service/gwml/schemas/2.1/gwml2-flow.xsd oField.SetGeomType(wkbUnknown); oField.SetArray(true); } else oField.SetGeomType(eGeomType); oField.SetXPath(osElementXPath); oField.SetDocumentation(GetAnnotationDoc(poElt)); oClass.AddField(oField); } else if (IsGMLNamespace(osEltNS) && (eGeomType = GetOGRGeometryTypeFromGMLEltName( osEltName)) != wkbNone) { GMLASField oField; oField.SetName(osPrefixedEltName); oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); oField.SetType(GMLAS_FT_GEOMETRY, szFAKEXS_GEOMETRY); oField.SetGeomType(eGeomType); oField.SetArray(nMaxOccurs > 1 || nMaxOccurs == MAXOCCURS_UNLIMITED); oField.SetXPath(osElementXPath); oField.SetIncludeThisEltInBlob(true); oField.SetDocumentation(GetAnnotationDoc(poElt)); oClass.AddField(oField); } // Any GML abstract type else if (poElt->getAbstract() && IsGMLNamespace(osEltNS) && osEltName != "_Feature" && osEltName != "AbstractFeature" && osEltName != "AbstractTimeObject") { GMLASField oField; oField.SetName(osPrefixedEltName); oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); if (osEltName == "AbstractGeometry") { oField.SetType(GMLAS_FT_GEOMETRY, szFAKEXS_GEOMETRY); oField.SetGeomType(wkbUnknown); oField.SetArray(nMaxOccurs > 1 || nMaxOccurs == MAXOCCURS_UNLIMITED); } else { oField.SetType(GMLAS_FT_ANYTYPE, szXS_ANY_TYPE); } oField.SetIncludeThisEltInBlob(true); oField.SetDocumentation(GetAnnotationDoc(poElt)); for (size_t j = 0; j < apoImplEltList.size(); j++) { XSElementDeclaration *poSubElt = apoImplEltList[j]; oField.AddAlternateXPath( oClass.GetXPath() + "/" + MakeXPath(transcode(poSubElt->getNamespace()), transcode(poSubElt->getName()))); } oClass.AddField(oField); } // Are there substitution groups for this element ? // or is this element already identified as being a top-level one ? else if (!apoImplEltList.empty() || (m_oSetEltsForTopClass.find(poElt) != m_oSetEltsForTopClass.end() && m_oSetSimpleEnoughElts.find(poElt) == m_oSetSimpleEnoughElts.end())) { CreateNonNestedRelationship( poElt, apoImplEltList, oClass, nMaxOccurs, bEltNameWillNeedPrefix, false, // do not force junction table false // regular case ); } // Abstract element without realizations ! else if (poElt->getAbstract()) { // Do nothing with it since it cannot be instantiated // in a valid way. CPLDebug("GMLAS", "Ignoring %s that is abstract without realizations", osElementXPath.c_str()); } // Simple type like string, int, etc... else if (poTypeDef->getTypeCategory() == XSTypeDefinition::SIMPLE_TYPE) { XSSimpleTypeDefinition *poST = reinterpret_cast(poTypeDef); GMLASField oField; SetFieldTypeAndWidthFromDefinition(poST, oField); oField.SetMinOccurs((bIsChoice) ? 0 : nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); oField.SetDocumentation(GetAnnotationDoc(poElt)); bool bNeedAuxTable = false; const bool bIsList = (poST->getVariety() == XSSimpleTypeDefinition::VARIETY_LIST); if (bIsList) { SetFieldTypeAndWidthFromDefinition(poST->getItemType(), oField); if (bRepeatedParticle || !m_bUseArrays || !IsCompatibleOfArray(oField.GetType())) { // Really particular case. This is a workaround oField.SetType(GMLAS_FT_STRING, szXS_STRING); } else { oField.SetList(true); oField.SetArray(true); } } if (m_bUseArrays && bRepeatedParticle && IsCompatibleOfArray(oField.GetType())) { oField.SetArray(true); } else if (bRepeatedParticle) { bNeedAuxTable = true; } if (bNeedAuxTable) { GMLASFeatureClass oNestedClass; oNestedClass.SetName(oClass.GetName() + "_" + osPrefixedEltName); oNestedClass.SetXPath(osElementXPath); GMLASField oUniqueField; oUniqueField.SetName("value"); oUniqueField.SetMinOccurs(1); oUniqueField.SetMaxOccurs(1); oUniqueField.SetXPath(osElementXPath); oUniqueField.SetType(oField.GetType(), oField.GetTypeName()); oNestedClass.AddField(oUniqueField); oNestedClass.SetDocumentation(GetAnnotationDoc(poElt)); oClass.AddNestedClass(oNestedClass); oField.SetType(GMLAS_FT_STRING, ""); oField.SetName(osPrefixedEltName); oField.SetXPath(osElementXPath); oField.SetCategory( GMLASField::PATH_TO_CHILD_ELEMENT_NO_LINK); oField.SetRelatedClassXPath(oField.GetXPath()); oClass.AddField(oField); } else { oField.SetName(osPrefixedEltName); oField.SetXPath(osElementXPath); if (!bIsChoice && nMinOccurs > 0 && !poElt->getNillable()) { oField.SetNotNullable(true); } oClass.AddField(oField); // If the element has minOccurs=0 and is nillable, then we // need an extra field to be able to distinguish between the // case of the missing element or the element with // xsi:nil="true" if (nMinOccurs == 0 && poElt->getNillable() && !m_bUseNullState) { GMLASField oFieldNil; oFieldNil.SetName(osPrefixedEltName + "_" + szNIL); oFieldNil.SetXPath(osElementXPath + "/" + szAT_XSI_NIL); oFieldNil.SetType(GMLAS_FT_BOOLEAN, "boolean"); oFieldNil.SetMinOccurs(0); oFieldNil.SetMaxOccurs(1); oClass.AddField(oFieldNil); } } } // Complex type (element with attributes, composed element, etc...) else if (poTypeDef->getTypeCategory() == XSTypeDefinition::COMPLEX_TYPE) { XSComplexTypeDefinition *poEltCT = reinterpret_cast(poTypeDef); std::vector aoFields; bool bNothingMoreToDo = false; std::vector aoNestedClasses; const int nMinOccursEltParticle = poEltCT->getParticle() ? static_cast( poEltCT->getParticle()->getMinOccurs()) : -1; const int nMaxOccursEltParticle = poEltCT->getParticle() ? (poEltCT->getParticle()->getMaxOccursUnbounded() ? MAXOCCURS_UNLIMITED : static_cast( poEltCT->getParticle()->getMaxOccurs())) : -1; const bool bEltRepeatedParticle = nMaxOccursEltParticle > 1 || nMaxOccursEltParticle == MAXOCCURS_UNLIMITED; const bool bMoveNestedClassToTop = !bRepeatedParticle && !bEltRepeatedParticle; // Process attributes XSAttributeUseList *poAttrList = poEltCT->getAttributeUses(); const size_t nAttrListSize = (poAttrList != nullptr) ? poAttrList->size() : 0; for (size_t j = 0; j < nAttrListSize; ++j) { XSAttributeUse *poAttr = poAttrList->elementAt(j); GMLASField oField; CPLString osNamePrefix(bMoveNestedClassToTop ? osPrefixedEltName : CPLString()); if (!SetFieldFromAttribute(oField, poAttr, osElementXPath, osNamePrefix)) { return false; } if (nMinOccurs == 0 || bIsChoice) { oField.SetMinOccurs(0); oField.SetNotNullable(false); } if (IsIgnoredXPath(oField.GetXPath())) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "%s is in ignored xpaths", oField.GetXPath().c_str()); #endif if (!oField.GetFixedValue().empty() || !oField.GetDefaultValue().empty()) { oField.SetIgnored(); } else { continue; } } aoFields.push_back(oField); } // Deal with anyAttributes (or any element that also imply it) XSWildcard *poAttrWildcard = poEltCT->getAttributeWildcard(); if (poAttrWildcard != nullptr) { GMLASField oField; oField.SetType(GMLASField::GetTypeFromString(szXS_STRING), szFAKEXS_JSON_DICT); if (!bMoveNestedClassToTop) { oField.SetName("anyAttributes"); } else { oField.SetName(osPrefixedEltName + "_anyAttributes"); } oField.SetXPath(osElementXPath + "/" + szAT_ANY_ATTR); oField.SetDocumentation( GetAnnotationDoc(poAttrWildcard->getAnnotation())); aoFields.push_back(oField); } XSSimpleTypeDefinition *poST = poEltCT->getSimpleType(); if (poST != nullptr) { /* Case of an element, generally with attributes */ GMLASField oField; SetFieldTypeAndWidthFromDefinition(poST, oField); if (bRepeatedParticle && nAttrListSize == 0 && m_bUseArrays && IsCompatibleOfArray(oField.GetType()) && oField.GetCategory() != GMLASField::PATH_TO_CHILD_ELEMENT_WITH_LINK) { /* We have a complex type, but no attributes, and */ /* compatible of arrays, so move it to top level! */ oField.SetName(osPrefixedEltName); oField.SetArray(true); oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); } else if (bRepeatedParticle) { oField.SetName("value"); oField.SetMinOccurs(1); oField.SetMaxOccurs(1); oField.SetNotNullable(true); } else { if (nMinOccurs == 0) { for (size_t j = 0; j < aoFields.size(); j++) { aoFields[j].SetMinOccurs(0); aoFields[j].SetNotNullable(false); } } oField.SetName(osPrefixedEltName); oField.SetMinOccurs((bIsChoice) ? 0 : nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); // If the element has minOccurs=0 and is nillable, then // we need an extra field to be able to distinguish // between the case of the missing element or the // element with xsi:nil="true" if (nMinOccurs == 0 && poElt->getNillable() && !m_bUseNullState) { GMLASField oFieldNil; oFieldNil.SetName(osPrefixedEltName + "_" + szNIL); oFieldNil.SetXPath(osElementXPath + "/" + szAT_XSI_NIL); oFieldNil.SetType(GMLAS_FT_BOOLEAN, "boolean"); oFieldNil.SetMinOccurs(0); oFieldNil.SetMaxOccurs(1); aoFields.push_back(oFieldNil); } } oField.SetXPath(osElementXPath); oField.SetDocumentation(GetAnnotationDoc(poElt)); aoFields.push_back(oField); if (oField.IsArray()) { oClass.AddField(oField); bNothingMoreToDo = true; } } else if (IsAnyType(poEltCT)) { GMLASField oField; oField.SetType(GMLAS_FT_ANYTYPE, szXS_ANY_TYPE); if (bRepeatedParticle) { oField.SetName("value"); oField.SetMinOccurs(1); oField.SetMaxOccurs(1); oField.SetNotNullable(true); } else { if (nMinOccurs == 0) { for (size_t j = 0; j < aoFields.size(); j++) { aoFields[j].SetMinOccurs(0); aoFields[j].SetNotNullable(false); } } oField.SetName(osPrefixedEltName); oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); } oField.SetXPath(osElementXPath); oField.SetDocumentation(GetAnnotationDoc(poElt)); aoFields.push_back(oField); } // Is it an element that we already visited ? (cycle) else if (poEltCT->getParticle() != nullptr && oSetVisitedModelGroups.find( poEltCT->getParticle()->getModelGroupTerm()) != oSetVisitedModelGroups.end()) { CreateNonNestedRelationship( poElt, apoImplEltList, oClass, bMoveNestedClassToTop ? 1 : MAXOCCURS_UNLIMITED, bEltNameWillNeedPrefix, true, // force junction table false // regular case ); bNothingMoreToDo = true; } else { GMLASFeatureClass oNestedClass; oNestedClass.SetName(oClass.GetName() + "_" + osPrefixedEltName); oNestedClass.SetXPath(osElementXPath); oNestedClass.SetDocumentation(GetAnnotationDoc(poElt)); // NULL can happen, for example for gml:ReferenceType // that is an empty sequence with just attributes if (poEltCT->getParticle() != nullptr) { #ifdef DEBUG_VERBOSE CPLDebug("GMLAS", "Exploring %s", osElementXPath.c_str()); #endif std::set oSetNewVisitedModelGroups( oSetVisitedModelGroups); std::map oMapCountOccurrencesOfSameNameSub; BuildMapCountOccurrencesOfSameName( poEltCT->getParticle()->getModelGroupTerm(), oMapCountOccurrencesOfSameNameSub); if (!ExploreModelGroup( poEltCT->getParticle()->getModelGroupTerm(), nullptr, oNestedClass, nRecursionCounter + 1, oSetNewVisitedModelGroups, poModel, oMapCountOccurrencesOfSameNameSub)) { return false; } } // If we have a element of type gml:ReferenceType that has // a targetElement in its annotation.appinfo, then create // a dedicated field to have cross-layer relationships. if (IsGMLNamespace(transcode(poTypeDef->getNamespace())) && transcode(poTypeDef->getName()) == "ReferenceType" && !osTargetElement.empty()) { XSElementDeclaration *poTargetElt = GetTopElementDeclarationFromXPath(osTargetElement, poModel); // TODO: even for non abstract we should probably // handle substitutions if (poTargetElt != nullptr && !poTargetElt->getAbstract()) { bool bHasRequiredId = false; XSComplexTypeDefinition *poTargetEltCT = IsEltCompatibleOfFC(poTargetElt); if (poTargetEltCT) { XSAttributeUseList *poTargetEltAttrList = poTargetEltCT->getAttributeUses(); const size_t nTEAttrListSize = (poTargetEltAttrList != nullptr) ? poTargetEltAttrList->size() : 0; for (size_t j = 0; j < nTEAttrListSize; ++j) { XSAttributeUse *poTEAttr = poTargetEltAttrList->elementAt(j); XSAttributeDeclaration *poTEAttrDecl = poTEAttr->getAttrDeclaration(); XSSimpleTypeDefinition *poTEAttrType = poTEAttrDecl->getTypeDefinition(); if (transcode(poTEAttrType->getName()) == szXS_ID && poTEAttr->getRequired()) { bHasRequiredId = true; break; } } } if (bHasRequiredId && !m_bAlwaysGenerateOGRId) { // If the element is nillable, then we // need an extra field to be able to distinguish // between the case of the missing element or // the element with xsi:nil="true" if (poElt->getNillable() && !m_bUseNullState) { GMLASField oFieldNil; oFieldNil.SetName(osPrefixedEltName + "_" + szNIL); oFieldNil.SetXPath(osElementXPath + "/" + szAT_XSI_NIL); oFieldNil.SetType(GMLAS_FT_BOOLEAN, "boolean"); oFieldNil.SetMinOccurs(0); oFieldNil.SetMaxOccurs(1); aoFields.push_back(oFieldNil); } GMLASField oField; // Fake xpath oField.SetXPath( GMLASField:: MakePKIDFieldXPathFromXLinkHrefXPath( osElementXPath + "/" + szAT_XLINK_HREF)); oField.SetName(osPrefixedEltName + szPKID_SUFFIX); oField.SetMinOccurs(0); oField.SetMaxOccurs(1); oField.SetType(GMLAS_FT_STRING, szXS_STRING); oField.SetCategory( GMLASField:: PATH_TO_CHILD_ELEMENT_WITH_LINK); oField.SetRelatedClassXPath(osTargetElement); aoFields.push_back(oField); } } else if (poTargetElt != nullptr && poTargetElt->getAbstract()) { // If the element is nillable, then we // need an extra field to be able to distinguish // between the case of the missing element or the // element with xsi:nil="true" if (poElt->getNillable() && !m_bUseNullState) { GMLASField oFieldNil; oFieldNil.SetName(osPrefixedEltName + "_" + szNIL); oFieldNil.SetXPath(osElementXPath + "/" + szAT_XSI_NIL); oFieldNil.SetType(GMLAS_FT_BOOLEAN, "boolean"); oFieldNil.SetMinOccurs(0); oFieldNil.SetMaxOccurs(1); aoFields.push_back(oFieldNil); } // e.g importing // http://inspire.ec.europa.eu/schemas/ad/4.0 // references bu-base:AbstractConstruction, but // sometimes there are no realization available for // it, so no need to be verbose about that. std::vector apoImplTargetEltList; GetConcreteImplementationTypes( poTargetElt, apoImplTargetEltList); if (!apoImplTargetEltList.empty()) { CPLDebug("GMLAS", "Not handled: targetElement %s of %s " "is abstract but has substitutions", osTargetElement.c_str(), osElementXPath.c_str()); } } else { // This shouldn't happen with consistent schemas // but as targetElement is in , no // general-purpose XSD validator can ensure this CPLDebug("GMLAS", "%s is a targetElement of %s, " "but cannot be found", osTargetElement.c_str(), osElementXPath.c_str()); } } // Can we move the nested class(es) one level up ? if (bMoveNestedClassToTop) { // Case of an element like // // // const std::vector &osNestedClassFields = oNestedClass.GetFields(); for (size_t j = 0; j < osNestedClassFields.size(); j++) { GMLASField oField(osNestedClassFields[j]); oField.SetName(osPrefixedEltName + "_" + oField.GetName()); if (nMinOccurs == 0 || (poEltCT->getParticle() != nullptr && poEltCT->getParticle()->getMinOccurs() == 0)) { oField.SetMinOccurs(0); oField.SetNotNullable(false); } aoFields.push_back(oField); } aoNestedClasses = oNestedClass.GetNestedClasses(); } else { // Case of an element like // // // // or // // // // or even // // // if (m_bUseArrays && nAttrListSize == 0 && oNestedClass.GetNestedClasses().empty() && oNestedClass.GetFields().size() == 1 && IsCompatibleOfArray( oNestedClass.GetFields()[0].GetType()) && oNestedClass.GetFields()[0].GetCategory() != GMLASField::PATH_TO_CHILD_ELEMENT_WITH_LINK) { // In the case the sequence has a single element, // compatible of array type, and no attribute and // no nested classes, then add an array attribute // at the top-level GMLASField oField(oNestedClass.GetFields()[0]); oField.SetName(osPrefixedEltName + "_" + oField.GetName()); if (oField.GetMaxOccurs() == 1 && bEltRepeatedParticle && poEltCT->getParticle() != nullptr) { oField.SetMaxOccurs(nMaxOccursEltParticle); } oField.SetArray(true); oClass.AddField(oField); } else { if (!aoFields.empty() && bEltRepeatedParticle) { // We have attributes and the sequence is // repeated // // // // ... // // // // // So we need to create an // intermediate class to store them GMLASFeatureClass oIntermediateNestedClass; oIntermediateNestedClass.SetName( oClass.GetName() + "_" + osPrefixedEltName); oIntermediateNestedClass.SetXPath( osElementXPath); oIntermediateNestedClass.PrependFields( aoFields); oNestedClass.SetName(oClass.GetName() + "_" + osPrefixedEltName + "_sequence"); oNestedClass.SetXPath(oNestedClass.GetXPath() + szEXTRA_SUFFIX + "sequence"); oNestedClass.SetIsRepeatedSequence(true); GMLASField oField; oField.SetXPath(osElementXPath); oField.SetCategory( GMLASField::PATH_TO_CHILD_ELEMENT_NO_LINK); if (nMaxOccursEltParticle != 1) oField.SetRepetitionOnSequence(true); oField.SetMinOccurs(nMinOccursEltParticle); oField.SetMaxOccurs(nMaxOccursEltParticle); oField.SetRelatedClassXPath( oNestedClass.GetXPath()); oIntermediateNestedClass.AddField(oField); oIntermediateNestedClass.AddNestedClass( oNestedClass); oClass.AddNestedClass(oIntermediateNestedClass); } else { oNestedClass.SetIsRepeatedSequence( bEltRepeatedParticle); oNestedClass.PrependFields(aoFields); oClass.AddNestedClass(oNestedClass); } GMLASField oField; oField.SetName(osPrefixedEltName); oField.SetXPath(osElementXPath); if (bRepeatedParticle) { if (poEltCT->getParticle() != nullptr) { oField.SetMinOccurs(ComposeMinOccurs( nMinOccurs, nMinOccursEltParticle)); oField.SetMaxOccurs(ComposeMaxOccurs( nMaxOccurs, nMaxOccursEltParticle)); } else { oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); } } else if (poEltCT->getParticle() != nullptr) { if (nMaxOccursEltParticle != 1) oField.SetRepetitionOnSequence(true); oField.SetMinOccurs(nMinOccursEltParticle); oField.SetMaxOccurs(nMaxOccursEltParticle); } oField.SetCategory( GMLASField::PATH_TO_CHILD_ELEMENT_NO_LINK); oField.SetRelatedClassXPath(oField.GetXPath()); oClass.AddField(oField); } bNothingMoreToDo = true; } } if (bNothingMoreToDo) { // Nothing to do } else if (bRepeatedParticle) { GMLASFeatureClass oNestedClass; oNestedClass.SetName(oClass.GetName() + "_" + osPrefixedEltName); oNestedClass.SetXPath(osElementXPath); oNestedClass.AppendFields(aoFields); oNestedClass.SetDocumentation(GetAnnotationDoc(poElt)); oClass.AddNestedClass(oNestedClass); GMLASField oField; oField.SetName(osPrefixedEltName); oField.SetXPath(osElementXPath); oField.SetMinOccurs((bIsChoice) ? 0 : nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); oField.SetCategory( GMLASField::PATH_TO_CHILD_ELEMENT_NO_LINK); oField.SetRelatedClassXPath(oField.GetXPath()); oClass.AddField(oField); } else { oClass.AppendFields(aoFields); for (size_t j = 0; j < aoNestedClasses.size(); j++) { oClass.AddNestedClass(aoNestedClasses[j]); } } } } else if (poParticle->getTermType() == XSParticle::TERM_MODELGROUP) { XSModelGroup *psSubModelGroup = poParticle->getModelGroupTerm(); if (bRepeatedParticle) { GMLASFeatureClass oNestedClass; CPLString osGroupName; XSModelGroupDefinition *psGroupDefinition = GetGroupDefinition(psSubModelGroup); if (psGroupDefinition != nullptr) { osGroupName = transcode(psGroupDefinition->getName()); oNestedClass.SetDocumentation( GetAnnotationDoc(psGroupDefinition->getAnnotation())); } else { // Is it a getCompositor() == XSModelGroup::COMPOSITOR_CHOICE) { std::set oSetNewVisitedModelGroups( oSetVisitedModelGroups); GMLASFeatureClass oTmpClass; oTmpClass.SetName(oClass.GetName()); oTmpClass.SetXPath(oClass.GetXPath()); if (!ExploreModelGroup(psSubModelGroup, nullptr, oTmpClass, nRecursionCounter + 1, oSetNewVisitedModelGroups, poModel, oMapCountOccurrencesOfSameName)) { return false; } bool bHasArray = false; std::vector &oTmpFields = oTmpClass.GetFields(); for (size_t j = 0; j < oTmpFields.size(); ++j) { if (oTmpFields[j].IsArray()) { bHasArray = true; break; } } if (!bHasArray) { for (size_t j = 0; j < oTmpFields.size(); ++j) { oTmpFields[j].SetMayAppearOutOfOrder(true); oClass.AddField(oTmpFields[j]); } return true; } } nGroup++; osGroupName = CPLSPrintf("_group%d", nGroup); } oNestedClass.SetName(oClass.GetName() + "_" + osGroupName); oNestedClass.SetIsGroup(true); oNestedClass.SetIsRepeatedSequence(true); // Caution: we will change it afterwards ! oNestedClass.SetXPath(oClass.GetXPath()); std::set oSetNewVisitedModelGroups( oSetVisitedModelGroups); if (!ExploreModelGroup(psSubModelGroup, nullptr, oNestedClass, nRecursionCounter + 1, oSetNewVisitedModelGroups, poModel, oMapCountOccurrencesOfSameName)) { return false; } // This is a nasty hack. We set a unique fake xpath *AFTER* // processing the group, so that we can add a fake GROUP field // pointing to the nested class oNestedClass.SetXPath(oClass.GetXPath() + szEXTRA_SUFFIX + osGroupName); if (m_bUseArrays && oNestedClass.GetFields().size() == 1 && IsCompatibleOfArray(oNestedClass.GetFields()[0].GetType())) { GMLASField oField(oNestedClass.GetFields()[0]); oField.SetMinOccurs( ComposeMinOccurs(oField.GetMinOccurs(), nMinOccurs)); oField.SetMaxOccurs( ComposeMaxOccurs(oField.GetMaxOccurs(), nMaxOccurs)); oField.SetArray(true); oClass.AddField(oField); } else { oClass.AddNestedClass(oNestedClass); GMLASField oField; oField.SetCategory(GMLASField::GROUP); oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(nMaxOccurs); oField.SetRelatedClassXPath(oNestedClass.GetXPath()); oClass.AddField(oField); } } else { std::set oSetNewVisitedModelGroups( oSetVisitedModelGroups); if (!ExploreModelGroup(psSubModelGroup, nullptr, oClass, nRecursionCounter + 1, oSetNewVisitedModelGroups, poModel, oMapCountOccurrencesOfSameName)) { return false; } } } else if (poParticle->getTermType() == XSParticle::TERM_WILDCARD) { /* Special case for a layer that matches everything, as found */ /* in swe:extension */ XSWildcard *poWildcard = poParticle->getWildcardTerm(); GMLASField oField; oField.SetXPath(oClass.GetXPath() + szMATCH_ALL); oField.SetName("value"); oField.SetType(GMLAS_FT_ANYTYPE, szXS_ANY_TYPE); oField.SetIncludeThisEltInBlob(true); oField.SetMinOccurs(nMinOccurs); oField.SetMaxOccurs(1); oField.SetDocumentation( GetAnnotationDoc(poWildcard->getAnnotation())); oClass.AddField(oField); } } return true; }