自学教程：C++ CPLGetXMLValue函数代码示例

staticint LookForSimpleType(CPLXMLNode *psSchemaNode,                      const char* pszStrippedNSType,                      GMLPropertyType *pGMLType,                      int *pnWidth,                      int *pnPrecision){    CPLXMLNode *psThis;    for( psThis = psSchemaNode->psChild;         psThis != NULL; psThis = psThis->psNext )    {        if( psThis->eType == CXT_Element           && EQUAL(psThis->pszValue,"simpleType")           && EQUAL(CPLGetXMLValue(psThis,"name",""),pszStrippedNSType) )        {            break;        }    }    if (psThis == NULL)        return FALSE;    return GetSimpleTypeProperties(psThis, pGMLType, pnWidth, pnPrecision);}

CPLXMLNode * SAFEDataset::GetDataObject(    CPLXMLNode *psMetaDataObjects, CPLXMLNode *psDataObjects,    const char *metadataObjectId){/* -------------------------------------------------------------------- *//*      Look for MetadataObject Element by ID.                          *//* -------------------------------------------------------------------- */    CPLXMLNode *psMDO = SAFEDataset::GetMetaDataObject(            psMetaDataObjects, metadataObjectId);    if (psMDO!=nullptr) {        const char *dataObjectId = CPLGetXMLValue(            psMDO, "dataObjectPointer.dataObjectID", "" );        if( *dataObjectId != '/0' ) {            return SAFEDataset::GetDataObject(psDataObjects, dataObjectId);        }    }    CPLError( CE_Warning, CPLE_AppDefined,              "DataObject not found with MetaID=%s",              metadataObjectId);    return nullptr;}

int OGRFMECacheIndex::ExpireOldCaches( IFMESession *poSession ){    CPLXMLNode *psDSNode, *psLastDSNode = NULL;    unsigned long nCurTime = time(NULL);    int  bChangeMade = FALSE;    if( psTree == NULL )        return FALSE;    for( psLastDSNode = NULL; TRUE; psLastDSNode = psDSNode )    {        if( psLastDSNode != NULL )            psDSNode = psLastDSNode->psNext;        else            psDSNode = psTree->psChild;        if( psDSNode == NULL )            break;        if( !EQUAL(psDSNode->pszValue,"DataSource") )            continue;        /* -------------------------------------------------------------------- *//*      When was this datasource last accessed?                         *//* -------------------------------------------------------------------- */        unsigned long nLastUseTime = 0;        sscanf( CPLGetXMLValue( psDSNode, "LastUseTime", "0" ),                 "%lu", &nLastUseTime );        /* -------------------------------------------------------------------- *//*      When was this datasource created.                               *//* -------------------------------------------------------------------- */        unsigned long nCreationTime = 0;        sscanf( CPLGetXMLValue( psDSNode, "CreationTime", "0" ),                 "%lu", &nCreationTime );/* -------------------------------------------------------------------- *//*      Do we want to delete this datasource according to our           *//*      retention and ref timeout rules?                                *//* -------------------------------------------------------------------- */        int bCleanup = FALSE;        // Do we want to cleanup this node?         if( atoi(CPLGetXMLValue( psDSNode, "RefCount", "0" )) > 0              && nLastUseTime + FMECACHE_REF_TIMEOUT < nCurTime )            bCleanup = TRUE;        if( atoi(CPLGetXMLValue( psDSNode, "RefCount", "0" )) < 1             && nLastUseTime + FMECACHE_RETENTION < nCurTime )            bCleanup = TRUE;        if( atoi(CPLGetXMLValue( psDSNode, "RefCount", "0" )) < 1             && nCreationTime + FMECACHE_MAX_RETENTION < nCurTime )            bCleanup = TRUE;        if( !bCleanup )            continue;        bChangeMade = TRUE;        CPLDebug( "OGRFMECacheIndex",                   "ExpireOldCaches() cleaning up data source %s - %ds since last use, %ds old.",                  CPLGetXMLValue( psDSNode, "DSName", "<missing name>" ),                  nCurTime - nLastUseTime,                  nCurTime - nCreationTime );/* -------------------------------------------------------------------- *//*      Loop over all the layers, to delete the spatial caches on       *//*      disk.                                                           *//* -------------------------------------------------------------------- */        CPLXMLNode *psLayerN;        for( psLayerN = psDSNode->psChild;              psLayerN != NULL;             psLayerN = psLayerN->psNext )        {            IFMESpatialIndex   *poIndex;            if( !EQUAL(psLayerN->pszValue,"OGRLayer") )                continue;            const char *pszBase;            pszBase = CPLGetXMLValue( psLayerN, "SpatialCacheName", "" );            if( EQUAL(pszBase,"") )                continue;            // open, and then delete the index on close.            poIndex = poSession->createSpatialIndex( pszBase, "READ", NULL );            if( poIndex == NULL )                continue;            if( poIndex->open() != 0 )            {                CPLDebug( "OGRFMECacheIndex", "Failed to open FME index %s.",                          pszBase );                          //.........这里部分代码省略.........

OGRErr OGRMILayerAttrIndex::LoadConfigFromXML(const char* pszRawXML){/* -------------------------------------------------------------------- *//*      Parse the XML.                                                  *//* -------------------------------------------------------------------- */    CPLXMLNode *psRoot = CPLParseXMLString( pszRawXML );    if( psRoot == nullptr )        return OGRERR_FAILURE;/* -------------------------------------------------------------------- *//*      Open the index file.                                            *//* -------------------------------------------------------------------- */    poINDFile = new TABINDFile();    if (pszMIINDFilename == nullptr)        pszMIINDFilename = CPLStrdup(CPLGetXMLValue(psRoot,"MIIDFilename",""));    if( pszMIINDFilename == nullptr )        return OGRERR_FAILURE;    /* NOTE: Replaced r+ with r according to explanation in Ticket #1620.     * This change has to be observed if it doesn't cause any     * problems in future. (mloskot)     */    if( poINDFile->Open( pszMIINDFilename, "r" ) != 0 )    {        CPLDestroyXMLNode( psRoot );        CPLError( CE_Failure, CPLE_OpenFailed,                  "Failed to open index file %s.",                  pszMIINDFilename );        return OGRERR_FAILURE;    }/* -------------------------------------------------------------------- *//*      Process each attrindex.                                         *//* -------------------------------------------------------------------- */    for( CPLXMLNode *psAttrIndex = psRoot->psChild;         psAttrIndex != nullptr;         psAttrIndex = psAttrIndex->psNext )    {        if( psAttrIndex->eType != CXT_Element            || !EQUAL(psAttrIndex->pszValue,"OGRMIAttrIndex") )            continue;        int iField = atoi(CPLGetXMLValue(psAttrIndex,"FieldIndex","-1"));        int iIndexIndex = atoi(CPLGetXMLValue(psAttrIndex,"IndexIndex","-1"));        if( iField == -1 || iIndexIndex == -1 )        {            CPLError( CE_Warning, CPLE_AppDefined,                      "Skipping corrupt OGRMIAttrIndex entry." );            continue;        }        AddAttrInd( iField, iIndexIndex );    }    CPLDestroyXMLNode( psRoot );    CPLDebug( "OGR", "Restored %d field indexes for layer %s from %s on %s.",              nIndexCount, poLayer->GetLayerDefn()->GetName(),              pszMetadataFilename ? pszMetadataFilename : "--unknown--",              pszMIINDFilename );    return OGRERR_NONE;}

OGRLayer*  OGRVRTDataSource::InstanciateUnionLayer(                                        CPLXMLNode *psLTree,                                        const char *pszVRTDirectory,                                        int bUpdate,                                        int nRecLevel){    CPLXMLNode *psSubNode;    if( !EQUAL(psLTree->pszValue,"OGRVRTUnionLayer") )        return NULL;/* -------------------------------------------------------------------- *//*      Get layer name.                                                 *//* -------------------------------------------------------------------- */    const char *pszLayerName = CPLGetXMLValue( psLTree, "name", NULL );    if( pszLayerName == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "Missing name attribute on OGRVRTUnionLayer" );        return FALSE;    }/* -------------------------------------------------------------------- *//*      Do we have a fixed geometry type?  If not derive from the       *//*      source layer.                                                   *//* -------------------------------------------------------------------- */    const char* pszGType = CPLGetXMLValue( psLTree, "GeometryType", NULL );    int bGlobalGeomTypeSet = FALSE;    OGRwkbGeometryType eGlobalGeomType = wkbUnknown;    if( pszGType != NULL )    {        int bError;        bGlobalGeomTypeSet = TRUE;        eGlobalGeomType = OGRVRTGetGeometryType(pszGType, &bError);        if( bError )        {            CPLError( CE_Failure, CPLE_AppDefined,                    "GeometryType %s not recognised.",                    pszGType );            return NULL;        }    }/* -------------------------------------------------------------------- *//*      Apply a spatial reference system if provided                    *//* -------------------------------------------------------------------- */     const char* pszLayerSRS = CPLGetXMLValue( psLTree, "LayerSRS", NULL );     OGRSpatialReference* poGlobalSRS = NULL;     int bGlobalSRSSet = FALSE;     if( pszLayerSRS != NULL )     {         bGlobalSRSSet = TRUE;         if( !EQUAL(pszLayerSRS,"NULL") )         {             OGRSpatialReference oSRS;             if( oSRS.SetFromUserInput( pszLayerSRS ) != OGRERR_NONE )             {                 CPLError( CE_Failure, CPLE_AppDefined,                           "Failed to import LayerSRS `%s'.", pszLayerSRS );                 return FALSE;             }             poGlobalSRS = oSRS.Clone();         }     }/* -------------------------------------------------------------------- *//*      Find field declarations.                                        *//* -------------------------------------------------------------------- */    OGRFieldDefn** papoFields = NULL;    int nFields = 0;    OGRUnionLayerGeomFieldDefn** papoGeomFields = NULL;    int nGeomFields = 0;    for( psSubNode=psLTree->psChild;         psSubNode != NULL;         psSubNode=psSubNode->psNext )    {         if( psSubNode->eType != CXT_Element )             continue;         if( psSubNode->eType == CXT_Element && EQUAL(psSubNode->pszValue,"Field") )         {/* -------------------------------------------------------------------- *//*      Field name.                                                     *//* -------------------------------------------------------------------- */             const char *pszName = CPLGetXMLValue( psSubNode, "name", NULL );             if( pszName == NULL )             {                 CPLError( CE_Failure, CPLE_AppDefined,                           "Unable to identify Field name." );                 break;             }             OGRFieldDefn oFieldDefn( pszName, OFTString );/* -------------------------------------------------------------------- *//*      Type                                                            *//* -------------------------------------------------------------------- *///.........这里部分代码省略.........

//.........这里部分代码省略.........    {        int nLNLen = tr_strlen( localname );        /* should save attributes too! */        if( m_nGeomLen + nLNLen + 4 > m_nGeomAlloc )        {            m_nGeomAlloc = (int) (m_nGeomAlloc * 1.3 + nLNLen + 1000);            m_pszGeometry = (char *)                CPLRealloc( m_pszGeometry, m_nGeomAlloc);        }        strcat( m_pszGeometry+m_nGeomLen, "</" );        tr_strcpy( m_pszGeometry+m_nGeomLen+2, localname );        strcat( m_pszGeometry+m_nGeomLen+nLNLen+2, ">" );        m_nGeomLen += static_cast<int>(strlen(m_pszGeometry+m_nGeomLen));        if( poState->m_nPathLength == m_nGeometryDepth+1 )        {            if( poState->m_poFeature != NULL )            {                CPLXMLNode* psNode = CPLParseXMLString(m_pszGeometry);                if (psNode)                {                    /* workaround for common malformed gml:pos with just a                     * elevation value instead of a full 3D coordinate:                     *                     * <gml:Point gml:id="BII2H">                     *    <gml:pos srsName="urn:adv:crs:ETRS89_h">41.394</gml:pos>                     * </gml:Point>                     *                     */                    const char *pszPos;                    if( (pszPos = CPLGetXMLValue( psNode, "=Point.pos", NULL ) ) != NULL                        && strstr(pszPos, " ") == NULL )                    {                        CPLSetXMLValue( psNode, "pos", CPLSPrintf("0 0 %s", pszPos) );                    }                    if ( poState->m_poFeature->GetGeometryList() &&                         poState->m_poFeature->GetGeometryList()[0] )                    {                        int iId = poState->m_poFeature->GetClass()->GetPropertyIndex( "gml_id" );                        const GMLProperty *poIdProp = poState->m_poFeature->GetProperty(iId);#ifdef DEBUG_VERBOSE                        char *pszOldGeom = CPLSerializeXMLTree( poState->m_poFeature->GetGeometryList()[0] );                        CPLDebug("NAS", "Overwriting other geometry (%s; replace:%s; with:%s)",                                 poIdProp && poIdProp->nSubProperties>0 && poIdProp->papszSubProperties[0] ? poIdProp->papszSubProperties[0] : "(null)",                                 m_pszGeometry,                                 pszOldGeom                                );                        CPLFree( pszOldGeom );#else                        CPLError( CE_Warning, CPLE_AppDefined, "NAS: Overwriting other geometry (%s)",                                 poIdProp && poIdProp->nSubProperties>0 && poIdProp->papszSubProperties[0] ? poIdProp->papszSubProperties[0] : "(null)" );#endif                    }                    poState->m_poFeature->SetGeometryDirectly( psNode );                }                else                    CPLError( CE_Warning, CPLE_AppDefined, "NAS: Invalid geometry skipped" );            }            else

GDALDataset *VRTDataset::OpenXML( const char *pszXML, const char *pszVRTPath,                                  GDALAccess eAccess){ /* -------------------------------------------------------------------- */ /*      Parse the XML.                                                  */ /* -------------------------------------------------------------------- */    CPLXMLNode	*psTree;    psTree = CPLParseXMLString( pszXML );    if( psTree == NULL )        return NULL;    CPLXMLNode *psRoot = CPLGetXMLNode( psTree, "=VRTDataset" );    if (psRoot == NULL)    {        CPLError( CE_Failure, CPLE_AppDefined,                  "Missing VRTDataset element." );        CPLDestroyXMLNode( psTree );        return NULL;    }    if( CPLGetXMLNode( psRoot, "rasterXSize" ) == NULL        || CPLGetXMLNode( psRoot, "rasterYSize" ) == NULL        || CPLGetXMLNode( psRoot, "VRTRasterBand" ) == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                   "Missing one of rasterXSize, rasterYSize or bands on"                  " VRTDataset." );        CPLDestroyXMLNode( psTree );        return NULL;    }/* -------------------------------------------------------------------- *//*      Create the new virtual dataset object.                          *//* -------------------------------------------------------------------- */    VRTDataset *poDS;    int nXSize = atoi(CPLGetXMLValue(psRoot,"rasterXSize","0"));    int nYSize = atoi(CPLGetXMLValue(psRoot,"rasterYSize","0"));        if ( !GDALCheckDatasetDimensions(nXSize, nYSize) )    {        CPLDestroyXMLNode( psTree );        return NULL;    }    if( strstr(pszXML,"VRTWarpedDataset") != NULL )        poDS = new VRTWarpedDataset( nXSize, nYSize );    else    {        poDS = new VRTDataset( nXSize, nYSize );        poDS->eAccess = eAccess;    }    if( poDS->XMLInit( psRoot, pszVRTPath ) != CE_None )    {        delete poDS;        poDS = NULL;    }/* -------------------------------------------------------------------- *//*      Try to return a regular handle on the file.                     *//* -------------------------------------------------------------------- */    CPLDestroyXMLNode( psTree );    return poDS;}

GDALDataset *TSXDataset::Open( GDALOpenInfo *poOpenInfo ) {/* -------------------------------------------------------------------- *//*      Is this a TerraSAR-X product file?                              *//* -------------------------------------------------------------------- */    if (!TSXDataset::Identify( poOpenInfo ))    {        return NULL; /* nope */    }/* -------------------------------------------------------------------- *//*      Confirm the requested access is supported.                      *//* -------------------------------------------------------------------- */    if( poOpenInfo->eAccess == GA_Update )    {        CPLError( CE_Failure, CPLE_NotSupported,                  "The TSX driver does not support update access to existing"                  " datasets./n" );        return NULL;    }    CPLString osFilename;    if( poOpenInfo->bIsDirectory )    {        osFilename =            CPLFormCIFilename( poOpenInfo->pszFilename,                               CPLGetFilename( poOpenInfo->pszFilename ),                               "xml" );    }    else        osFilename = poOpenInfo->pszFilename;    /* Ingest the XML */    CPLXMLNode *psData = CPLParseXMLFile( osFilename );    if (psData == NULL)        return NULL;    /* find the product components */    CPLXMLNode *psComponents        = CPLGetXMLNode( psData, "=level1Product.productComponents" );    if (psComponents == NULL) {        CPLError( CE_Failure, CPLE_OpenFailed,            "Unable to find <productComponents> tag in file./n" );        CPLDestroyXMLNode(psData);        return NULL;    }    /* find the product info tag */    CPLXMLNode *psProductInfo        = CPLGetXMLNode( psData, "=level1Product.productInfo" );    if (psProductInfo == NULL) {        CPLError( CE_Failure, CPLE_OpenFailed,            "Unable to find <productInfo> tag in file./n" );        CPLDestroyXMLNode(psData);        return NULL;    }/* -------------------------------------------------------------------- *//*      Create the dataset.                                             *//* -------------------------------------------------------------------- */    TSXDataset *poDS = new TSXDataset();/* -------------------------------------------------------------------- *//*      Read in product info.                                           *//* -------------------------------------------------------------------- */    poDS->SetMetadataItem( "SCENE_CENTRE_TIME", CPLGetXMLValue( psProductInfo,        "sceneInfo.sceneCenterCoord.azimuthTimeUTC", "unknown" ) );    poDS->SetMetadataItem( "OPERATIONAL_MODE", CPLGetXMLValue( psProductInfo,        "generationInfo.groundOperationsType", "unknown" ) );    poDS->SetMetadataItem( "ORBIT_CYCLE", CPLGetXMLValue( psProductInfo,        "missionInfo.orbitCycle", "unknown" ) );    poDS->SetMetadataItem( "ABSOLUTE_ORBIT", CPLGetXMLValue( psProductInfo,        "missionInfo.absOrbit", "unknown" ) );    poDS->SetMetadataItem( "ORBIT_DIRECTION", CPLGetXMLValue( psProductInfo,        "missionInfo.orbitDirection", "unknown" ) );    poDS->SetMetadataItem( "IMAGING_MODE", CPLGetXMLValue( psProductInfo,        "acquisitionInfo.imagingMode", "unknown" ) );    poDS->SetMetadataItem( "PRODUCT_VARIANT", CPLGetXMLValue( psProductInfo,        "productVariantInfo.productVariant", "unknown" ) );    char *pszDataType = CPLStrdup( CPLGetXMLValue( psProductInfo,        "imageDataInfo.imageDataType", "unknown" ) );    poDS->SetMetadataItem( "IMAGE_TYPE", pszDataType );    /* Get raster information */    int nRows = atoi( CPLGetXMLValue( psProductInfo,        "imageDataInfo.imageRaster.numberOfRows", "" ) );    int nCols = atoi( CPLGetXMLValue( psProductInfo,        "imageDataInfo.imageRaster.numberOfColumns", "" ) );    poDS->nRasterXSize = nCols;    poDS->nRasterYSize = nRows;    poDS->SetMetadataItem( "ROW_SPACING", CPLGetXMLValue( psProductInfo,        "imageDataInfo.imageRaster.rowSpacing", "unknown" ) );    poDS->SetMetadataItem( "COL_SPACING", CPLGetXMLValue( psProductInfo,        "imageDataInfo.imageRaster.columnSpacing", "unknown" ) );    poDS->SetMetadataItem( "COL_SPACING_UNITS", CPLGetXMLValue( psProductInfo,        "imageDataInfo.imageRaster.columnSpacing.units", "unknown" ) );//.........这里部分代码省略.........

OGRErr BAGDataset::ParseWKTFromXML( const char *pszISOXML ){    OGRSpatialReference oSRS;    CPLXMLNode *psRoot = CPLParseXMLString( pszISOXML );    OGRErr eOGRErr = OGRERR_FAILURE;    if( psRoot == NULL )        return eOGRErr;    CPLStripXMLNamespace( psRoot, NULL, TRUE );     CPLXMLNode *psRSI = CPLSearchXMLNode( psRoot, "=referenceSystemInfo" );    if( psRSI == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,          "Unable to find <referenceSystemInfo> in metadata." );        CPLDestroyXMLNode( psRoot );        return eOGRErr;    }    oSRS.Clear();    const char *pszSRCodeString =         CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.code.CharacterString", NULL );    if( pszSRCodeString == NULL )    {        CPLDebug("BAG",          "Unable to find /MI_Metadata/referenceSystemInfo[1]/MD_ReferenceSystem[1]/referenceSystemIdentifier[1]/RS_Identifier[1]/code[1]/CharacterString[1] in metadata." );        CPLDestroyXMLNode( psRoot );        return eOGRErr;    }        const char *pszSRCodeSpace =         CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.codeSpace.CharacterString", "" );    if( !EQUAL( pszSRCodeSpace, "WKT" ) )    {        CPLError( CE_Failure, CPLE_AppDefined,            "Spatial reference string is not in WKT." );        CPLDestroyXMLNode( psRoot );        return eOGRErr;    }    char* pszWKT = const_cast< char* >( pszSRCodeString );    if( oSRS.importFromWkt( &pszWKT ) != OGRERR_NONE )    {        CPLError( CE_Failure, CPLE_AppDefined,          "Failed parsing WKT string /"%s/".", pszSRCodeString );        CPLDestroyXMLNode( psRoot );        return eOGRErr;    }    oSRS.exportToWkt( &pszProjection );    eOGRErr = OGRERR_NONE;    psRSI = CPLSearchXMLNode( psRSI->psNext, "=referenceSystemInfo" );    if( psRSI == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,            "Unable to find second instance of <referenceSystemInfo> in metadata." );        CPLDestroyXMLNode( psRoot );        return eOGRErr;    }    pszSRCodeString =       CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.code.CharacterString", NULL );    if( pszSRCodeString == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,            "Unable to find /MI_Metadata/referenceSystemInfo[2]/MD_ReferenceSystem[1]/referenceSystemIdentifier[1]/RS_Identifier[1]/code[1]/CharacterString[1] in metadata." );        CPLDestroyXMLNode( psRoot );        return eOGRErr;    }    pszSRCodeSpace =         CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.codeSpace.CharacterString", "" );    if( !EQUAL( pszSRCodeSpace, "WKT" ) )    {        CPLError( CE_Failure, CPLE_AppDefined,            "Spatial reference string is not in WKT." );        CPLDestroyXMLNode( psRoot );        return eOGRErr;    }    if( EQUALN(pszSRCodeString, "VERTCS", 6 ) )    {        CPLString oString( pszProjection );        oString += ",";        oString += pszSRCodeString;        if ( pszProjection )            CPLFree( pszProjection );        pszProjection = CPLStrdup( oString );    }    CPLDestroyXMLNode( psRoot );        return eOGRErr;}

//.........这里部分代码省略.........                strcmp(psChild->pszValue, "xlink:href") == 0 &&                (strncmp(psChild->psChild->pszValue, "http://", strlen("http://")) == 0 ||                 strncmp(psChild->psChild->pszValue, "https://", strlen("https://")) == 0) )            {                if( !bOpenRemoteResources )                    CPLDebug("GMLJP2", "Remote feature collection %s mentionned in GMLJP2 box",                             psChild->psChild->pszValue);                else                    osGMLTmpFile = "/vsicurl/" + CPLString(psChild->psChild->pszValue);            }            else if( psChild->eType == CXT_Element &&                     strstr(psChild->pszValue, "FeatureCollection") != NULL )            {                psFC = psChild;            }            if( psFC == NULL && osGMLTmpFile.size() == 0 )                continue;            if( psFC != NULL )            {                osGMLTmpFile = CPLSPrintf("/vsimem/gmljp2/%p/my.gml", this);                // Create temporary .gml file                CPLSerializeXMLTreeToFile(psFC, osGMLTmpFile);            }            CPLDebug("GMLJP2", "Found a FeatureCollection at %s level",                     (bIsGC) ? "GridCoverage" : "CoverageCollection");            CPLString osXSDTmpFile;            if( psFC )            {                // Try to localize its .xsd schema in a GMLJP2 auxiliary box                const char* pszSchemaLocation = CPLGetXMLValue(psFC, "xsi:schemaLocation", NULL);                if( pszSchemaLocation )                {                    char **papszTokens = CSLTokenizeString2(                            pszSchemaLocation, " /t/n",                             CSLT_HONOURSTRINGS | CSLT_STRIPLEADSPACES | CSLT_STRIPENDSPACES);                    if( (CSLCount(papszTokens) % 2) == 0 )                    {                        for(char** papszIter = papszTokens; *papszIter; papszIter += 2 )                        {                            if( strncmp(papszIter[1], "gmljp2://xml/", strlen("gmljp2://xml/")) == 0 )                            {                                const char* pszBoxName = papszIter[1] + strlen("gmljp2://xml/");                                char** papszBoxData = GetMetadata(CPLSPrintf("xml:%s", pszBoxName));                                if( papszBoxData != NULL )                                {                                    osXSDTmpFile = CPLSPrintf("/vsimem/gmljp2/%p/my.xsd", this);                                    VSIFCloseL(VSIFileFromMemBuffer(osXSDTmpFile,                                                                    (GByte*)papszBoxData[0],                                                                    strlen(papszBoxData[0]),                                                                    FALSE));                                }                                else                                {                                    CPLDebug("GMLJP2",                                            "Feature collection references %s, but no corresponding box found",                                            papszIter[1]);                                }                                break;                            }                        }                    }

static OGRGeometry* ParseKMLGeometry(/* const */ CPLXMLNode* psXML){    OGRGeometry* poGeom = nullptr;    const char* pszGeomType = psXML->pszValue;    if (strcmp(pszGeomType, "Point") == 0)    {        const char* pszCoordinates = CPLGetXMLValue(psXML, "coordinates", nullptr);        if (pszCoordinates)        {            char** papszTokens = CSLTokenizeString2(pszCoordinates, ",", 0);            if (CSLCount(papszTokens) == 2)                poGeom = new OGRPoint(CPLAtof(papszTokens[0]), CPLAtof(papszTokens[1]));            else if (CSLCount(papszTokens) == 3)                poGeom = new OGRPoint(CPLAtof(papszTokens[0]), CPLAtof(papszTokens[1]),                                      CPLAtof(papszTokens[2]));            CSLDestroy(papszTokens);        }    }    else if (strcmp(pszGeomType, "LineString") == 0)    {        const char* pszCoordinates = CPLGetXMLValue(psXML, "coordinates", nullptr);        if (pszCoordinates)        {            OGRLineString* poLS = new OGRLineString();            ParseLineString(poLS, pszCoordinates);            poGeom = poLS;        }    }    else if (strcmp(pszGeomType, "Polygon") == 0)    {        OGRPolygon* poPoly = nullptr;        CPLXMLNode* psOuterBoundary = CPLGetXMLNode(psXML, "outerBoundaryIs");        if (psOuterBoundary)        {            CPLXMLNode* psLinearRing = CPLGetXMLNode(psOuterBoundary, "LinearRing");            const char* pszCoordinates = CPLGetXMLValue(                psLinearRing ? psLinearRing : psOuterBoundary, "coordinates", nullptr);            if (pszCoordinates)            {                OGRLinearRing* poLS = new OGRLinearRing();                ParseLineString(poLS, pszCoordinates);                poPoly = new OGRPolygon();                poPoly->addRingDirectly(poLS);                poGeom = poPoly;            }            if (poPoly)            {                CPLXMLNode* psIter = psXML->psChild;                while(psIter)                {                    if (psIter->eType == CXT_Element &&                        strcmp(psIter->pszValue, "innerBoundaryIs") == 0)                    {                        psLinearRing = CPLGetXMLNode(psIter, "LinearRing");                        pszCoordinates = CPLGetXMLValue(                            psLinearRing ? psLinearRing : psIter, "coordinates", nullptr);                        if (pszCoordinates)                        {                            OGRLinearRing* poLS = new OGRLinearRing();                            ParseLineString(poLS, pszCoordinates);                            poPoly->addRingDirectly(poLS);                        }                    }                    psIter = psIter->psNext;                }            }        }    }    else if (strcmp(pszGeomType, "MultiGeometry") == 0)    {        CPLXMLNode* psIter = nullptr;        OGRwkbGeometryType eType = wkbUnknown;        for(psIter = psXML->psChild; psIter; psIter = psIter->psNext)        {            if (psIter->eType == CXT_Element)            {                OGRwkbGeometryType eNewType = wkbUnknown;                if (strcmp(psIter->pszValue, "Point") == 0)                {                    eNewType = wkbPoint;                }                else if (strcmp(psIter->pszValue, "LineString") == 0)                {                    eNewType = wkbLineString;                }                else if (strcmp(psIter->pszValue, "Polygon") == 0)                {                    eNewType = wkbPolygon;                }                else                    break;                if (eType == wkbUnknown)                    eType = eNewType;                else if (eType != eNewType)                    break;            }        }        OGRGeometryCollection* poColl = nullptr;        if (psIter != nullptr)//.........这里部分代码省略.........

CPLErr GDALWMSMiniDriver_AGS::Initialize(CPLXMLNode *config){	CPLErr ret = CE_None;	int i;    if (ret == CE_None)     {        const char *base_url = CPLGetXMLValue(config, "ServerURL", "");        if (base_url[0] != '/0')         {            /* Try the old name */            base_url = CPLGetXMLValue(config, "ServerUrl", "");        }                if (base_url[0] != '/0')         {            m_base_url = base_url;        }        else         {            CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS, ArcGIS Server mini-driver: ServerURL missing.");            ret = CE_Failure;        }    }	if (ret == CE_None) 	{        m_image_format = CPLGetXMLValue(config, "ImageFormat", "png");        m_transparent = CPLGetXMLValue(config, "Transparent","");		// the transparent flag needs to be "true" or "false" 		// in lower case according to the ArcGIS Server REST API        for(i = 0; i < (int)m_transparent.size(); i++)        {			m_transparent[i] = (char) tolower(m_transparent[i]);        }        		m_layers = CPLGetXMLValue(config, "Layers", "");    }    	if (ret == CE_None) 	{		const char* irs = CPLGetXMLValue(config, "SRS", "102100");				if (irs != NULL)		{	        if(EQUALN(irs, "EPSG:", 5)) //if we have EPSG code just convert it to WKT	        {	            m_projection_wkt = ProjToWKT(irs);	            m_irs = irs + 5;	        }	        else //if we have AGS code - try if it's EPSG		    {		        m_irs = irs;		        m_projection_wkt = ProjToWKT("EPSG:" + m_irs);		    }		    // TODO: if we have AGS JSON    		}		m_identification_tolerance = CPLGetXMLValue(config, "IdentificationTolerance", "2");	}	if (ret == CE_None)	{        const char *bbox_order = CPLGetXMLValue(config, "BBoxOrder", "xyXY");        if (bbox_order[0] != '/0')         {            for (i = 0; i < 4; ++i)             {                if ((bbox_order[i] != 'x') && (bbox_order[i] != 'y') &&                     (bbox_order[i] != 'X') && (bbox_order[i] != 'Y'))                     break;            }                        if (i == 4)             {                m_bbox_order = bbox_order;            }             else             {                CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS, ArcGIS Server mini-driver: Incorrect BBoxOrder.");                ret = CE_Failure;            }        }         else        {            CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS, ArcGIS Server mini-driver: BBoxOrder missing.");            ret = CE_Failure;        }    }	    return ret;}

VSIVirtualHandle *VSISparseFileFilesystemHandler::Open( const char *pszFilename,                                       const char *pszAccess ){    CPLAssert( EQUALN(pszFilename,"/vsisparse/", 11) );    if( !EQUAL(pszAccess,"r") && !EQUAL(pszAccess,"rb") )    {        errno = EACCES;        return NULL;    }    /* Arbitrary number */    if( GetRecCounter() == 32 )        return NULL;    CPLString osSparseFilePath = pszFilename + 11;/* -------------------------------------------------------------------- *//*      Does this file even exist?                                      *//* -------------------------------------------------------------------- */    VSILFILE *fp = VSIFOpenL( osSparseFilePath, "r" );    if( fp == NULL )        return NULL;    VSIFCloseL( fp );/* -------------------------------------------------------------------- *//*      Read the XML file.                                              *//* -------------------------------------------------------------------- */    CPLXMLNode *psXMLRoot = CPLParseXMLFile( osSparseFilePath );    if( psXMLRoot == NULL )        return NULL;/* -------------------------------------------------------------------- *//*      Setup the file handle on this file.                             *//* -------------------------------------------------------------------- */    VSISparseFileHandle *poHandle = new VSISparseFileHandle(this);/* -------------------------------------------------------------------- *//*      Translate the desired fields out of the XML tree.               *//* -------------------------------------------------------------------- */    CPLXMLNode *psRegion;    for( psRegion = psXMLRoot->psChild;         psRegion != NULL;         psRegion = psRegion->psNext )    {        if( psRegion->eType != CXT_Element )            continue;        if( !EQUAL(psRegion->pszValue,"SubfileRegion")            && !EQUAL(psRegion->pszValue,"ConstantRegion") )            continue;        SFRegion oRegion;        oRegion.osFilename = CPLGetXMLValue( psRegion, "Filename", "" );        if( atoi(CPLGetXMLValue( psRegion, "Filename.relative", "0" )) != 0 )        {            CPLString osSFPath = CPLGetPath(osSparseFilePath);            oRegion.osFilename = CPLFormFilename( osSFPath,                                                  oRegion.osFilename, NULL );        }        oRegion.nDstOffset =             CPLScanUIntBig( CPLGetXMLValue(psRegion,"DestinationOffset","0" ),                            32 );        oRegion.nSrcOffset =             CPLScanUIntBig( CPLGetXMLValue(psRegion,"SourceOffset","0" ), 32);        oRegion.nLength =             CPLScanUIntBig( CPLGetXMLValue(psRegion,"RegionLength","0" ), 32);        oRegion.byValue = (GByte) atoi(CPLGetXMLValue(psRegion,"Value","0" ));        poHandle->aoRegions.push_back( oRegion );    }/* -------------------------------------------------------------------- *//*      Get sparse file length, use maximum bound of regions if not     *//*      explicit in file.                                               *//* -------------------------------------------------------------------- */    poHandle->nOverallLength =         CPLScanUIntBig( CPLGetXMLValue(psXMLRoot,"Length","0" ), 32);    if( poHandle->nOverallLength == 0 )    {        for( unsigned int i = 0; i < poHandle->aoRegions.size(); i++ )        {            poHandle->nOverallLength = MAX(poHandle->nOverallLength,                                           poHandle->aoRegions[i].nDstOffset                                           + poHandle->aoRegions[i].nLength);        }    }    CPLDestroyXMLNode( psXMLRoot );    return poHandle;//.........这里部分代码省略.........

GDALDataset* ECRGTOCDataset::Build(const char* pszTOCFilename,                                   CPLXMLNode* psXML,                                   CPLString osProduct,                                   CPLString osDiscId,                                   const char* pszOpenInfoFilename){    CPLXMLNode* psTOC = CPLGetXMLNode(psXML, "=Table_of_Contents");    if (psTOC == NULL)    {        CPLError(CE_Warning, CPLE_AppDefined,                 "Cannot find Table_of_Contents element");        return NULL;    }    double dfGlobalMinX = 0, dfGlobalMinY = 0, dfGlobalMaxX = 0, dfGlobalMaxY= 0;    double dfGlobalPixelXSize = 0, dfGlobalPixelYSize = 0;    int bGlobalExtentValid = FALSE;    ECRGTOCDataset* poDS = new ECRGTOCDataset();    int nSubDatasets = 0;    int bLookForSubDataset = osProduct.size() != 0 && osDiscId.size() != 0;    int nCountSubDataset = 0;    poDS->SetDescription( pszOpenInfoFilename );    poDS->papszFileList = poDS->GDALDataset::GetFileList();    for(CPLXMLNode* psIter1 = psTOC->psChild;                    psIter1 != NULL;                    psIter1 = psIter1->psNext)    {        if (!(psIter1->eType == CXT_Element && psIter1->pszValue != NULL &&              strcmp(psIter1->pszValue, "product") == 0))            continue;        const char* pszProductTitle =            CPLGetXMLValue(psIter1, "product_title", NULL);        if (pszProductTitle == NULL)        {            CPLError(CE_Warning, CPLE_AppDefined,                        "Cannot find product_title attribute");            continue;        }        if (bLookForSubDataset && strcmp(pszProductTitle, osProduct.c_str()) != 0)            continue;        for(CPLXMLNode* psIter2 = psIter1->psChild;                        psIter2 != NULL;                        psIter2 = psIter2->psNext)        {            if (!(psIter2->eType == CXT_Element && psIter2->pszValue != NULL &&                  strcmp(psIter2->pszValue, "disc") == 0))                continue;            const char* pszDiscId = CPLGetXMLValue(psIter2, "id", NULL);            if (pszDiscId == NULL)            {                CPLError(CE_Warning, CPLE_AppDefined,                            "Cannot find id attribute");                continue;            }            if (bLookForSubDataset && strcmp(pszDiscId, osDiscId.c_str()) != 0)                continue;            nCountSubDataset ++;            CPLXMLNode* psFrameList = CPLGetXMLNode(psIter2, "frame_list");            if (psFrameList == NULL)            {                CPLError(CE_Warning, CPLE_AppDefined,                            "Cannot find frame_list element");                continue;            }            int nValidFrames = 0;            std::vector<FrameDesc> aosFrameDesc;            int nSubDatasetScale = -1;            for(CPLXMLNode* psIter3 = psFrameList->psChild;                            psIter3 != NULL;                            psIter3 = psIter3->psNext)            {                if (!(psIter3->eType == CXT_Element &&                      psIter3->pszValue != NULL &&                      strcmp(psIter3->pszValue, "scale") == 0))                    continue;                const char* pszSize = CPLGetXMLValue(psIter3, "size", NULL);                if (pszSize == NULL)                {                    CPLError(CE_Warning, CPLE_AppDefined,                                "Cannot find size attribute");                    continue;                }//.........这里部分代码省略.........

GDALDataset *DIMAPDataset::Open( GDALOpenInfo * poOpenInfo ){    if( !Identify( poOpenInfo ) )        return NULL;        /* -------------------------------------------------------------------- *//*      Confirm the requested access is supported.                      *//* -------------------------------------------------------------------- */    if( poOpenInfo->eAccess == GA_Update )    {        CPLError( CE_Failure, CPLE_NotSupported,                   "The DIMAP driver does not support update access to existing"                  " datasets./n" );        return NULL;    }/* -------------------------------------------------------------------- *//*      Get the metadata filename.                                      *//* -------------------------------------------------------------------- */    CPLString osMDFilename;    if( poOpenInfo->bIsDirectory )    {        osMDFilename =             CPLFormCIFilename( poOpenInfo->pszFilename, "METADATA.DIM", NULL );    }    else        osMDFilename = poOpenInfo->pszFilename;/* -------------------------------------------------------------------- *//*      Ingest the xml file.                                            *//* -------------------------------------------------------------------- */    CPLXMLNode *psProduct, *psImageAttributes;    psProduct = CPLParseXMLFile( osMDFilename );    if( psProduct == NULL )        return NULL;    CPLXMLNode *psDoc = CPLGetXMLNode( psProduct, "=Dimap_Document" );    psImageAttributes = CPLGetXMLNode( psDoc, "Raster_Dimensions" );    if( psImageAttributes == NULL )    {        CPLError( CE_Failure, CPLE_OpenFailed,                   "Failed to find <Raster_Dimensions> in document." );        return NULL;    }/* -------------------------------------------------------------------- *//*      Create the dataset.                                             *//* -------------------------------------------------------------------- */    DIMAPDataset *poDS = new DIMAPDataset();    poDS->psProduct = psProduct;/* -------------------------------------------------------------------- *//*      Get overall image information.                                  *//* -------------------------------------------------------------------- */#ifdef DEBUG    int nBands =         atoi(CPLGetXMLValue( psImageAttributes, "NBANDS", "-1" ));#endif    poDS->nRasterXSize =         atoi(CPLGetXMLValue( psImageAttributes, "NCOLS", "-1" ));    poDS->nRasterYSize =         atoi(CPLGetXMLValue( psImageAttributes, "NROWS", "-1" ));/* -------------------------------------------------------------------- *//*      Get the name of the underlying file.                            *//* -------------------------------------------------------------------- */    const char *pszHref = CPLGetXMLValue(        psDoc, "Data_Access.Data_File.DATA_FILE_PATH.href", "" );    CPLString osPath = CPLGetPath(osMDFilename);    CPLString osImageFilename =         CPLFormFilename( osPath, pszHref, NULL );                                   /* -------------------------------------------------------------------- *//*      Try and open the file.                                          *//* -------------------------------------------------------------------- */    poDS->poImageDS = (GDALDataset *) GDALOpen( osImageFilename, GA_ReadOnly );    if( poDS->poImageDS == NULL )    {        delete poDS;        return NULL;    }        /* -------------------------------------------------------------------- *//*      Attach the bands.                                               *//* -------------------------------------------------------------------- */    int iBand;    CPLAssert( nBands == poDS->poImageDS->GetRasterCount() );    for( iBand = 1; iBand <= poDS->poImageDS->GetRasterCount(); iBand++ )        poDS->SetBand( iBand, poDS->poImageDS->GetRasterBand( iBand ) );/* -------------------------------------------------------------------- *//*      Try to collect simple insertion point.                          *//* -------------------------------------------------------------------- */    CPLXMLNode *psGeoLoc =  //.........这里部分代码省略.........

GDALDataset *TSXDataset::Open( GDALOpenInfo *poOpenInfo ) {/* -------------------------------------------------------------------- *//*      Is this a TerraSAR-X product file?                              *//* -------------------------------------------------------------------- */	if (!TSXDataset::Identify( poOpenInfo )) {		return NULL; /* nope */	}    /* -------------------------------------------------------------------- *//*      Confirm the requested access is supported.                      *//* -------------------------------------------------------------------- */    if( poOpenInfo->eAccess == GA_Update )    {        CPLError( CE_Failure, CPLE_NotSupported,                   "The TSX driver does not support update access to existing"                  " datasets./n" );        return NULL;    }    	/* Ingest the XML */	CPLXMLNode *psData, *psComponents, *psProductInfo;	psData = CPLParseXMLFile( poOpenInfo->pszFilename );	/* find the product components */	psComponents = CPLGetXMLNode( psData, "=level1Product.productComponents" );	if (psComponents == NULL) {		CPLError( CE_Failure, CPLE_OpenFailed, 			"Unable to find <productComponents> tag in file./n" );		return NULL;	}	/* find the product info tag */	psProductInfo = CPLGetXMLNode( psData, "=level1Product.productInfo" );	if (psComponents == NULL) {		CPLError( CE_Failure, CPLE_OpenFailed,			"Unable to find <productInfo> tag in file./n" );		return NULL;	}/* -------------------------------------------------------------------- *//*      Create the dataset.                                             *//* -------------------------------------------------------------------- */	    TSXDataset *poDS = new TSXDataset();	poDS->fp = poOpenInfo->fp;	poOpenInfo->fp = NULL;/* -------------------------------------------------------------------- *//*      Read in product info.                                           *//* -------------------------------------------------------------------- */    poDS->SetMetadataItem( "SCENE_CENTRE_TIME", CPLGetXMLValue( psProductInfo,        "sceneInfo.sceneCenterCoord.azimuthTimeUTC", "unknown" ) );	poDS->SetMetadataItem( "OPERATIONAL_MODE", CPLGetXMLValue( psProductInfo, 		"generationInfo.groundOperationsType", "unknown" ) );	poDS->SetMetadataItem( "ORBIT_CYCLE", CPLGetXMLValue( psProductInfo,		"missionInfo.orbitCycle", "unknown" ) );	poDS->SetMetadataItem( "ABSOLUTE_ORBIT", CPLGetXMLValue( psProductInfo,		"missionInfo.absOrbit", "unknown" ) );	poDS->SetMetadataItem( "ORBIT_DIRECTION", CPLGetXMLValue( psProductInfo,		"missionInfo.orbitDirection", "unknown" ) );	poDS->SetMetadataItem( "IMAGING_MODE", CPLGetXMLValue( psProductInfo,		"acquisitionInfo.imagingMode", "unknown" ) );	poDS->SetMetadataItem( "PRODUCT_VARIANT", CPLGetXMLValue( psProductInfo,		"productVariantInfo.productVariant", "unknown" ) ); 	char *pszDataType = strdup( CPLGetXMLValue( psProductInfo,		"imageDataInfo.imageDataType", "unknown" ) );	poDS->SetMetadataItem( "IMAGE_TYPE", pszDataType ); 		/* Get raster information */	int nRows = atoi( CPLGetXMLValue( psProductInfo,		"imageDataInfo.imageRaster.numberOfRows", "" ) );	int nCols = atoi( CPLGetXMLValue( psProductInfo,		"imageDataInfo.imageRaster.numberOfColumns", "" ) );	poDS->nRasterXSize = nCols;	poDS->nRasterYSize = nRows;	poDS->SetMetadataItem( "ROW_SPACING", CPLGetXMLValue( psProductInfo,		"imageDataInfo.imageRaster.rowSpacing", "unknown" ) );	poDS->SetMetadataItem( "COL_SPACING", CPLGetXMLValue( psProductInfo,		"imageDataInfo.imageRaster.columnSpacing", "unknown" ) );    poDS->SetMetadataItem( "COL_SPACING_UNITS", CPLGetXMLValue( psProductInfo,        "imageDataInfo.imageRaster.columnSpacing.units", "unknown" ) );	/* Get equivalent number of looks */	poDS->SetMetadataItem( "AZIMUTH_LOOKS", CPLGetXMLValue( psProductInfo,		"imageDataInfo.imageRaster.azimuthLooks", "unknown" ) );	poDS->SetMetadataItem( "RANGE_LOOKS", CPLGetXMLValue( psProductInfo,		"imageDataInfo.imageRaster.rangeLooks", "unknown" ) );    const char *pszProductVariant;    pszProductVariant = CPLGetXMLValue( psProductInfo,         "productVariantInfo.productVariant", "unknown" );    poDS->SetMetadataItem( "PRODUCT_VARIANT", pszProductVariant );    /* Determine what product variant this is */    if (EQUALN(pszProductVariant,"SSC",3))        poDS->nProduct = eSSC;//.........这里部分代码省略.........

CPLErr VRTWarpedDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath ){    CPLErr eErr;/* -------------------------------------------------------------------- *//*      Initialize blocksize before calling sub-init so that the        *//*      band initializers can get it from the dataset object when       *//*      they are created.                                               *//* -------------------------------------------------------------------- */    nBlockXSize = atoi(CPLGetXMLValue(psTree,"BlockXSize","512"));    nBlockYSize = atoi(CPLGetXMLValue(psTree,"BlockYSize","128"));/* -------------------------------------------------------------------- *//*      Initialize all the general VRT stuff.  This will even           *//*      create the VRTWarpedRasterBands and initialize them.            *//* -------------------------------------------------------------------- */    eErr = VRTDataset::XMLInit( psTree, pszVRTPath );    if( eErr != CE_None )        return eErr;/* -------------------------------------------------------------------- *//*      Find the GDALWarpOptions XML tree.                              *//* -------------------------------------------------------------------- */    CPLXMLNode *psOptionsTree;    psOptionsTree = CPLGetXMLNode( psTree, "GDALWarpOptions" );    if( psOptionsTree == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "Count not find required GDALWarpOptions in XML." );        return CE_Failure;    }/* -------------------------------------------------------------------- *//*      Adjust the SourceDataset in the warp options to take into       *//*      account that it is relative to the VRT if appropriate.          *//* -------------------------------------------------------------------- */    int bRelativeToVRT =         atoi(CPLGetXMLValue(psOptionsTree,                            "SourceDataset.relativeToVRT", "0" ));    const char *pszRelativePath = CPLGetXMLValue(psOptionsTree,                                                 "SourceDataset", "" );    char *pszAbsolutePath;    if( bRelativeToVRT )        pszAbsolutePath =             CPLStrdup(CPLProjectRelativeFilename( pszVRTPath,                                                   pszRelativePath ) );    else        pszAbsolutePath = CPLStrdup(pszRelativePath);    CPLSetXMLValue( psOptionsTree, "SourceDataset", pszAbsolutePath );    CPLFree( pszAbsolutePath );/* -------------------------------------------------------------------- *//*      And instantiate the warp options, and corresponding warp        *//*      operation.                                                      *//* -------------------------------------------------------------------- */    GDALWarpOptions *psWO;    psWO = GDALDeserializeWarpOptions( psOptionsTree );    if( psWO == NULL )        return CE_Failure;    this->eAccess = GA_Update;    psWO->hDstDS = this;/* -------------------------------------------------------------------- *//*      Instantiate the warp operation.                                 *//* -------------------------------------------------------------------- */    poWarper = new GDALWarpOperation();    eErr = poWarper->Initialize( psWO );    if( eErr != CE_None)    {/* -------------------------------------------------------------------- *//*      We are responsible for cleaning up the transformer outselves.   *//* -------------------------------------------------------------------- */        if( psWO->pTransformerArg != NULL )            GDALDestroyTransformer( psWO->pTransformerArg );    }    GDALDestroyWarpOptions( psWO );    if( eErr != CE_None )    {        delete poWarper;        poWarper = NULL;    }/* -------------------------------------------------------------------- *//*      Generate overviews, if appropriate.                             *//* -------------------------------------------------------------------- */    char **papszTokens = CSLTokenizeString(         CPLGetXMLValue( psTree, "OverviewList", "" ));    int iOverview;    for( iOverview = 0;          papszTokens != NULL && papszTokens[iOverview] != NULL;//.........这里部分代码省略.........

bool TSXDataset::getGCPsFromGEOREF_XML(char *pszGeorefFilename){    //open GEOREF.xml    CPLXMLNode *psGeorefData = CPLParseXMLFile( pszGeorefFilename );    if (psGeorefData==NULL)        return false;    //get the ellipsoid and semi-major, semi-minor axes    OGRSpatialReference osr;    CPLXMLNode *psSphere = CPLGetXMLNode( psGeorefData, "=geoReference.referenceFrames.sphere" );    if (psSphere!=NULL)    {        const char *pszEllipsoidName            = CPLGetXMLValue( psSphere, "ellipsoidID", "" );        const double minor_axis = CPLAtof(CPLGetXMLValue( psSphere, "semiMinorAxis", "0.0" ));        const double major_axis = CPLAtof(CPLGetXMLValue( psSphere, "semiMajorAxis", "0.0" ));        //save datum parameters to the spatial reference        if ( EQUAL(pszEllipsoidName, "") || minor_axis==0.0 || major_axis==0.0 )        {            CPLError(CE_Warning,CPLE_AppDefined,"Warning- incomplete"                " ellipsoid information.  Using wgs-84 parameters./n");            osr.SetWellKnownGeogCS( "WGS84" );        }        else if ( EQUAL( pszEllipsoidName, "WGS84" ) ) {            osr.SetWellKnownGeogCS( "WGS84" );        }        else {            const double inv_flattening = major_axis/(major_axis - minor_axis);            osr.SetGeogCS( "","",pszEllipsoidName, major_axis, inv_flattening);        }    }    //get gcps    CPLXMLNode *psGeolocationGrid        = CPLGetXMLNode( psGeorefData, "=geoReference.geolocationGrid" );    if (psGeolocationGrid==NULL)    {        CPLDestroyXMLNode( psGeorefData );        return false;    }    nGCPCount        = atoi(CPLGetXMLValue( psGeolocationGrid, "numberOfGridPoints.total", "0" ));    //count the gcps if the given count value is invalid    CPLXMLNode *psNode;    if (nGCPCount<=0)    {        for( psNode = psGeolocationGrid->psChild; psNode != NULL; psNode = psNode->psNext )            if( EQUAL(psNode->pszValue,"gridPoint") )                nGCPCount++ ;    }    //if there are no gcps, fail    if(nGCPCount<=0)    {        CPLDestroyXMLNode( psGeorefData );        return false;    }    //put some reasonable limits of the number of gcps    if (nGCPCount>MAX_GCPS )        nGCPCount=MAX_GCPS;    //allocate memory for the gcps    pasGCPList = reinterpret_cast<GDAL_GCP *>(        CPLCalloc(sizeof(GDAL_GCP), nGCPCount) );    //loop through all gcps and set info    //save the number allocated to ensure it does not run off the end of the array    const int gcps_allocated = nGCPCount;    nGCPCount=0;    //reset to zero and count    //do a check on the grid point to make sure it has lat,long row, and column    //it seems that only SSC products contain row, col - how to map lat long otherwise??    //for now fail if row and col are not present - just check the first and assume the rest are the same    for( psNode = psGeolocationGrid->psChild; psNode != NULL; psNode = psNode->psNext )    {         if( !EQUAL(psNode->pszValue,"gridPoint") )             continue;         if (    !strcmp(CPLGetXMLValue(psNode,"col","error"), "error") ||                 !strcmp(CPLGetXMLValue(psNode,"row","error"), "error") ||                 !strcmp(CPLGetXMLValue(psNode,"lon","error"), "error") ||                 !strcmp(CPLGetXMLValue(psNode,"lat","error"), "error"))        {            CPLDestroyXMLNode( psGeorefData );            return false;        }    }    for( psNode = psGeolocationGrid->psChild; psNode != NULL; psNode = psNode->psNext )    {        //break out if the end of the array has been reached        if (nGCPCount >= gcps_allocated)        {            CPLError(CE_Warning, CPLE_AppDefined, "GDAL TSX driver: Truncating the number of GCPs.");            break;        }         GDAL_GCP   *psGCP = pasGCPList + nGCPCount;         if( !EQUAL(psNode->pszValue,"gridPoint") )             continue;//.........这里部分代码省略.........

staticGMLFeatureClass* GMLParseFeatureType(CPLXMLNode *psSchemaNode,                                     const char* pszName,                                     CPLXMLNode *psComplexType){/* -------------------------------------------------------------------- *//*      Grab the sequence of extensions greatgrandchild.                *//* -------------------------------------------------------------------- */    CPLXMLNode *psAttrSeq =        CPLGetXMLNode( psComplexType,                        "complexContent.extension.sequence" );    if( psAttrSeq == NULL )    {        return NULL;    }/* -------------------------------------------------------------------- *//*      We are pretty sure this going to be a valid Feature class       *//*      now, so create it.                                              *//* -------------------------------------------------------------------- */    GMLFeatureClass *poClass = new GMLFeatureClass( pszName );/* -------------------------------------------------------------------- *//*      Loop over each of the attribute elements being defined for      *//*      this feature class.                                             *//* -------------------------------------------------------------------- */    CPLXMLNode *psAttrDef;    int nAttributeIndex = 0;    int bGotUnrecognizedType = FALSE;    for( psAttrDef = psAttrSeq->psChild;            psAttrDef != NULL;            psAttrDef = psAttrDef->psNext )    {        if( strcmp(psAttrDef->pszValue,"group") == 0 )        {            /* Too complex schema for us. Aborts parsing */            delete poClass;            return NULL;        }        if( !EQUAL(psAttrDef->pszValue,"element") )            continue;        /* MapServer WFS writes element type as an attribute of element */        /* not as a simpleType definition */        const char* pszType = CPLGetXMLValue( psAttrDef, "type", NULL );        const char* pszElementName = CPLGetXMLValue( psAttrDef, "name", NULL );        if (pszType != NULL)        {            const char* pszStrippedNSType = StripNS(pszType);            int nWidth = 0, nPrecision = 0;            GMLPropertyType gmlType = GMLPT_Untyped;            if (EQUAL(pszStrippedNSType, "string") ||                EQUAL(pszStrippedNSType, "Character"))                gmlType = GMLPT_String;            /* TODO: Would be nice to have a proper date type */            else if (EQUAL(pszStrippedNSType, "date") ||                     EQUAL(pszStrippedNSType, "dateTime"))                gmlType = GMLPT_String;            else if (EQUAL(pszStrippedNSType, "real") ||                     EQUAL(pszStrippedNSType, "double") ||                     EQUAL(pszStrippedNSType, "float") ||                     EQUAL(pszStrippedNSType, "decimal"))                gmlType = GMLPT_Real;            else if (EQUAL(pszStrippedNSType, "short") ||                     EQUAL(pszStrippedNSType, "int") ||                     EQUAL(pszStrippedNSType, "integer") ||                     EQUAL(pszStrippedNSType, "long"))                gmlType = GMLPT_Integer;            else if (strncmp(pszType, "gml:", 4) == 0)            {                const AssocNameType* psIter = apsPropertyTypes;                while(psIter->pszName)                {                    if (strncmp(pszType + 4, psIter->pszName, strlen(psIter->pszName)) == 0)                    {                        if (poClass->GetGeometryAttributeIndex() != -1)                        {                            CPLDebug("GML", "Geometry field already found ! Ignoring the following ones");                        }                        else                        {                            poClass->SetGeometryElement(pszElementName);                            poClass->SetGeometryType(psIter->eType);                            poClass->SetGeometryAttributeIndex( nAttributeIndex );                            nAttributeIndex ++;                        }                                                break;                    }                    psIter ++;                }//.........这里部分代码省略.........

void *GDALDeserializeGCPTransformer( CPLXMLNode *psTree ){    GDAL_GCP *pasGCPList = 0;    int nGCPCount = 0;    void *pResult;    int nReqOrder;    int bReversed;    int bRefine;    int nMinimumGcps;    double dfTolerance;    /* -------------------------------------------------------------------- */    /*      Check for GCPs.                                                 */    /* -------------------------------------------------------------------- */    CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );    if( psGCPList != NULL )    {        int  nGCPMax = 0;        CPLXMLNode *psXMLGCP;                 // Count GCPs.        for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;              psXMLGCP = psXMLGCP->psNext )            nGCPMax++;                 pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);        for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;              psXMLGCP = psXMLGCP->psNext )        {            GDAL_GCP *psGCP = pasGCPList + nGCPCount;            if( !EQUAL(psXMLGCP->pszValue,"GCP") ||                 psXMLGCP->eType != CXT_Element )                continue;                         GDALInitGCPs( 1, psGCP );                         CPLFree( psGCP->pszId );            psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));                         CPLFree( psGCP->pszInfo );            psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));                         psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));            psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));                         psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));            psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));            psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));            nGCPCount++;        }    }/* -------------------------------------------------------------------- *//*      Get other flags.                                                *//* -------------------------------------------------------------------- */    nReqOrder = atoi(CPLGetXMLValue(psTree,"Order","3"));    bReversed = atoi(CPLGetXMLValue(psTree,"Reversed","0"));    bRefine = atoi(CPLGetXMLValue(psTree,"Refine","0"));    nMinimumGcps = atoi(CPLGetXMLValue(psTree,"MinimumGcps","6"));    dfTolerance = atof(CPLGetXMLValue(psTree,"Tolerance","1.0"));/* -------------------------------------------------------------------- *//*      Generate transformation.                                        *//* -------------------------------------------------------------------- */    if(bRefine)    {        pResult = GDALCreateGCPRefineTransformer( nGCPCount, pasGCPList, nReqOrder,                                         bReversed, dfTolerance, nMinimumGcps );    }    else    {        pResult = GDALCreateGCPTransformer( nGCPCount, pasGCPList, nReqOrder,                                         bReversed );    }    /* -------------------------------------------------------------------- *//*      Cleanup GCP copy.                                               *//* -------------------------------------------------------------------- */    GDALDeinitGCPs( nGCPCount, pasGCPList );    CPLFree( pasGCPList );    return pResult;}

void BAGDataset::LoadMetadata(){/* -------------------------------------------------------------------- *//*      Load the metadata from the file.                                *//* -------------------------------------------------------------------- */    hid_t hMDDS = H5Dopen( hHDF5, "/BAG_root/metadata" );    hid_t datatype     = H5Dget_type( hMDDS );    hid_t dataspace    = H5Dget_space( hMDDS );    hid_t native       = H5Tget_native_type( datatype, H5T_DIR_ASCEND );    hsize_t dims[3], maxdims[3];    H5Sget_simple_extent_dims( dataspace, dims, maxdims );    pszXMLMetadata = (char *) CPLCalloc(dims[0]+1,1);    H5Dread( hMDDS, native, H5S_ALL, dataspace, H5P_DEFAULT, pszXMLMetadata );    H5Sclose( dataspace );    H5Tclose( datatype );    H5Dclose( hMDDS );    if( strlen(pszXMLMetadata) == 0 )        return;/* -------------------------------------------------------------------- *//*      Try to get the geotransform.                                    *//* -------------------------------------------------------------------- */    CPLXMLNode *psRoot = CPLParseXMLString( pszXMLMetadata );    if( psRoot == NULL )        return;    CPLStripXMLNamespace( psRoot, NULL, TRUE );    CPLXMLNode *psGeo = CPLSearchXMLNode( psRoot, "=MD_Georectified" );    if( psGeo != NULL )    {        char **papszCornerTokens =             CSLTokenizeStringComplex(                 CPLGetXMLValue( psGeo, "cornerPoints.Point.coordinates", "" ),                " ,", FALSE, FALSE );        if( CSLCount(papszCornerTokens ) == 4 )        {            double dfLLX = atof( papszCornerTokens[0] );            double dfLLY = atof( papszCornerTokens[1] );            double dfURX = atof( papszCornerTokens[2] );            double dfURY = atof( papszCornerTokens[3] );            adfGeoTransform[0] = dfLLX;            adfGeoTransform[1] = (dfURX - dfLLX) / (GetRasterXSize()-1);            adfGeoTransform[3] = dfURY;            adfGeoTransform[5] = (dfLLY - dfURY) / (GetRasterYSize()-1);            adfGeoTransform[0] -= adfGeoTransform[1] * 0.5;            adfGeoTransform[3] -= adfGeoTransform[5] * 0.5;        }        CSLDestroy( papszCornerTokens );    }    CPLDestroyXMLNode( psRoot );/* -------------------------------------------------------------------- *//*      Try to get the coordinate system.                               *//* -------------------------------------------------------------------- */    OGRSpatialReference oSRS;    if( OGR_SRS_ImportFromISO19115( &oSRS, pszXMLMetadata )        == OGRERR_NONE )    {        oSRS.exportToWkt( &pszProjection );    }}

CPLErr VRTRasterBand::XMLInit( CPLXMLNode * psTree,                                const char *pszVRTPath ){/* -------------------------------------------------------------------- *//*      Validate a bit.                                                 *//* -------------------------------------------------------------------- */    if( psTree == NULL || psTree->eType != CXT_Element        || !EQUAL(psTree->pszValue,"VRTRasterBand") )    {        CPLError( CE_Failure, CPLE_AppDefined,                   "Invalid node passed to VRTRasterBand::XMLInit()." );        return CE_Failure;    }/* -------------------------------------------------------------------- *//*      Set the band if provided as an attribute.                       *//* -------------------------------------------------------------------- */    const char* pszBand = CPLGetXMLValue( psTree, "band", NULL);    if( pszBand != NULL )    {        nBand = atoi(pszBand);    }/* -------------------------------------------------------------------- *//*      Set the band if provided as an attribute.                       *//* -------------------------------------------------------------------- */    const char *pszDataType = CPLGetXMLValue( psTree, "dataType", NULL);    if( pszDataType != NULL )    {        eDataType = GDALGetDataTypeByName(pszDataType);    }/* -------------------------------------------------------------------- *//*      Apply any band level metadata.                                  *//* -------------------------------------------------------------------- */    oMDMD.XMLInit( psTree, TRUE );/* -------------------------------------------------------------------- *//*      Collect various other items of metadata.                        *//* -------------------------------------------------------------------- */    SetDescription( CPLGetXMLValue( psTree, "Description", "" ) );        if( CPLGetXMLValue( psTree, "NoDataValue", NULL ) != NULL )        SetNoDataValue( CPLAtofM(CPLGetXMLValue( psTree, "NoDataValue", "0" )) );    if( CPLGetXMLValue( psTree, "HideNoDataValue", NULL ) != NULL )        bHideNoDataValue = CSLTestBoolean( CPLGetXMLValue( psTree, "HideNoDataValue", "0" ) );    SetUnitType( CPLGetXMLValue( psTree, "UnitType", NULL ) );    SetOffset( atof(CPLGetXMLValue( psTree, "Offset", "0.0" )) );    SetScale( atof(CPLGetXMLValue( psTree, "Scale", "1.0" )) );    if( CPLGetXMLValue( psTree, "ColorInterp", NULL ) != NULL )    {        const char *pszInterp = CPLGetXMLValue( psTree, "ColorInterp", NULL );        SetColorInterpretation(GDALGetColorInterpretationByName(pszInterp));    }/* -------------------------------------------------------------------- *//*      Category names.                                                 *//* -------------------------------------------------------------------- */    if( CPLGetXMLNode( psTree, "CategoryNames" ) != NULL )    {        CPLXMLNode *psEntry;        CSLDestroy( papszCategoryNames );        papszCategoryNames = NULL;        CPLStringList oCategoryNames;        for( psEntry = CPLGetXMLNode( psTree, "CategoryNames" )->psChild;             psEntry != NULL; psEntry = psEntry->psNext )        {            if( psEntry->eType != CXT_Element                 || !EQUAL(psEntry->pszValue,"Category")                 || (psEntry->psChild != NULL && psEntry->psChild->eType != CXT_Text) )                continue;                        oCategoryNames.AddString(                                (psEntry->psChild) ? psEntry->psChild->pszValue : "");        }        papszCategoryNames = oCategoryNames.StealList();    }/* -------------------------------------------------------------------- *//*      Collect a color table.                                          *//* -------------------------------------------------------------------- */    if( CPLGetXMLNode( psTree, "ColorTable" ) != NULL )    {        CPLXMLNode *psEntry;        GDALColorTable oTable;        int        iEntry = 0;        for( psEntry = CPLGetXMLNode( psTree, "ColorTable" )->psChild;             psEntry != NULL; psEntry = psEntry->psNext )        {            GDALColorEntry sCEntry;//.........这里部分代码省略.........

bool VSIDIRAz::AnalyseAzureFileList(    const CPLString& osBaseURL,    const char* pszXML){#if DEBUG_VERBOSE    CPLDebug("AZURE", "%s", pszXML);#endif    CPLXMLNode* psTree = CPLParseXMLString(pszXML);    if( psTree == nullptr )        return false;    CPLXMLNode* psEnumerationResults = CPLGetXMLNode(psTree, "=EnumerationResults");    bool bNonEmpty = false;    if( psEnumerationResults )    {        CPLString osPrefix = CPLGetXMLValue(psEnumerationResults, "Prefix", "");        CPLXMLNode* psBlobs = CPLGetXMLNode(psEnumerationResults, "Blobs");        if( psBlobs == nullptr )        {            psBlobs = CPLGetXMLNode(psEnumerationResults, "Containers");            if( psBlobs != nullptr )                bNonEmpty = true;        }        // Count the number of occurrences of a path. Can be 1 or 2. 2 in the case        // that both a filename and directory exist        std::map<CPLString, int> aoNameCount;        for(CPLXMLNode* psIter = psBlobs ? psBlobs->psChild : nullptr;            psIter != nullptr; psIter = psIter->psNext )        {            if( psIter->eType != CXT_Element )                continue;            if( strcmp(psIter->pszValue, "Blob") == 0 )            {                const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);                if( pszKey && strstr(pszKey, GDAL_MARKER_FOR_DIR) != nullptr )                {                    bNonEmpty = true;                }                else if( pszKey && strlen(pszKey) > osPrefix.size() )                {                    bNonEmpty = true;                    aoNameCount[pszKey + osPrefix.size()] ++;                }            }            else if( strcmp(psIter->pszValue, "BlobPrefix") == 0 ||                     strcmp(psIter->pszValue, "Container") == 0 )            {                bNonEmpty = true;                const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);                if( pszKey && strncmp(pszKey, osPrefix, osPrefix.size()) == 0 )                {                    CPLString osKey = pszKey;                    if( !osKey.empty() && osKey.back() == '/' )                        osKey.resize(osKey.size()-1);                    if( osKey.size() > osPrefix.size() )                    {                        aoNameCount[osKey.c_str() + osPrefix.size()] ++;                    }                }            }        }        for(CPLXMLNode* psIter = psBlobs ? psBlobs->psChild : nullptr;            psIter != nullptr; psIter = psIter->psNext )        {            if( psIter->eType != CXT_Element )                continue;            if( strcmp(psIter->pszValue, "Blob") == 0 )            {                const char* pszKey = CPLGetXMLValue(psIter, "Name", nullptr);                if( pszKey && strstr(pszKey, GDAL_MARKER_FOR_DIR) != nullptr )                {                    if( nRecurseDepth < 0 )                    {                        aoEntries.push_back(                            std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));                        auto& entry = aoEntries.back();                        entry->pszName = CPLStrdup(pszKey + osPrefix.size());                        char* pszMarker = strstr(entry->pszName, GDAL_MARKER_FOR_DIR);                        if( pszMarker )                            *pszMarker = '/0';                        entry->nMode = S_IFDIR;                        entry->bModeKnown = true;                    }                }                else if( pszKey && strlen(pszKey) > osPrefix.size() )                {                    aoEntries.push_back(                        std::unique_ptr<VSIDIREntry>(new VSIDIREntry()));                    auto& entry = aoEntries.back();                    entry->pszName = CPLStrdup(pszKey + osPrefix.size());                    entry->nSize = static_cast<GUIntBig>(                        CPLAtoGIntBig(CPLGetXMLValue(psIter, "Properties.Content-Length", "0")));                    entry->bSizeKnown = true;                    entry->nMode = S_IFDIR;                    entry->bModeKnown = true;//.........这里部分代码省略.........

int GMLParseXSD( const char *pszFile,                 std::vector<GMLFeatureClass*> & aosClasses){    if( pszFile == NULL )        return FALSE;/* -------------------------------------------------------------------- *//*      Load the raw XML file.                                          *//* -------------------------------------------------------------------- */    CPLXMLNode *psXSDTree = CPLParseXMLFile( pszFile );        if( psXSDTree == NULL )        return FALSE;/* -------------------------------------------------------------------- *//*      Strip off any namespace qualifiers.                             *//* -------------------------------------------------------------------- */    CPLStripXMLNamespace( psXSDTree, NULL, TRUE );/* -------------------------------------------------------------------- *//*      Find <schema> root element.                                     *//* -------------------------------------------------------------------- */    CPLXMLNode *psSchemaNode = CPLGetXMLNode( psXSDTree, "=schema" );    if( psSchemaNode == NULL )    {        CPLDestroyXMLNode( psXSDTree );        return FALSE;    }/* ==================================================================== *//*      Process each feature class definition.                          *//* ==================================================================== */    CPLXMLNode *psThis;    for( psThis = psSchemaNode->psChild;          psThis != NULL; psThis = psThis->psNext )    {/* -------------------------------------------------------------------- *//*      Check for <xs:element> node.                                    *//* -------------------------------------------------------------------- */        if( psThis->eType != CXT_Element             || !EQUAL(psThis->pszValue,"element") )            continue;/* -------------------------------------------------------------------- *//*      Check the substitution group.                                   *//* -------------------------------------------------------------------- */        const char *pszSubGroup =             StripNS(CPLGetXMLValue(psThis,"substitutionGroup",""));        // Old OGR produced elements for the feature collection.        if( EQUAL(pszSubGroup, "_FeatureCollection") )            continue;        if( !EQUAL(pszSubGroup, "_Feature") &&            !EQUAL(pszSubGroup, "AbstractFeature") /* AbstractFeature used by GML 3.2 */ )        {            continue;        }        /* -------------------------------------------------------------------- *//*      Get name                                                        *//* -------------------------------------------------------------------- */        const char *pszName;        pszName = CPLGetXMLValue( psThis, "name", NULL );        if( pszName == NULL )        {            continue;        }/* -------------------------------------------------------------------- *//*      Get type and verify relationship with name.                     *//* -------------------------------------------------------------------- */        const char *pszType;        pszType = CPLGetXMLValue( psThis, "type", NULL );        if (pszType == NULL)        {            CPLXMLNode *psComplexType = CPLGetXMLNode( psThis, "complexType" );            if (psComplexType)            {                GMLFeatureClass* poClass =                        GMLParseFeatureType(psSchemaNode, pszName, psComplexType);                if (poClass)                    aosClasses.push_back(poClass);            }            continue;        }        if( strstr( pszType, ":" ) != NULL )            pszType = strstr( pszType, ":" ) + 1;        if( EQUAL(pszType, pszName) )        {            /* A few WFS servers return a type name which is the element name */            /* without any _Type or Type suffix */            /* e.g. : http://apollo.erdas.com/erdas-apollo/vector/Cherokee?SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&TYPENAME=iwfs:Air */        }        else if( !EQUALN(pszType,pszName,strlen(pszName))            || !(EQUAL(pszType+strlen(pszName),"_Type") ||//.........这里部分代码省略.........

CPLErr VRTDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath ){    if( pszVRTPath != NULL )        this->pszVRTPath = CPLStrdup(pszVRTPath);/* -------------------------------------------------------------------- *//*      Check for an SRS node.                                          *//* -------------------------------------------------------------------- */    if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 )    {        OGRSpatialReference oSRS;        CPLFree( pszProjection );        pszProjection = NULL;        if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") )            == OGRERR_NONE )            oSRS.exportToWkt( &pszProjection );    }/* -------------------------------------------------------------------- *//*      Check for a GeoTransform node.                                  *//* -------------------------------------------------------------------- */    if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 )    {        const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", "");        char	**papszTokens;        papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE );        if( CSLCount(papszTokens) != 6 )        {            CPLError( CE_Warning, CPLE_AppDefined,                      "GeoTransform node does not have expected six values.");        }        else        {            for( int iTA = 0; iTA < 6; iTA++ )                adfGeoTransform[iTA] = atof(papszTokens[iTA]);            bGeoTransformSet = TRUE;        }        CSLDestroy( papszTokens );    }/* -------------------------------------------------------------------- *//*      Check for GCPs.                                                 *//* -------------------------------------------------------------------- */    CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );    if( psGCPList != NULL )    {        CPLXMLNode *psXMLGCP;        OGRSpatialReference oSRS;        const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", "");        CPLFree( pszGCPProjection );        if( strlen(pszRawProj) > 0             && oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE )            oSRS.exportToWkt( &pszGCPProjection );        else            pszGCPProjection = CPLStrdup("");        // Count GCPs.        int  nGCPMax = 0;                 for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;              psXMLGCP = psXMLGCP->psNext )            nGCPMax++;                 pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);                 for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;              psXMLGCP = psXMLGCP->psNext )        {            GDAL_GCP *psGCP = pasGCPList + nGCPCount;            if( !EQUAL(psXMLGCP->pszValue,"GCP") ||                 psXMLGCP->eType != CXT_Element )                continue;                         GDALInitGCPs( 1, psGCP );                         CPLFree( psGCP->pszId );            psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));                         CPLFree( psGCP->pszInfo );            psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));                         psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));            psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));                         psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));            psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));            psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));            nGCPCount++;        }    }//.........这里部分代码省略.........

OGRLayer*  OGRVRTDataSource::InstanciateWarpedLayer(                                        CPLXMLNode *psLTree,                                        const char *pszVRTDirectory,                                        int bUpdate,                                        int nRecLevel){    if( !EQUAL(psLTree->pszValue,"OGRVRTWarpedLayer") )        return NULL;    CPLXMLNode *psSubNode;    OGRLayer* poSrcLayer = NULL;    for( psSubNode=psLTree->psChild;         psSubNode != NULL;         psSubNode=psSubNode->psNext )    {        if( psSubNode->eType != CXT_Element )            continue;        poSrcLayer = InstanciateLayer(psSubNode, pszVRTDirectory,                                 bUpdate, nRecLevel + 1);        if( poSrcLayer != NULL )            break;    }    if( poSrcLayer == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "Cannot instanciate source layer" );        return NULL;    }    const char* pszTargetSRS = CPLGetXMLValue(psLTree, "TargetSRS", NULL);    if( pszTargetSRS == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "Missing TargetSRS element within OGRVRTWarpedLayer" );        delete poSrcLayer;        return NULL;    }    const char* pszGeomFieldName = CPLGetXMLValue(psLTree, "WarpedGeomFieldName", NULL);    int iGeomField = 0;    if( pszGeomFieldName != NULL )    {        iGeomField = poSrcLayer->GetLayerDefn()->GetGeomFieldIndex(pszGeomFieldName);        if( iGeomField < 0 )        {            CPLError( CE_Failure, CPLE_AppDefined,                  "Cannot find source geometry field '%s'", pszGeomFieldName );            delete poSrcLayer;            return NULL;        }    }    OGRSpatialReference* poSrcSRS;    OGRSpatialReference* poTargetSRS;    const char* pszSourceSRS = CPLGetXMLValue(psLTree, "SrcSRS", NULL);    if( pszSourceSRS == NULL )    {        poSrcSRS = poSrcLayer->GetLayerDefn()->GetGeomFieldDefn(iGeomField)->GetSpatialRef();        if( poSrcSRS != NULL)            poSrcSRS = poSrcSRS->Clone();    }    else    {        poSrcSRS = new OGRSpatialReference();        if( poSrcSRS->SetFromUserInput(pszSourceSRS) != OGRERR_NONE )        {            delete poSrcSRS;            poSrcSRS = NULL;        }    }    if( poSrcSRS == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "Failed to import source SRS" );        delete poSrcLayer;        return NULL;    }    poTargetSRS = new OGRSpatialReference();    if( poTargetSRS->SetFromUserInput(pszTargetSRS) != OGRERR_NONE )    {        delete poTargetSRS;        poTargetSRS = NULL;    }    if( poTargetSRS == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "Failed to import target SRS" );        delete poSrcSRS;        delete poSrcLayer;        return NULL;    }    if( pszSourceSRS == NULL && poSrcSRS->IsSame(poTargetSRS) )//.........这里部分代码省略.........