/****************************************************************************** * * Project: KML Translator * Purpose: Implements OGRLIBKMLDriver * Author: Brian Case, rush at winkey dot org * ****************************************************************************** * Copyright (c) 2010, Brian Case * Copyright (c) 2010-2014, Even Rouault * * SPDX-License-Identifier: MIT *****************************************************************************/ #include "libkml_headers.h" #include #include "ogr_libkml.h" #include "ogrlibkmlstyle.h" #include "ogr_p.h" #include "cpl_vsi_error.h" using kmlbase::Attributes; using kmldom::ContainerPtr; using kmldom::DocumentPtr; using kmldom::ElementPtr; using kmldom::FeaturePtr; using kmldom::FolderPtr; using kmldom::KmlFactory; using kmldom::KmlPtr; using kmldom::LinkPtr; using kmldom::LinkSnippetPtr; using kmldom::NetworkLinkControlPtr; using kmldom::NetworkLinkPtr; using kmldom::SchemaPtr; using kmldom::SnippetPtr; using kmldom::StyleSelectorPtr; using kmlengine::KmzFile; /************************************************************************/ /* OGRLIBKMLParse() */ /************************************************************************/ static ElementPtr OGRLIBKMLParse(const std::string &oKml, std::string *posError) { try { // To allow reading files using an explicit namespace prefix like // we need to use ParseNS (see #6981). But if we use ParseNS, // we have issues reading gx: elements. So use ParseNS only when we have // errors with Parse. This is not completely satisfactory... ElementPtr element = kmldom::Parse(oKml, posError); if (!element) element = kmldom::ParseNS(oKml, posError); return element; } catch (const std::exception &ex) { CPLError(CE_Failure, CPLE_AppDefined, "LIBKML: libstdc++ exception during Parse() : %s", ex.what()); return nullptr; } } /****************************************************************************** OGRLIBKMLDataSource Constructor Args: none Returns: nothing ******************************************************************************/ OGRLIBKMLDataSource::OGRLIBKMLDataSource(KmlFactory *poKmlFactory) : papoLayers(nullptr), nLayers(0), nAllocated(0), bUpdate(false), bUpdated(false), m_papszOptions(nullptr), m_isKml(false), m_poKmlDSKml(nullptr), m_poKmlDSContainer(nullptr), m_poKmlUpdate(nullptr), m_isKmz(false), m_poKmlDocKml(nullptr), m_poKmlDocKmlRoot(nullptr), m_poKmlStyleKml(nullptr), m_isDir(false), m_poKmlFactory(poKmlFactory) { } /************************************************************************/ /* OGRLIBKMLPreProcessInput() */ /************************************************************************/ // Substitute by deprecated since libkml currently // only supports Snippet but ogckml22.xsd has deprecated it in favor of snippet. static void OGRLIBKMLPreProcessInput(std::string &oKml) { size_t nPos = 0; while (true) { nPos = oKml.find("", nPos); if (nPos == std::string::npos) { break; } oKml[nPos + 1] = 'S'; nPos = oKml.find("", nPos); if (nPos == std::string::npos) { break; } oKml[nPos + 2] = 'S'; } // Workaround Windows specific issue with libkml (at least the version // used by OSGeo4W at time of writing), where tabulations as // coordinate separators aren't properly handled //(see https://trac.osgeo.org/gdal/ticket/7231) // Another Windows specific issue is that if the content of // is non-empty and does not contain any digit, // libkml hangs (see https://trac.osgeo.org/gdal/ticket/7232) nPos = 0; while (true) { nPos = oKml.find("", nPos); if (nPos == std::string::npos) { break; } size_t nPosEnd = oKml.find("", nPos); if (nPosEnd == std::string::npos) { break; } nPos += strlen(""); size_t nPosAfterCoordinates = nPos; bool bDigitFound = false; for (; nPos < nPosEnd; nPos++) { char ch = oKml[nPos]; if (ch >= '0' && ch <= '9') bDigitFound = true; else if (ch == '\t' || ch == '\n') oKml[nPos] = ' '; } if (!bDigitFound) { oKml.replace(nPosAfterCoordinates, nPosEnd + strlen("") - nPosAfterCoordinates, ""); nPos = nPosAfterCoordinates + strlen(""); } } // Some non conformant file may contain // MultiPolygon/MultiLineString/MultiPoint See // https://github.com/OSGeo/gdal/issues/4031 Replace them by MultiGeometry. nPos = 0; while (true) { const char *pszStartTag = ""; const char *pszEndTag = ""; CPL_IGNORE_RET_VAL(pszEndTag); // Make CSA happy auto nNewPos = oKml.find(pszStartTag, nPos); if (nNewPos != std::string::npos) { pszEndTag = ""; } else { pszStartTag = ""; nNewPos = oKml.find(pszStartTag, nPos); if (nNewPos != std::string::npos) { pszEndTag = ""; } else { pszStartTag = ""; nNewPos = oKml.find(pszStartTag, nPos); if (nNewPos != std::string::npos) pszEndTag = ""; else break; } } nPos = nNewPos; oKml.replace(nPos, strlen(pszStartTag), ""); nPos = oKml.find(pszEndTag, nPos); if (nPos == std::string::npos) break; oKml.replace(nPos, strlen(pszEndTag), ""); } } /************************************************************************/ /* OGRLIBKMLRemoveSpaces() */ /************************************************************************/ static void OGRLIBKMLRemoveSpaces(std::string &osKml, const std::string &osNeedle) { size_t nPos = 0; const std::string osLtNeedle(std::string("<").append(osNeedle)); std::string osTmp; std::string osRet; while (true) { auto nPosNew = osKml.find(osLtNeedle, nPos); if (nPosNew == std::string::npos) { osRet.append(osKml, nPos); break; } const size_t nPosOri = nPosNew; nPosNew = osKml.find(">\n", nPosNew); if (nPosNew == std::string::npos || nPosNew + 2 == osKml.size()) { osRet.append(osKml, nPos); break; } // Skip \n character osRet.append(osKml, nPos, nPosNew - nPos + 1); nPos = nPosNew + 2; // Remove leading spaces of " " osTmp.clear(); for (size_t nPosTmp = nPosOri - 1; osKml[nPosTmp] == ' '; nPosTmp--) { osTmp += ' '; } osTmp += "'; nPosNew = osKml.find(osTmp, nPos); if (nPosNew != std::string::npos) { osRet.append(osKml, nPos, nPosNew - nPos); osRet += "'; nPos = nPosNew + osTmp.size(); } else { osRet.append(osKml, nPos); break; } } osKml = std::move(osRet); } /************************************************************************/ /* OGRLIBKMLPostProcessOutput() */ /************************************************************************/ // Substitute deprecated by since libkml currently // only supports Snippet but ogckml22.xsd has deprecated it in favor of snippet. static void OGRLIBKMLPostProcessOutput(std::string &oKml) { // Manually add node since libkml does not produce it currently // and this is useful in some circumstances (#5407). if (!(oKml.size() >= 2 && oKml[0] == '<' && oKml[1] == '?')) oKml = "\n" + oKml; size_t nPos = 0; while (true) { nPos = oKml.find("", nPos); if (nPos == std::string::npos) { break; } oKml[nPos + 1] = 's'; nPos = oKml.find("", nPos); if (nPos == std::string::npos) { break; } oKml[nPos + 2] = 's'; } // Fix indentation problems. OGRLIBKMLRemoveSpaces(oKml, "snippet"); OGRLIBKMLRemoveSpaces(oKml, "linkSnippet"); OGRLIBKMLRemoveSpaces(oKml, "SimpleData"); } /****************************************************************************** Method to write a single file ds .kml at ds destroy. Args: none Returns: nothing ******************************************************************************/ bool OGRLIBKMLDataSource::WriteKml() { std::string oKmlFilename = GetDescription(); if (m_poKmlDSContainer && m_poKmlDSContainer->IsA(kmldom::Type_Document)) { DocumentPtr poKmlDocument = AsDocument(m_poKmlDSContainer); ParseDocumentOptions(m_poKmlDSKml, poKmlDocument); for (int iLayer = 0; iLayer < nLayers; iLayer++) { SchemaPtr poKmlSchema = nullptr; if ((poKmlSchema = papoLayers[iLayer]->GetKmlSchema())) { const size_t nKmlSchemas = poKmlDocument->get_schema_array_size(); SchemaPtr poKmlSchema2 = nullptr; for (size_t iKmlSchema = 0; iKmlSchema < nKmlSchemas; iKmlSchema++) { poKmlSchema2 = poKmlDocument->get_schema_array_at(iKmlSchema); if (poKmlSchema2 == poKmlSchema) break; } if (poKmlSchema2 != poKmlSchema) poKmlDocument->add_schema(poKmlSchema); } papoLayers[iLayer]->Finalize(poKmlDocument); } } else { ParseDocumentOptions(m_poKmlDSKml, nullptr); } std::string oKmlOut; oKmlOut = kmldom::SerializePretty(m_poKmlDSKml); OGRLIBKMLPostProcessOutput(oKmlOut); bool bRet = true; if (!oKmlOut.empty()) { VSILFILE *fp = VSIFOpenExL(oKmlFilename.c_str(), "wb", true); if (fp == nullptr) { CPLError(CE_Failure, CPLE_FileIO, "Error writing %s: %s", oKmlFilename.c_str(), VSIGetLastErrorMsg()); return false; } if (VSIFWriteL(oKmlOut.data(), 1, oKmlOut.size(), fp) != oKmlOut.size()) bRet = false; if (VSIFCloseL(fp) != 0) bRet = false; } return bRet; } /************************************************************************/ /* OGRLIBKMLCreateOGCKml22() */ /************************************************************************/ static KmlPtr OGRLIBKMLCreateOGCKml22(KmlFactory *poFactory, CSLConstList papszOptions = nullptr) { const char *pszAuthorName = CSLFetchNameValue(papszOptions, "AUTHOR_NAME"); const char *pszAuthorURI = CSLFetchNameValue(papszOptions, "AUTHOR_URI"); const char *pszAuthorEmail = CSLFetchNameValue(papszOptions, "AUTHOR_EMAIL"); const char *pszLink = CSLFetchNameValue(papszOptions, "LINK"); const bool bWithAtom = pszAuthorName != nullptr || pszAuthorURI != nullptr || pszAuthorEmail != nullptr || pszLink != nullptr; KmlPtr kml = poFactory->CreateKml(); if (bWithAtom) { const char *kAttrs[] = {"xmlns", "http://www.opengis.net/kml/2.2", "xmlns:atom", "http://www.w3.org/2005/Atom", nullptr}; kml->AddUnknownAttributes(Attributes::Create(kAttrs)); } else { const char *kAttrs[] = {"xmlns", "http://www.opengis.net/kml/2.2", nullptr}; kml->AddUnknownAttributes(Attributes::Create(kAttrs)); } return kml; } /****************************************************************************** Method to write a ds .kmz at ds destroy. Args: none Returns: nothing ******************************************************************************/ bool OGRLIBKMLDataSource::WriteKmz() { std::string osTmpFilename; if (!VSISupportsRandomWrite(GetDescription(), false) || EQUAL(CPLGetConfigOption("CPL_VSIL_USE_TEMP_FILE_FOR_RANDOM_WRITE", ""), "FORCED")) { osTmpFilename = CPLGenerateTempFilenameSafe( CPLGetBasenameSafe(GetDescription()).c_str()); } void *hZIP = CPLCreateZip(osTmpFilename.empty() ? GetDescription() : osTmpFilename.c_str(), nullptr); if (!hZIP) { CPLError(CE_Failure, CPLE_NoWriteAccess, "Error creating %s: %s", GetDescription(), VSIGetLastErrorMsg()); return false; } bool bRet = true; /***** write out the doc.kml ****/ const char *pszUseDocKml = CPLGetConfigOption("LIBKML_USE_DOC.KML", "yes"); if (CPLTestBool(pszUseDocKml) && (m_poKmlDocKml || m_poKmlUpdate)) { // If we do not have the doc.kmlroot // make it and add the container. if (!m_poKmlDocKmlRoot) { m_poKmlDocKmlRoot = OGRLIBKMLCreateOGCKml22(m_poKmlFactory, m_papszOptions); auto kml = AsKml(m_poKmlDocKmlRoot); if (m_poKmlDocKml) { if (kml) { kml->set_feature(m_poKmlDocKml); } } ParseDocumentOptions(std::move(kml), AsDocument(m_poKmlDocKml)); } std::string oKmlOut = kmldom::SerializePretty(m_poKmlDocKmlRoot); OGRLIBKMLPostProcessOutput(oKmlOut); if (CPLCreateFileInZip(hZIP, "doc.kml", nullptr) != CE_None || CPLWriteFileInZip(hZIP, oKmlOut.data(), static_cast(oKmlOut.size())) != CE_None) { bRet = false; CPLError(CE_Failure, CPLE_FileIO, "ERROR adding %s to %s", "doc.kml", GetDescription()); } CPLCloseFileInZip(hZIP); } /***** loop though the layers and write them *****/ for (int iLayer = 0; iLayer < nLayers && !m_poKmlUpdate; iLayer++) { ContainerPtr poKmlContainer = papoLayers[iLayer]->GetKmlLayer(); if (poKmlContainer->IsA(kmldom::Type_Document)) { DocumentPtr poKmlDocument = AsDocument(poKmlContainer); SchemaPtr poKmlSchema = papoLayers[iLayer]->GetKmlSchema(); if (!poKmlDocument->get_schema_array_size() && poKmlSchema && poKmlSchema->get_simplefield_array_size()) { poKmlDocument->add_schema(std::move(poKmlSchema)); } papoLayers[iLayer]->Finalize(std::move(poKmlDocument)); } // If we do not have the layers root // make it and add the container. KmlPtr poKmlKml = nullptr; if (!(poKmlKml = AsKml(papoLayers[iLayer]->GetKmlLayerRoot()))) { poKmlKml = OGRLIBKMLCreateOGCKml22(m_poKmlFactory); poKmlKml->set_feature(poKmlContainer); } std::string oKmlOut = kmldom::SerializePretty(poKmlKml); OGRLIBKMLPostProcessOutput(oKmlOut); if (iLayer == 0 && CPLTestBool(pszUseDocKml)) { CPL_IGNORE_RET_VAL(CPLCreateFileInZip(hZIP, "layers/", nullptr)); } const char *pszLayerFileName = nullptr; if (CPLTestBool(pszUseDocKml)) pszLayerFileName = CPLSPrintf("layers/%s", papoLayers[iLayer]->GetFileName()); else pszLayerFileName = papoLayers[iLayer]->GetFileName(); if (CPLCreateFileInZip(hZIP, pszLayerFileName, nullptr) != CE_None || CPLWriteFileInZip(hZIP, oKmlOut.data(), static_cast(oKmlOut.size())) != CE_None) CPLError(CE_Failure, CPLE_FileIO, "ERROR adding %s to %s", papoLayers[iLayer]->GetFileName(), GetDescription()); CPLCloseFileInZip(hZIP); } /***** write the style table *****/ if (m_poKmlStyleKml) { KmlPtr poKmlKml = OGRLIBKMLCreateOGCKml22(m_poKmlFactory); poKmlKml->set_feature(m_poKmlStyleKml); std::string oKmlOut = kmldom::SerializePretty(poKmlKml); OGRLIBKMLPostProcessOutput(oKmlOut); if (CPLCreateFileInZip(hZIP, "style/", nullptr) != CE_None || CPLCreateFileInZip(hZIP, "style/style.kml", nullptr) != CE_None || CPLWriteFileInZip(hZIP, oKmlOut.data(), static_cast(oKmlOut.size())) != CE_None) { bRet = false; CPLError(CE_Failure, CPLE_FileIO, "ERROR adding %s to %s", "style/style.kml", GetDescription()); } CPLCloseFileInZip(hZIP); } CPLCloseZip(hZIP); if (!osTmpFilename.empty()) { if (bRet) { bRet = CPLCopyFile(GetDescription(), osTmpFilename.c_str()) == 0; if (!bRet) CPLError(CE_Failure, CPLE_FileIO, "Cannot copy temporary file to %s", GetDescription()); } VSIUnlink(osTmpFilename.c_str()); } return bRet; } /****************************************************************************** Method to write a dir ds at ds destroy. Args: none Returns: nothing ******************************************************************************/ bool OGRLIBKMLDataSource::WriteDir() { /***** write out the doc.kml ****/ const char *pszUseDocKml = CPLGetConfigOption("LIBKML_USE_DOC.KML", "yes"); bool bRet = true; if (CPLTestBool(pszUseDocKml) && (m_poKmlDocKml || m_poKmlUpdate)) { // If we don't have the doc.kml root // make it and add the container. if (!m_poKmlDocKmlRoot) { m_poKmlDocKmlRoot = OGRLIBKMLCreateOGCKml22(m_poKmlFactory, m_papszOptions); auto kml = AsKml(m_poKmlDocKmlRoot); if (kml) { if (m_poKmlDocKml) kml->set_feature(m_poKmlDocKml); } ParseDocumentOptions(std::move(kml), AsDocument(m_poKmlDocKml)); } std::string oKmlOut = kmldom::SerializePretty(m_poKmlDocKmlRoot); OGRLIBKMLPostProcessOutput(oKmlOut); const std::string osOutfile = CPLFormFilenameSafe(GetDescription(), "doc.kml", nullptr); VSILFILE *fp = VSIFOpenExL(osOutfile.c_str(), "wb", true); if (fp == nullptr) { CPLError(CE_Failure, CPLE_FileIO, "Error writing %s to %s: %s", "doc.kml", GetDescription(), VSIGetLastErrorMsg()); return false; } if (VSIFWriteL(oKmlOut.data(), 1, oKmlOut.size(), fp) != oKmlOut.size()) bRet = false; if (VSIFCloseL(fp) != 0) bRet = false; } /***** loop though the layers and write them *****/ for (int iLayer = 0; iLayer < nLayers && !m_poKmlUpdate; iLayer++) { ContainerPtr poKmlContainer = papoLayers[iLayer]->GetKmlLayer(); if (poKmlContainer->IsA(kmldom::Type_Document)) { DocumentPtr poKmlDocument = AsDocument(poKmlContainer); SchemaPtr poKmlSchema = papoLayers[iLayer]->GetKmlSchema(); if (!poKmlDocument->get_schema_array_size() && poKmlSchema && poKmlSchema->get_simplefield_array_size()) { poKmlDocument->add_schema(std::move(poKmlSchema)); } papoLayers[iLayer]->Finalize(std::move(poKmlDocument)); } // If we do not have the layers root // make it and add the container. KmlPtr poKmlKml = nullptr; if (!(poKmlKml = AsKml(papoLayers[iLayer]->GetKmlLayerRoot()))) { poKmlKml = OGRLIBKMLCreateOGCKml22(m_poKmlFactory); poKmlKml->set_feature(poKmlContainer); } std::string oKmlOut = kmldom::SerializePretty(poKmlKml); OGRLIBKMLPostProcessOutput(oKmlOut); const std::string osOutfile = CPLFormFilenameSafe( GetDescription(), papoLayers[iLayer]->GetFileName(), nullptr); VSILFILE *fp = VSIFOpenL(osOutfile.c_str(), "wb"); if (fp == nullptr) { CPLError(CE_Failure, CPLE_FileIO, "ERROR Writing %s to %s", papoLayers[iLayer]->GetFileName(), GetDescription()); return false; } if (VSIFWriteL(oKmlOut.data(), 1, oKmlOut.size(), fp) != oKmlOut.size()) bRet = false; if (VSIFCloseL(fp) != 0) bRet = false; } /***** write the style table *****/ if (m_poKmlStyleKml) { KmlPtr poKmlKml = OGRLIBKMLCreateOGCKml22(m_poKmlFactory); poKmlKml->set_feature(m_poKmlStyleKml); std::string oKmlOut = kmldom::SerializePretty(poKmlKml); OGRLIBKMLPostProcessOutput(oKmlOut); const std::string osOutfile = CPLFormFilenameSafe(GetDescription(), "style.kml", nullptr); VSILFILE *fp = VSIFOpenL(osOutfile.c_str(), "wb"); if (fp == nullptr) { CPLError(CE_Failure, CPLE_FileIO, "ERROR Writing %s to %s", "style.kml", GetDescription()); return false; } if (VSIFWriteL(oKmlOut.data(), 1, oKmlOut.size(), fp) != oKmlOut.size()) bRet = false; if (VSIFCloseL(fp) != 0) bRet = false; } return bRet; } /****************************************************************************** Method to write the datasource to disk. Args: none Returns nothing ******************************************************************************/ CPLErr OGRLIBKMLDataSource::FlushCache(bool /* bAtClosing */) { if (!bUpdated) return CE_None; CPLErr eErr = CE_None; if (bUpdate && IsKml()) { if (!WriteKml()) eErr = CE_Failure; } else if (bUpdate && IsKmz()) { if (!WriteKmz()) eErr = CE_Failure; } else if (bUpdate && IsDir()) { if (!WriteDir()) eErr = CE_Failure; } bUpdated = false; return eErr; } /****************************************************************************** OGRLIBKMLDataSource Destructor Args: none Returns: nothing ******************************************************************************/ OGRLIBKMLDataSource::~OGRLIBKMLDataSource() { /***** sync the DS to disk *****/ OGRLIBKMLDataSource::FlushCache(true); for (int i = 0; i < nLayers; i++) delete papoLayers[i]; CPLFree(papoLayers); CSLDestroy(m_papszOptions); } /****************************************************************************** Method to parse a schemas out of a document. Args: poKmlDocument pointer to the document to parse Returns: nothing ******************************************************************************/ SchemaPtr OGRLIBKMLDataSource::FindSchema(const char *pszSchemaUrl) { if (!pszSchemaUrl || !*pszSchemaUrl) return nullptr; char *pszID = nullptr; char *pszFile = nullptr; char *pszSchemaName = nullptr; DocumentPtr poKmlDocument = nullptr; SchemaPtr poKmlSchemaResult = nullptr; if (*pszSchemaUrl == '#') { pszID = CPLStrdup(pszSchemaUrl + 1); /***** kml *****/ if (IsKml() && m_poKmlDSContainer->IsA(kmldom::Type_Document)) poKmlDocument = AsDocument(m_poKmlDSContainer); /***** kmz *****/ else if ((IsKmz() || IsDir()) && m_poKmlDocKml && m_poKmlDocKml->IsA(kmldom::Type_Document)) poKmlDocument = AsDocument(m_poKmlDocKml); } else if (const char *pszPound = strchr(pszSchemaUrl, '#')) { pszFile = CPLStrdup(pszSchemaUrl); pszID = CPLStrdup(pszPound + 1); pszFile[pszPound - pszSchemaUrl] = '\0'; } else { pszSchemaName = CPLStrdup(pszSchemaUrl); /***** kml *****/ if (IsKml() && m_poKmlDSContainer->IsA(kmldom::Type_Document)) poKmlDocument = AsDocument(m_poKmlDSContainer); /***** kmz *****/ else if ((IsKmz() || IsDir()) && m_poKmlDocKml && m_poKmlDocKml->IsA(kmldom::Type_Document)) poKmlDocument = AsDocument(m_poKmlDocKml); } if (poKmlDocument) { size_t nKmlSchemas = poKmlDocument->get_schema_array_size(); for (size_t iKmlSchema = 0; iKmlSchema < nKmlSchemas; iKmlSchema++) { SchemaPtr poKmlSchema = poKmlDocument->get_schema_array_at(iKmlSchema); if (poKmlSchema->has_id() && pszID) { if (EQUAL(pszID, poKmlSchema->get_id().c_str())) { poKmlSchemaResult = std::move(poKmlSchema); break; } } else if (poKmlSchema->has_name() && pszSchemaName) { if (EQUAL(pszSchemaName, poKmlSchema->get_name().c_str())) { poKmlSchemaResult = std::move(poKmlSchema); break; } } } } CPLFree(pszFile); CPLFree(pszID); CPLFree(pszSchemaName); return poKmlSchemaResult; } /****************************************************************************** Method to allocate memory for the layer array, create the layer, and add it to the layer array. Args: pszLayerName the name of the layer eGType the layers geometry type poOgrDS pointer to the datasource the layer is in poKmlRoot pointer to the root kml element of the layer pszFileName the filename of the layer bNew true if its a new layer bUpdate true if the layer is writable nGuess a guess at the number of additional layers we are going to need Returns: Pointer to the new layer ******************************************************************************/ OGRLIBKMLLayer *OGRLIBKMLDataSource::AddLayer( const char *pszLayerName, OGRwkbGeometryType eGType, const OGRSpatialReference *poSRS, OGRLIBKMLDataSource *poOgrDS, ElementPtr poKmlRoot, ContainerPtr poKmlContainer, const char *pszFileName, bool bNew, bool bUpdateIn, int nGuess) { // Build unique layer name CPLString osUniqueLayername(pszLayerName); int nIter = 2; while (true) { if (GetLayerByName(osUniqueLayername) == nullptr) break; osUniqueLayername = CPLSPrintf("%s (#%d)", pszLayerName, nIter); nIter++; } /***** check to see if we have enough space to store the layer *****/ if (nLayers == nAllocated) { nAllocated += nGuess; papoLayers = static_cast( CPLRealloc(papoLayers, sizeof(OGRLIBKMLLayer *) * nAllocated)); } /***** create the layer *****/ OGRLIBKMLLayer *poOgrLayer = new OGRLIBKMLLayer( osUniqueLayername, eGType, poSRS, poOgrDS, std::move(poKmlRoot), std::move(poKmlContainer), m_poKmlUpdate, pszFileName, bNew, bUpdateIn); /***** add the layer to the array *****/ const int iLayer = nLayers++; papoLayers[iLayer] = poOgrLayer; osUniqueLayername.toupper(); m_oMapLayers[std::move(osUniqueLayername)] = poOgrLayer; return poOgrLayer; } /****************************************************************************** Method to parse multiple layers out of a container. Args: poKmlContainer pointer to the container to parse Returns: number of features in the container that are not another container ******************************************************************************/ int OGRLIBKMLDataSource::ParseLayers(ContainerPtr poKmlContainer, bool bRecurse) { /***** if container is null just bail now *****/ if (!poKmlContainer) return 0; const size_t nKmlFeatures = poKmlContainer->get_feature_array_size(); /***** loop over the container to separate the style, layers, etc *****/ int nResult = 0; for (size_t iKmlFeature = 0; iKmlFeature < nKmlFeatures; iKmlFeature++) { FeaturePtr poKmlFeat = poKmlContainer->get_feature_array_at(iKmlFeature); /***** container *****/ if (poKmlFeat->IsA(kmldom::Type_Container)) { if (bRecurse) { /***** see if the container has a name *****/ std::string oKmlFeatName; if (poKmlFeat->has_name()) { /* Strip leading and trailing spaces */ const char *l_pszName = poKmlFeat->get_name().c_str(); while (*l_pszName == ' ' || *l_pszName == '\n' || *l_pszName == '\r' || *l_pszName == '\t') l_pszName++; oKmlFeatName = l_pszName; int nSize = (int)oKmlFeatName.size(); while (nSize > 0 && (oKmlFeatName[nSize - 1] == ' ' || oKmlFeatName[nSize - 1] == '\n' || oKmlFeatName[nSize - 1] == '\r' || oKmlFeatName[nSize - 1] == '\t')) { nSize--; oKmlFeatName.resize(nSize); } } /***** use the feature index number as the name *****/ /***** not sure i like this c++ ich *****/ else { std::stringstream oOut; oOut << iKmlFeature; oKmlFeatName = "Layer"; oKmlFeatName.append(oOut.str()); } /***** create the layer *****/ AddLayer(oKmlFeatName.c_str(), wkbUnknown, nullptr, this, nullptr, AsContainer(poKmlFeat), "", false, bUpdate, static_cast(nKmlFeatures)); /***** check if any features are another layer *****/ ParseLayers(AsContainer(poKmlFeat), true); } } else { nResult++; } } return nResult; } /****************************************************************************** Function to get the container from the kmlroot. Args: poKmlRoot the root element Returns: root if its a container, if its a kml the container it contains, or NULL ******************************************************************************/ static ContainerPtr GetContainerFromRoot(KmlFactory *poKmlFactory, ElementPtr poKmlRoot) { ContainerPtr poKmlContainer = nullptr; const bool bReadGroundOverlay = CPLTestBool(CPLGetConfigOption("LIBKML_READ_GROUND_OVERLAY", "YES")); if (poKmlRoot) { /***** skip over the we want the container *****/ if (poKmlRoot->IsA(kmldom::Type_kml)) { KmlPtr poKmlKml = AsKml(poKmlRoot); if (poKmlKml && poKmlKml->has_feature()) { FeaturePtr poKmlFeat = poKmlKml->get_feature(); if (poKmlFeat->IsA(kmldom::Type_Container)) poKmlContainer = AsContainer(poKmlFeat); else if (poKmlFeat->IsA(kmldom::Type_Placemark) || (bReadGroundOverlay && poKmlFeat->IsA(kmldom::Type_GroundOverlay))) { poKmlContainer = poKmlFactory->CreateDocument(); poKmlContainer->add_feature( kmldom::AsFeature(kmlengine::Clone(poKmlFeat))); } } } else if (poKmlRoot->IsA(kmldom::Type_Container)) { poKmlContainer = AsContainer(std::move(poKmlRoot)); } } return poKmlContainer; } /****************************************************************************** Method to parse a kml string into the style table. ******************************************************************************/ int OGRLIBKMLDataSource::ParseIntoStyleTable(std::string *poKmlStyleKml, const char *pszMyStylePath) { /***** parse the kml into the dom *****/ std::string oKmlErrors; ElementPtr poKmlRoot = OGRLIBKMLParse(*poKmlStyleKml, &oKmlErrors); if (!poKmlRoot) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing style kml %s :%s", pszMyStylePath, oKmlErrors.c_str()); return false; } ContainerPtr poKmlContainer = nullptr; if (!(poKmlContainer = GetContainerFromRoot(m_poKmlFactory, std::move(poKmlRoot)))) { return false; } ParseStyles(AsDocument(std::move(poKmlContainer)), &m_poStyleTable); m_osStylePath = pszMyStylePath; return true; } /****************************************************************************** Method to open a kml file. Args: pszFilename file to open bUpdate update mode Returns: True on success, false on failure ******************************************************************************/ int OGRLIBKMLDataSource::OpenKml(const char *pszFilename, int bUpdateIn) { std::string oKmlKml; std::string osBuffer; osBuffer.resize(4096); VSILFILE *fp = VSIFOpenL(pszFilename, "rb"); if (fp == nullptr) { CPLError(CE_Failure, CPLE_OpenFailed, "Cannot open %s", pszFilename); return FALSE; } int nRead = 0; while ((nRead = static_cast( VSIFReadL(&osBuffer[0], 1, osBuffer.size(), fp))) != 0) { try { oKmlKml.append(osBuffer.c_str(), nRead); } catch (const std::exception &ex) { CPLDebug("LIBKML", "libstdc++ exception during ingestion: %s", ex.what()); VSIFCloseL(fp); return FALSE; } } OGRLIBKMLPreProcessInput(oKmlKml); VSIFCloseL(fp); CPLLocaleC oLocaleForcer; /***** parse the kml into the DOM *****/ std::string oKmlErrors; m_poKmlDSKml = AsKml(OGRLIBKMLParse(oKmlKml, &oKmlErrors)); if (!m_poKmlDSKml) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing kml %s :%s", pszFilename, oKmlErrors.c_str()); return FALSE; } /***** get the container from root *****/ if (!(m_poKmlDSContainer = GetContainerFromRoot(m_poKmlFactory, m_poKmlDSKml))) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing kml %s :%s %s", pszFilename, "This file does not fit the OGR model,", "there is no container element at the root."); return FALSE; } m_isKml = true; /***** get the styles *****/ ParseStyles(AsDocument(m_poKmlDSContainer), &m_poStyleTable); /***** parse for layers *****/ int nPlacemarks = ParseLayers(m_poKmlDSContainer, false); /***** if there is placemarks in the root its a layer *****/ if (nPlacemarks) { std::string layername_default(CPLGetBasenameSafe(pszFilename)); if (m_poKmlDSContainer->has_name()) { layername_default = m_poKmlDSContainer->get_name(); } AddLayer(layername_default.c_str(), wkbUnknown, nullptr, this, m_poKmlDSKml, m_poKmlDSContainer, pszFilename, FALSE, bUpdateIn, 1); } ParseLayers(m_poKmlDSContainer, true); return TRUE; } /****************************************************************************** Method to open a kmz file. Args: pszFilename file to open bUpdate update mode Returns: True on success, false on failure ******************************************************************************/ int OGRLIBKMLDataSource::OpenKmz(const char *pszFilename, int bUpdateIn) { std::string oKmlKmz; char szBuffer[1024 + 1] = {}; VSILFILE *fp = VSIFOpenL(pszFilename, "rb"); if (fp == nullptr) { CPLError(CE_Failure, CPLE_OpenFailed, "Cannot open %s", pszFilename); return FALSE; } int nRead = 0; while ((nRead = static_cast(VSIFReadL(szBuffer, 1, 1024, fp))) != 0) { try { oKmlKmz.append(szBuffer, nRead); } catch (const std::bad_alloc &) { VSIFCloseL(fp); return FALSE; } } VSIFCloseL(fp); KmzFile *poKmlKmzfile = KmzFile::OpenFromString(oKmlKmz); if (!poKmlKmzfile) { CPLError(CE_Failure, CPLE_OpenFailed, "%s is not a valid kmz file", pszFilename); return FALSE; } CPLLocaleC oLocaleForcer; /***** read the doc.kml *****/ std::string oKmlKml; std::string oKmlKmlPath; if (!poKmlKmzfile->ReadKmlAndGetPath(&oKmlKml, &oKmlKmlPath)) { return FALSE; } /***** parse the kml into the DOM *****/ std::string oKmlErrors; ElementPtr poKmlDocKmlRoot = OGRLIBKMLParse(oKmlKml, &oKmlErrors); if (!poKmlDocKmlRoot) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing kml layer %s from %s :%s", oKmlKmlPath.c_str(), pszFilename, oKmlErrors.c_str()); return FALSE; } /***** Get the child container from root. *****/ ContainerPtr poKmlContainer = nullptr; if (!(poKmlContainer = GetContainerFromRoot(m_poKmlFactory, poKmlDocKmlRoot))) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing %s from %s :%s", oKmlKmlPath.c_str(), pszFilename, "kml contains no Containers"); return FALSE; } /***** loop over the container looking for network links *****/ size_t nKmlFeatures = poKmlContainer->get_feature_array_size(); int nLinks = 0; for (size_t iKmlFeature = 0; iKmlFeature < nKmlFeatures; iKmlFeature++) { FeaturePtr poKmlFeat = poKmlContainer->get_feature_array_at(iKmlFeature); /***** is it a network link? *****/ if (!poKmlFeat->IsA(kmldom::Type_NetworkLink)) continue; NetworkLinkPtr poKmlNetworkLink = AsNetworkLink(poKmlFeat); /***** does it have a link? *****/ if (!poKmlNetworkLink->has_link()) continue; LinkPtr poKmlLink = poKmlNetworkLink->get_link(); /***** does the link have a href? *****/ if (!poKmlLink->has_href()) continue; const kmlengine::Href oKmlHref(poKmlLink->get_href()); /***** is the link relative? *****/ if (oKmlHref.IsRelativePath()) { nLinks++; std::string oKml; if (poKmlKmzfile->ReadFile(oKmlHref.get_path().c_str(), &oKml)) { /***** parse the kml into the DOM *****/ oKmlErrors.clear(); ElementPtr poKmlLyrRoot = OGRLIBKMLParse(oKml, &oKmlErrors); if (!poKmlLyrRoot) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing kml layer %s from %s :%s", oKmlHref.get_path().c_str(), pszFilename, oKmlErrors.c_str()); continue; } /***** get the container from root *****/ ContainerPtr poKmlLyrContainer = GetContainerFromRoot(m_poKmlFactory, poKmlLyrRoot); if (!poKmlLyrContainer) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing kml layer %s from %s :%s", oKmlHref.get_path().c_str(), pszFilename, oKmlErrors.c_str()); continue; } /***** create the layer *****/ const std::string osLayerName = poKmlNetworkLink->has_name() ? poKmlNetworkLink->get_name() : CPLGetBasenameSafe(oKmlHref.get_path().c_str()); AddLayer(osLayerName.c_str(), wkbUnknown, nullptr, this, std::move(poKmlLyrRoot), poKmlLyrContainer, oKmlHref.get_path().c_str(), false, bUpdateIn, static_cast(nKmlFeatures)); /***** check if any features are another layer *****/ ParseLayers(std::move(poKmlLyrContainer), true); } } } /***** if the doc.kml has links store it so if were in update mode we can * write it *****/ if (nLinks) { m_poKmlDocKml = std::move(poKmlContainer); m_poKmlDocKmlRoot = std::move(poKmlDocKmlRoot); } /***** if the doc.kml has no links treat it as a normal kml file *****/ else { /* TODO: There could still be a separate styles file in the KMZ if there is this would be a layer style table IF its only a single layer. */ /***** get the styles *****/ ParseStyles(AsDocument(poKmlContainer), &m_poStyleTable); /***** parse for layers *****/ const int nPlacemarks = ParseLayers(poKmlContainer, false); /***** if there is placemarks in the root its a layer *****/ if (nPlacemarks) { std::string layername_default(CPLGetBasenameSafe(pszFilename)); if (poKmlContainer->has_name()) { layername_default = poKmlContainer->get_name(); } AddLayer(layername_default.c_str(), wkbUnknown, nullptr, this, std::move(poKmlDocKmlRoot), poKmlContainer, pszFilename, false, bUpdateIn, 1); } ParseLayers(std::move(poKmlContainer), true); } /***** read the style table if it has one *****/ std::string oKmlStyleKml; if (poKmlKmzfile->ReadFile("style/style.kml", &oKmlStyleKml)) ParseIntoStyleTable(&oKmlStyleKml, "style/style.kml"); /***** cleanup *****/ delete poKmlKmzfile; m_isKmz = true; return TRUE; } /****************************************************************************** Method to open a dir. Args: pszFilename Dir to open bUpdate update mode Returns: True on success, false on failure ******************************************************************************/ int OGRLIBKMLDataSource::OpenDir(const char *pszFilename, int bUpdateIn) { char **papszDirList = VSIReadDir(pszFilename); if (papszDirList == nullptr) return FALSE; const int nFiles = CSLCount(papszDirList); for (int iFile = 0; iFile < nFiles; iFile++) { /***** make sure its a .kml file *****/ if (!EQUAL(CPLGetExtensionSafe(papszDirList[iFile]).c_str(), "kml")) continue; /***** read the file *****/ std::string oKmlKml; char szBuffer[1024 + 1] = {}; const CPLString osFilePath = CPLFormFilenameSafe(pszFilename, papszDirList[iFile], nullptr); VSILFILE *fp = VSIFOpenL(osFilePath, "rb"); if (fp == nullptr) { CPLError(CE_Failure, CPLE_OpenFailed, "Cannot open %s", osFilePath.c_str()); continue; } int nRead = 0; while ((nRead = static_cast(VSIFReadL(szBuffer, 1, 1024, fp))) != 0) { try { oKmlKml.append(szBuffer, nRead); } catch (const std::bad_alloc &) { VSIFCloseL(fp); CSLDestroy(papszDirList); return FALSE; } } VSIFCloseL(fp); CPLLocaleC oLocaleForcer; /***** parse the kml into the DOM *****/ std::string oKmlErrors; ElementPtr poKmlRoot = OGRLIBKMLParse(oKmlKml, &oKmlErrors); if (!poKmlRoot) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing kml layer %s from %s :%s", osFilePath.c_str(), pszFilename, oKmlErrors.c_str()); continue; } /***** Get the container from the root *****/ ContainerPtr poKmlContainer = nullptr; if (!(poKmlContainer = GetContainerFromRoot(m_poKmlFactory, poKmlRoot))) { CPLError(CE_Failure, CPLE_OpenFailed, "ERROR parsing kml %s :%s %s", pszFilename, "This file does not fit the OGR model,", "there is no container element at the root."); continue; } /***** is it a style table? *****/ if (EQUAL(papszDirList[iFile], "style.kml")) { ParseStyles(AsDocument(poKmlContainer), &m_poStyleTable); m_osStylePath = "style.kml"; continue; } // Root document generated by ourselves. Contains nothing of interest if (poKmlContainer->has_id() && poKmlContainer->get_id() == "root_doc") { continue; } const std::string osLayerName = poKmlContainer->has_name() ? poKmlContainer->get_name() : std::string(CPLGetBasenameSafe(osFilePath.c_str())); /***** create the layer *****/ AddLayer(osLayerName.c_str(), wkbUnknown, nullptr, this, std::move(poKmlRoot), poKmlContainer, osFilePath.c_str(), false, bUpdateIn, nFiles); /***** check if any features are another layer *****/ ParseLayers(std::move(poKmlContainer), true); } CSLDestroy(papszDirList); if (nLayers > 0) { m_isDir = true; return TRUE; } return FALSE; } /****************************************************************************** Method to open a datasource. Args: pszFilename Darasource to open bUpdate update mode Returns: True on success, false on failure ******************************************************************************/ static bool CheckIsKMZ(const char *pszFilename) { char **papszFiles = VSIReadDir(pszFilename); char **papszIter = papszFiles; bool bFoundKML = false; while (papszIter && *papszIter) { if (EQUAL(CPLGetExtensionSafe(*papszIter).c_str(), "kml")) { bFoundKML = true; break; } else { CPLString osFilename(pszFilename); osFilename += "/"; osFilename += *papszIter; if (CheckIsKMZ(osFilename)) { bFoundKML = true; break; } } papszIter++; } CSLDestroy(papszFiles); return bFoundKML; } int OGRLIBKMLDataSource::Open(const char *pszFilename, bool bUpdateIn) { bUpdate = CPL_TO_BOOL(bUpdateIn); /***** dir *****/ VSIStatBufL sStatBuf; if (!VSIStatExL(pszFilename, &sStatBuf, VSI_STAT_NATURE_FLAG) && VSI_ISDIR(sStatBuf.st_mode)) { return OpenDir(pszFilename, bUpdate); } /***** kml *****/ if (EQUAL(CPLGetExtensionSafe(pszFilename).c_str(), "kml")) { return OpenKml(pszFilename, bUpdate); } /***** kmz *****/ if (EQUAL(CPLGetExtensionSafe(pszFilename).c_str(), "kmz")) { return OpenKmz(pszFilename, bUpdate); } VSILFILE *fp = VSIFOpenL(pszFilename, "rb"); if (fp == nullptr) return FALSE; char szBuffer[1024 + 1] = {}; const int nRead = static_cast(VSIFReadL(szBuffer, 1, 1024, fp)); szBuffer[nRead] = 0; VSIFCloseL(fp); // Does it look like a zip file? if (nRead == 1024 && szBuffer[0] == 0x50 && szBuffer[1] == 0x4B && szBuffer[2] == 0x03 && szBuffer[3] == 0x04) { CPLString osFilename("/vsizip/"); osFilename += pszFilename; if (!CheckIsKMZ(osFilename)) return FALSE; return OpenKmz(pszFilename, bUpdate); } if (strstr(szBuffer, "") || strstr(szBuffer, "= '0' && ch <= '9') bDigitFound = true; else if (ch == ';') break; else if (!(ch == '-' || ch == '.' || ch == '(' || ch == ')')) return false; pszPhoneNumber++; } return bDigitFound; } /************************************************************************/ /* SetCommonOptions() */ /************************************************************************/ void OGRLIBKMLDataSource::SetCommonOptions(ContainerPtr poKmlContainer, CSLConstList papszOptions) { const char *l_pszName = CSLFetchNameValue(papszOptions, "NAME"); if (l_pszName != nullptr) poKmlContainer->set_name(l_pszName); const char *pszVisibilility = CSLFetchNameValue(papszOptions, "VISIBILITY"); if (pszVisibilility != nullptr) poKmlContainer->set_visibility(CPLTestBool(pszVisibilility)); const char *pszOpen = CSLFetchNameValue(papszOptions, "OPEN"); if (pszOpen != nullptr) poKmlContainer->set_open(CPLTestBool(pszOpen)); const char *pszSnippet = CSLFetchNameValue(papszOptions, "SNIPPET"); if (pszSnippet != nullptr) { SnippetPtr poKmlSnippet = m_poKmlFactory->CreateSnippet(); poKmlSnippet->set_text(pszSnippet); poKmlContainer->set_snippet(poKmlSnippet); } const char *pszDescription = CSLFetchNameValue(papszOptions, "DESCRIPTION"); if (pszDescription != nullptr) poKmlContainer->set_description(pszDescription); } /************************************************************************/ /* ParseDocumentOptions() */ /************************************************************************/ void OGRLIBKMLDataSource::ParseDocumentOptions(KmlPtr poKml, DocumentPtr poKmlDocument) { if (poKmlDocument) { const char *pszDocumentId = CSLFetchNameValueDef(m_papszOptions, "DOCUMENT_ID", "root_doc"); poKmlDocument->set_id(pszDocumentId); const char *pszAuthorName = CSLFetchNameValue(m_papszOptions, "AUTHOR_NAME"); const char *pszAuthorURI = CSLFetchNameValue(m_papszOptions, "AUTHOR_URI"); const char *pszAuthorEmail = CSLFetchNameValue(m_papszOptions, "AUTHOR_EMAIL"); const char *pszLink = CSLFetchNameValue(m_papszOptions, "LINK"); if (pszAuthorName != nullptr || pszAuthorURI != nullptr || pszAuthorEmail != nullptr) { kmldom::AtomAuthorPtr author = m_poKmlFactory->CreateAtomAuthor(); if (pszAuthorName != nullptr) author->set_name(pszAuthorName); if (pszAuthorURI != nullptr) { // Ad-hoc validation. The ABNF is horribly complicated: // http://tools.ietf.org/search/rfc3987#page-7 if (STARTS_WITH(pszAuthorURI, "http://") || STARTS_WITH(pszAuthorURI, "https://")) { author->set_uri(pszAuthorURI); } else { CPLError(CE_Warning, CPLE_AppDefined, "Invalid URI for AUTHOR_URI"); } } if (pszAuthorEmail != nullptr) { const char *pszArobase = strchr(pszAuthorEmail, '@'); if (pszArobase != nullptr && strchr(pszArobase + 1, '.') != nullptr) { author->set_email(pszAuthorEmail); } else { CPLError(CE_Warning, CPLE_AppDefined, "Invalid email for AUTHOR_EMAIL"); } } poKmlDocument->set_atomauthor(author); } if (pszLink != nullptr) { kmldom::AtomLinkPtr link = m_poKmlFactory->CreateAtomLink(); link->set_href(pszLink); link->set_rel("related"); poKmlDocument->set_atomlink(link); } const char *pszPhoneNumber = CSLFetchNameValue(m_papszOptions, "PHONENUMBER"); if (pszPhoneNumber != nullptr) { if (IsValidPhoneNumber(pszPhoneNumber)) { if (!STARTS_WITH(pszPhoneNumber, "tel:")) poKmlDocument->set_phonenumber( CPLSPrintf("tel:%s", pszPhoneNumber)); else poKmlDocument->set_phonenumber(pszPhoneNumber); } else { CPLError(CE_Warning, CPLE_AppDefined, "Invalid phone number"); } } SetCommonOptions(poKmlDocument, m_papszOptions); CPLString osListStyleType = CSLFetchNameValueDef(m_papszOptions, "LISTSTYLE_TYPE", ""); CPLString osListStyleIconHref = CSLFetchNameValueDef(m_papszOptions, "LISTSTYLE_ICON_HREF", ""); createkmlliststyle(m_poKmlFactory, pszDocumentId, poKmlDocument, poKmlDocument, osListStyleType, osListStyleIconHref); } if (poKml) { if (m_poKmlUpdate) { NetworkLinkControlPtr nlc = m_poKmlFactory->CreateNetworkLinkControl(); poKml->set_networklinkcontrol(nlc); if (m_poKmlUpdate->get_updateoperation_array_size() != 0) { nlc->set_update(m_poKmlUpdate); } } const char *pszNLCMinRefreshPeriod = CSLFetchNameValue(m_papszOptions, "NLC_MINREFRESHPERIOD"); const char *pszNLCMaxSessionLength = CSLFetchNameValue(m_papszOptions, "NLC_MAXSESSIONLENGTH"); const char *pszNLCCookie = CSLFetchNameValue(m_papszOptions, "NLC_COOKIE"); const char *pszNLCMessage = CSLFetchNameValue(m_papszOptions, "NLC_MESSAGE"); const char *pszNLCLinkName = CSLFetchNameValue(m_papszOptions, "NLC_LINKNAME"); const char *pszNLCLinkDescription = CSLFetchNameValue(m_papszOptions, "NLC_LINKDESCRIPTION"); const char *pszNLCLinkSnippet = CSLFetchNameValue(m_papszOptions, "NLC_LINKSNIPPET"); const char *pszNLCExpires = CSLFetchNameValue(m_papszOptions, "NLC_EXPIRES"); if (pszNLCMinRefreshPeriod != nullptr || pszNLCMaxSessionLength != nullptr || pszNLCCookie != nullptr || pszNLCMessage != nullptr || pszNLCLinkName != nullptr || pszNLCLinkDescription != nullptr || pszNLCLinkSnippet != nullptr || pszNLCExpires != nullptr) { NetworkLinkControlPtr nlc = nullptr; if (poKml->has_networklinkcontrol()) { nlc = poKml->get_networklinkcontrol(); } else { nlc = m_poKmlFactory->CreateNetworkLinkControl(); poKml->set_networklinkcontrol(nlc); } if (pszNLCMinRefreshPeriod != nullptr) { const double dfVal = CPLAtof(pszNLCMinRefreshPeriod); if (dfVal >= 0) nlc->set_minrefreshperiod(dfVal); } if (pszNLCMaxSessionLength != nullptr) { const double dfVal = CPLAtof(pszNLCMaxSessionLength); nlc->set_maxsessionlength(dfVal); } if (pszNLCCookie != nullptr) { nlc->set_cookie(pszNLCCookie); } if (pszNLCMessage != nullptr) { nlc->set_message(pszNLCMessage); } if (pszNLCLinkName != nullptr) { nlc->set_linkname(pszNLCLinkName); } if (pszNLCLinkDescription != nullptr) { nlc->set_linkdescription(pszNLCLinkDescription); } if (pszNLCLinkSnippet != nullptr) { LinkSnippetPtr linksnippet = m_poKmlFactory->CreateLinkSnippet(); linksnippet->set_text(pszNLCLinkSnippet); nlc->set_linksnippet(std::move(linksnippet)); } if (pszNLCExpires != nullptr) { OGRField sField; if (OGRParseXMLDateTime(pszNLCExpires, &sField)) { char *pszXMLDate = OGRGetXMLDateTime(&sField); nlc->set_expires(pszXMLDate); CPLFree(pszXMLDate); } } } } } /****************************************************************************** Method to create a single file .kml ds. Args: pszFilename the datasource to create papszOptions datasource creation options Returns: True on success, false on failure ******************************************************************************/ int OGRLIBKMLDataSource::CreateKml(const char * /* pszFilename */, CSLConstList papszOptions) { m_poKmlDSKml = OGRLIBKMLCreateOGCKml22(m_poKmlFactory, papszOptions); if (osUpdateTargetHref.empty()) { DocumentPtr poKmlDocument = m_poKmlFactory->CreateDocument(); m_poKmlDSKml->set_feature(poKmlDocument); m_poKmlDSContainer = poKmlDocument; } m_isKml = true; bUpdated = true; return true; } /****************************************************************************** Method to create a .kmz ds. Args: pszFilename the datasource to create papszOptions datasource creation options Returns: True on success, false on failure ******************************************************************************/ int OGRLIBKMLDataSource::CreateKmz(const char * /* pszFilename */, CSLConstList /* papszOptions */) { /***** create the doc.kml *****/ if (osUpdateTargetHref.empty()) { const char *pszUseDocKml = CPLGetConfigOption("LIBKML_USE_DOC.KML", "yes"); if (CPLTestBool(pszUseDocKml)) { m_poKmlDocKml = m_poKmlFactory->CreateDocument(); } } // Layers are written in a layers/ subdirectory, hence ../style // to access style/style.kml m_osStylePath = "../style/style.kml"; m_isKmz = true; bUpdated = true; return TRUE; } /****************************************************************************** Method to create a dir datasource. Args: pszFilename the datasource to create papszOptions datasource creation options Returns: True on success, false on failure ******************************************************************************/ int OGRLIBKMLDataSource::CreateDir(const char *pszFilename, CSLConstList /* papszOptions */) { if (VSIMkdir(pszFilename, 0755)) { CPLError(CE_Failure, CPLE_AppDefined, "ERROR Creating dir: %s for KML datasource", pszFilename); return FALSE; } m_isDir = true; bUpdated = true; if (osUpdateTargetHref.empty()) { const char *pszUseDocKml = CPLGetConfigOption("LIBKML_USE_DOC.KML", "yes"); if (CPLTestBool(pszUseDocKml)) { m_poKmlDocKml = m_poKmlFactory->CreateDocument(); } } m_osStylePath = "style.kml"; return TRUE; } /****************************************************************************** Method to create a datasource. Args: pszFilename the datasource to create papszOptions datasource creation options Returns: True on success, false on failure env vars: LIBKML_USE_DOC.KML default: yes ******************************************************************************/ int OGRLIBKMLDataSource::Create(const char *pszFilename, CSLConstList papszOptions) { if (strcmp(pszFilename, "/dev/stdout") == 0) pszFilename = "/vsistdout/"; SetDescription(pszFilename); bUpdate = true; osUpdateTargetHref = CSLFetchNameValueDef(papszOptions, "UPDATE_TARGETHREF", ""); if (!osUpdateTargetHref.empty()) { m_poKmlUpdate = m_poKmlFactory->CreateUpdate(); m_poKmlUpdate->set_targethref(osUpdateTargetHref.c_str()); } m_papszOptions = CSLDuplicate(papszOptions); /***** kml *****/ if (strcmp(pszFilename, "/vsistdout/") == 0 || STARTS_WITH(pszFilename, "/vsigzip/") || EQUAL(CPLGetExtensionSafe(pszFilename).c_str(), "kml")) return CreateKml(pszFilename, papszOptions); /***** kmz *****/ if (EQUAL(CPLGetExtensionSafe(pszFilename).c_str(), "kmz")) return CreateKmz(pszFilename, papszOptions); /***** dir *****/ return CreateDir(pszFilename, papszOptions); } /****************************************************************************** Method to get a layer by index. Args: iLayer the index of the layer to get Returns: pointer to the layer, or NULL if the layer does not exist ******************************************************************************/ const OGRLayer *OGRLIBKMLDataSource::GetLayer(int iLayer) const { if (iLayer < 0 || iLayer >= nLayers) return nullptr; return papoLayers[iLayer]; } /****************************************************************************** Method to get a layer by name. Args: pszname name of the layer to get Returns: pointer to the layer, or NULL if the layer does not exist ******************************************************************************/ OGRLayer *OGRLIBKMLDataSource::GetLayerByName(const char *pszName) { auto oIter = m_oMapLayers.find(CPLString(pszName).toupper()); if (oIter != m_oMapLayers.end()) return oIter->second; return nullptr; } /****************************************************************************** Method to DeleteLayers in a .kml datasource. Args: iLayer index of the layer to delete Returns: OGRERR_NONE on success, OGRERR_FAILURE on failure ******************************************************************************/ OGRErr OGRLIBKMLDataSource::DeleteLayerKml(int iLayer) { OGRLIBKMLLayer *poOgrLayer = (OGRLIBKMLLayer *)papoLayers[iLayer]; /***** loop over the features *****/ const size_t nKmlFeatures = m_poKmlDSContainer->get_feature_array_size(); for (size_t iKmlFeature = 0; iKmlFeature < nKmlFeatures; iKmlFeature++) { FeaturePtr poKmlFeat = m_poKmlDSContainer->get_feature_array_at(iKmlFeature); if (poKmlFeat == poOgrLayer->GetKmlLayer()) { m_poKmlDSContainer->DeleteFeatureAt(iKmlFeature); break; } } return OGRERR_NONE; } /****************************************************************************** Method to DeleteLayers in a .kmz datasource. Args: iLayer index of the layer to delete Returns: OGRERR_NONE on success, OGRERR_FAILURE on failure ******************************************************************************/ OGRErr OGRLIBKMLDataSource::DeleteLayerKmz(int iLayer) { OGRLIBKMLLayer *poOgrLayer = papoLayers[iLayer]; const char *pszUseDocKml = CPLGetConfigOption("LIBKML_USE_DOC.KML", "yes"); if (CPLTestBool(pszUseDocKml) && m_poKmlDocKml) { /***** loop over the features *****/ const size_t nKmlFeatures = m_poKmlDocKml->get_feature_array_size(); for (size_t iKmlFeature = 0; iKmlFeature < nKmlFeatures; iKmlFeature++) { FeaturePtr poKmlFeat = m_poKmlDocKml->get_feature_array_at(iKmlFeature); if (poKmlFeat->IsA(kmldom::Type_NetworkLink)) { NetworkLinkPtr poKmlNetworkLink = AsNetworkLink(poKmlFeat); /***** does it have a link? *****/ if (poKmlNetworkLink->has_link()) { LinkPtr poKmlLink = poKmlNetworkLink->get_link(); /***** does the link have a href? *****/ if (poKmlLink->has_href()) { const kmlengine::Href oKmlHref(poKmlLink->get_href()); /***** is the link relative? *****/ if (oKmlHref.IsRelativePath()) { if (EQUAL(oKmlHref.get_path().c_str(), poOgrLayer->GetFileName())) { m_poKmlDocKml->DeleteFeatureAt(iKmlFeature); break; } } } } } } } return OGRERR_NONE; } /****************************************************************************** Method to delete a layer in a datasource. Args: iLayer index of the layer to delete Returns: OGRERR_NONE on success, OGRERR_FAILURE on failure ******************************************************************************/ OGRErr OGRLIBKMLDataSource::DeleteLayer(int iLayer) { if (!bUpdate) return OGRERR_UNSUPPORTED_OPERATION; if (iLayer >= nLayers) return OGRERR_FAILURE; if (IsKml()) { DeleteLayerKml(iLayer); } else if (IsKmz()) { DeleteLayerKmz(iLayer); } else if (IsDir()) { DeleteLayerKmz(iLayer); /***** delete the file the layer corresponds to *****/ const std::string osFilePath = CPLFormFilenameSafe( GetDescription(), papoLayers[iLayer]->GetFileName(), nullptr); VSIStatBufL oStatBufL; if (!VSIStatL(osFilePath.c_str(), &oStatBufL)) { if (VSIUnlink(osFilePath.c_str())) { CPLError(CE_Failure, CPLE_AppDefined, "ERROR Deleting Layer %s from filesystem as %s", papoLayers[iLayer]->GetName(), osFilePath.c_str()); } } } m_oMapLayers.erase(CPLString(papoLayers[iLayer]->GetName()).toupper()); delete papoLayers[iLayer]; memmove(papoLayers + iLayer, papoLayers + iLayer + 1, sizeof(void *) * (nLayers - iLayer - 1)); nLayers--; bUpdated = true; return OGRERR_NONE; } /****************************************************************************** Method to create a layer in a single file .kml. Args: pszLayerName name of the layer to create poOgrSRS the SRS of the layer eGType the layers geometry type papszOptions layer creation options Returns: return a pointer to the new layer or NULL on failure ******************************************************************************/ OGRLIBKMLLayer *OGRLIBKMLDataSource::CreateLayerKml( const char *pszLayerName, const OGRSpatialReference *poSRS, OGRwkbGeometryType eGType, CSLConstList papszOptions) { ContainerPtr poKmlLayerContainer = nullptr; if (m_poKmlDSContainer) { if (CPLFetchBool(papszOptions, "FOLDER", false)) poKmlLayerContainer = m_poKmlFactory->CreateFolder(); else poKmlLayerContainer = m_poKmlFactory->CreateDocument(); poKmlLayerContainer->set_id( OGRLIBKMLGetSanitizedNCName(pszLayerName).c_str()); m_poKmlDSContainer->add_feature(poKmlLayerContainer); } /***** create the layer *****/ OGRLIBKMLLayer *poOgrLayer = AddLayer(pszLayerName, eGType, poSRS, this, nullptr, poKmlLayerContainer, "", true, bUpdate, 1); /***** add the layer name as a *****/ if (poKmlLayerContainer) poKmlLayerContainer->set_name(pszLayerName); else if (CPLFetchBool(papszOptions, "FOLDER", false)) { poOgrLayer->SetUpdateIsFolder(TRUE); } return poOgrLayer; } /****************************************************************************** Method to create a layer in a .kmz or dir. Args: pszLayerName name of the layer to create poOgrSRS the SRS of the layer eGType the layers geometry type papszOptions layer creation options Returns: return a pointer to the new layer or NULL on failure ******************************************************************************/ OGRLIBKMLLayer *OGRLIBKMLDataSource::CreateLayerKmz( const char *pszLayerName, const OGRSpatialReference *poSRS, OGRwkbGeometryType eGType, CSLConstList papszOptions) { DocumentPtr poKmlDocument = nullptr; if (!m_poKmlUpdate) { /***** add a network link to doc.kml *****/ const char *pszUseDocKml = CPLGetConfigOption("LIBKML_USE_DOC.KML", "yes"); if (CPLTestBool(pszUseDocKml) && m_poKmlDocKml) { poKmlDocument = AsDocument(m_poKmlDocKml); NetworkLinkPtr poKmlNetLink = m_poKmlFactory->CreateNetworkLink(); poKmlNetLink->set_name( CSLFetchNameValueDef(papszOptions, "NAME", pszLayerName)); LinkPtr poKmlLink = m_poKmlFactory->CreateLink(); std::string oHref; if (IsKmz()) oHref.append("layers/"); oHref.append(pszLayerName); oHref.append(".kml"); poKmlLink->set_href(oHref); poKmlNetLink->set_link(poKmlLink); poKmlDocument->add_feature(poKmlNetLink); } /***** create the layer *****/ poKmlDocument = m_poKmlFactory->CreateDocument(); poKmlDocument->set_id( OGRLIBKMLGetSanitizedNCName(pszLayerName).c_str()); } OGRLIBKMLLayer *poOgrLayer = AddLayer(pszLayerName, eGType, poSRS, this, nullptr, poKmlDocument, CPLFormFilenameSafe(nullptr, pszLayerName, ".kml").c_str(), true, bUpdate, 1); /***** add the layer name as a *****/ if (!m_poKmlUpdate) { poKmlDocument->set_name(pszLayerName); } return poOgrLayer; } /****************************************************************************** ICreateLayer() Args: pszLayerName name of the layer to create poOgrSRS the SRS of the layer eGType the layers geometry type papszOptions layer creation options Returns: return a pointer to the new layer or NULL on failure ******************************************************************************/ OGRLayer * OGRLIBKMLDataSource::ICreateLayer(const char *pszLayerName, const OGRGeomFieldDefn *poGeomFieldDefn, CSLConstList papszOptions) { if (!bUpdate) return nullptr; if (CPLLaunderForFilenameSafe(pszLayerName, nullptr) != pszLayerName) { CPLError(CE_Failure, CPLE_AppDefined, "Illegal characters in '%s' to form a valid filename", pszLayerName); return nullptr; } if ((IsKmz() || IsDir()) && EQUAL(pszLayerName, "doc")) { CPLError(CE_Failure, CPLE_AppDefined, "'doc' is an invalid layer name in a KMZ file"); return nullptr; } const auto eGType = poGeomFieldDefn ? poGeomFieldDefn->GetType() : wkbNone; const auto poOgrSRS = poGeomFieldDefn ? poGeomFieldDefn->GetSpatialRef() : nullptr; OGRLIBKMLLayer *poOgrLayer = nullptr; /***** kml DS *****/ if (IsKml()) { poOgrLayer = CreateLayerKml(pszLayerName, poOgrSRS, eGType, papszOptions); } else if (IsKmz() || IsDir()) { poOgrLayer = CreateLayerKmz(pszLayerName, poOgrSRS, eGType, papszOptions); } const char *pszLookatLongitude = CSLFetchNameValue(papszOptions, "LOOKAT_LONGITUDE"); const char *pszLookatLatitude = CSLFetchNameValue(papszOptions, "LOOKAT_LATITUDE"); const char *pszLookatAltitude = CSLFetchNameValue(papszOptions, "LOOKAT_ALTITUDE"); const char *pszLookatHeading = CSLFetchNameValue(papszOptions, "LOOKAT_HEADING"); const char *pszLookatTilt = CSLFetchNameValue(papszOptions, "LOOKAT_TILT"); const char *pszLookatRange = CSLFetchNameValue(papszOptions, "LOOKAT_RANGE"); const char *pszLookatAltitudeMode = CSLFetchNameValue(papszOptions, "LOOKAT_ALTITUDEMODE"); if (poOgrLayer != nullptr && pszLookatLongitude != nullptr && pszLookatLatitude != nullptr && pszLookatRange != nullptr) { poOgrLayer->SetLookAt(pszLookatLongitude, pszLookatLatitude, pszLookatAltitude, pszLookatHeading, pszLookatTilt, pszLookatRange, pszLookatAltitudeMode); } else { const char *pszCameraLongitude = CSLFetchNameValue(papszOptions, "CAMERA_LONGITUDE"); const char *pszCameraLatitude = CSLFetchNameValue(papszOptions, "CAMERA_LATITUDE"); const char *pszCameraAltitude = CSLFetchNameValue(papszOptions, "CAMERA_ALTITUDE"); const char *pszCameraHeading = CSLFetchNameValue(papszOptions, "CAMERA_HEADING"); const char *pszCameraTilt = CSLFetchNameValue(papszOptions, "CAMERA_TILT"); const char *pszCameraRoll = CSLFetchNameValue(papszOptions, "CAMERA_ROLL"); const char *pszCameraAltitudeMode = CSLFetchNameValue(papszOptions, "CAMERA_ALTITUDEMODE"); if (poOgrLayer != nullptr && pszCameraLongitude != nullptr && pszCameraLatitude != nullptr && pszCameraAltitude != nullptr && pszCameraAltitudeMode != nullptr) { poOgrLayer->SetCamera(pszCameraLongitude, pszCameraLatitude, pszCameraAltitude, pszCameraHeading, pszCameraTilt, pszCameraRoll, pszCameraAltitudeMode); } } const char *pszRegionAdd = CSLFetchNameValueDef(papszOptions, "ADD_REGION", "FALSE"); const char *pszRegionXMin = CSLFetchNameValue(papszOptions, "REGION_XMIN"); const char *pszRegionYMin = CSLFetchNameValue(papszOptions, "REGION_YMIN"); const char *pszRegionXMax = CSLFetchNameValue(papszOptions, "REGION_XMAX"); const char *pszRegionYMax = CSLFetchNameValue(papszOptions, "REGION_YMAX"); const char *pszRegionMinLodPixels = CSLFetchNameValueDef(papszOptions, "REGION_MIN_LOD_PIXELS", "256"); const char *pszRegionMaxLodPixels = CSLFetchNameValueDef(papszOptions, "REGION_MAX_LOD_PIXELS", "-1"); const char *pszRegionMinFadeExtent = CSLFetchNameValueDef(papszOptions, "REGION_MIN_FADE_EXTENT", "0"); const char *pszRegionMaxFadeExtent = CSLFetchNameValueDef(papszOptions, "REGION_MAX_FADE_EXTENT", "0"); if (poOgrLayer != nullptr && CPLTestBool(pszRegionAdd)) { poOgrLayer->SetWriteRegion( CPLAtof(pszRegionMinLodPixels), CPLAtof(pszRegionMaxLodPixels), CPLAtof(pszRegionMinFadeExtent), CPLAtof(pszRegionMaxFadeExtent)); if (pszRegionXMin != nullptr && pszRegionYMin != nullptr && pszRegionXMax != nullptr && pszRegionYMax != nullptr) { const double xmin = CPLAtof(pszRegionXMin); const double ymin = CPLAtof(pszRegionYMin); const double xmax = CPLAtof(pszRegionXMax); const double ymax = CPLAtof(pszRegionYMax); if (xmin < xmax && ymin < ymax) poOgrLayer->SetRegionBounds(xmin, ymin, xmax, ymax); } } const char *pszSOHref = CSLFetchNameValue(papszOptions, "SO_HREF"); const char *pszSOName = CSLFetchNameValue(papszOptions, "SO_NAME"); const char *pszSODescription = CSLFetchNameValue(papszOptions, "SO_DESCRIPTION"); const char *pszSOOverlayX = CSLFetchNameValue(papszOptions, "SO_OVERLAY_X"); const char *pszSOOverlayY = CSLFetchNameValue(papszOptions, "SO_OVERLAY_Y"); const char *pszSOOverlayXUnits = CSLFetchNameValue(papszOptions, "SO_OVERLAY_XUNITS"); const char *pszSOOverlayYUnits = CSLFetchNameValue(papszOptions, "SO_OVERLAY_YUNITS"); const char *pszSOScreenX = CSLFetchNameValue(papszOptions, "SO_SCREEN_X"); const char *pszSOScreenY = CSLFetchNameValue(papszOptions, "SO_SCREEN_Y"); const char *pszSOScreenXUnits = CSLFetchNameValue(papszOptions, "SO_SCREEN_XUNITS"); const char *pszSOScreenYUnits = CSLFetchNameValue(papszOptions, "SO_SCREEN_YUNITS"); const char *pszSOSizeX = CSLFetchNameValue(papszOptions, "SO_SIZE_X"); const char *pszSOSizeY = CSLFetchNameValue(papszOptions, "SO_SIZE_Y"); const char *pszSOSizeXUnits = CSLFetchNameValue(papszOptions, "SO_SIZE_XUNITS"); const char *pszSOSizeYUnits = CSLFetchNameValue(papszOptions, "SO_SIZE_YUNITS"); if (poOgrLayer != nullptr && pszSOHref != nullptr) { poOgrLayer->SetScreenOverlay( pszSOHref, pszSOName, pszSODescription, pszSOOverlayX, pszSOOverlayY, pszSOOverlayXUnits, pszSOOverlayYUnits, pszSOScreenX, pszSOScreenY, pszSOScreenXUnits, pszSOScreenYUnits, pszSOSizeX, pszSOSizeY, pszSOSizeXUnits, pszSOSizeYUnits); } const char *pszListStyleType = CSLFetchNameValue(papszOptions, "LISTSTYLE_TYPE"); const char *pszListStyleIconHref = CSLFetchNameValue(papszOptions, "LISTSTYLE_ICON_HREF"); if (poOgrLayer != nullptr) { poOgrLayer->SetListStyle(pszListStyleType, pszListStyleIconHref); } if (poOgrLayer != nullptr && poOgrLayer->GetKmlLayer()) { SetCommonOptions(poOgrLayer->GetKmlLayer(), papszOptions); } /***** mark the dataset as updated *****/ if (poOgrLayer) bUpdated = true; return poOgrLayer; } /****************************************************************************** Method to get a datasources style table. Args: none Returns: pointer to the datasources style table, or NULL if it does not have one ******************************************************************************/ OGRStyleTable *OGRLIBKMLDataSource::GetStyleTable() { return m_poStyleTable; } /****************************************************************************** Method to write a style table to a single file .kml ds. Args: poStyleTable pointer to the style table to add Returns: nothing ******************************************************************************/ void OGRLIBKMLDataSource::SetStyleTable2Kml(OGRStyleTable *poStyleTable) { if (!m_poKmlDSContainer) return; /***** delete all the styles *****/ DocumentPtr poKmlDocument = AsDocument(m_poKmlDSContainer); int nKmlStyles = static_cast(poKmlDocument->get_styleselector_array_size()); for (int iKmlStyle = nKmlStyles - 1; iKmlStyle >= 0; iKmlStyle--) { poKmlDocument->DeleteStyleSelectorAt(iKmlStyle); } /***** add the new style table to the document *****/ styletable2kml(poStyleTable, m_poKmlFactory, AsContainer(poKmlDocument), m_papszOptions); } /****************************************************************************** Method to write a style table to a kmz ds. Args: poStyleTable pointer to the style table to add Returns: nothing ******************************************************************************/ void OGRLIBKMLDataSource::SetStyleTable2Kmz(OGRStyleTable *poStyleTable) { if (m_poKmlStyleKml || poStyleTable != nullptr) { /***** replace the style document with a new one *****/ m_poKmlStyleKml = m_poKmlFactory->CreateDocument(); m_poKmlStyleKml->set_id("styleId"); styletable2kml(poStyleTable, m_poKmlFactory, m_poKmlStyleKml); } } /****************************************************************************** Method to write a style table to a datasource. Args: poStyleTable pointer to the style table to add Returns: nothing Note: This method assumes ownership of the style table. ******************************************************************************/ void OGRLIBKMLDataSource::SetStyleTableDirectly(OGRStyleTable *poStyleTable) { if (!bUpdate) return; if (m_poStyleTable) delete m_poStyleTable; m_poStyleTable = poStyleTable; /***** a kml datasource? *****/ if (IsKml()) SetStyleTable2Kml(m_poStyleTable); else if (IsKmz() || IsDir()) SetStyleTable2Kmz(m_poStyleTable); bUpdated = true; } /****************************************************************************** Method to write a style table to a datasource. Args: poStyleTable pointer to the style table to add Returns: nothing Note: This method copies the style table, and the user will still be responsible for its destruction. ******************************************************************************/ void OGRLIBKMLDataSource::SetStyleTable(OGRStyleTable *poStyleTable) { if (!bUpdate) return; if (poStyleTable) SetStyleTableDirectly(poStyleTable->Clone()); else SetStyleTableDirectly(nullptr); } /****************************************************************************** Test if capability is available. Args: pszCap datasource capability name to test Returns: TRUE or FALSE ODsCCreateLayer: True if this datasource can create new layers. ODsCDeleteLayer: True if this datasource can delete existing layers. ******************************************************************************/ int OGRLIBKMLDataSource::TestCapability(const char *pszCap) const { if (EQUAL(pszCap, ODsCCreateLayer)) return bUpdate; else if (EQUAL(pszCap, ODsCDeleteLayer)) return bUpdate; else if (EQUAL(pszCap, ODsCRandomLayerWrite)) return bUpdate; else if (EQUAL(pszCap, ODsCZGeometries)) return TRUE; return FALSE; }