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

GMLFeature::~GMLFeature(){    CPLFree( m_pszFID );    int i;    for( i = 0; i < m_nPropertyCount; i++ )    {        int nSubProperties = m_pasProperties[i].nSubProperties;        if (nSubProperties == 1)            CPLFree( m_pasProperties[i].aszSubProperties[0] );        else if (nSubProperties > 1)        {            for( int j = 0; j < nSubProperties; j++)                CPLFree( m_pasProperties[i].papszSubProperties[j] );            CPLFree( m_pasProperties[i].papszSubProperties );        }    }    if (m_nGeometryCount == 1)    {        CPLDestroyXMLNode(m_apsGeometry[0]);    }    else if (m_nGeometryCount > 1)    {        for(i=0;i<m_nGeometryCount;i++)            CPLDestroyXMLNode(m_papsGeometry[i]);        CPLFree(m_papsGeometry);    }    CPLFree( m_pasProperties );    CSLDestroy( m_papszOBProperties );}

DIMAPDataset::~DIMAPDataset(){    FlushCache();    CPLDestroyXMLNode( psProduct );    CPLFree( pszGCPProjection );    if( nGCPCount > 0 )    {        GDALDeinitGCPs( nGCPCount, pasGCPList );        CPLFree( pasGCPList );    }    if( poImageDS != NULL )        delete poImageDS;    CSLDestroy(papszXMLDimapMetadata);/* -------------------------------------------------------------------- *//*      Disconnect the bands so our destructor doesn't try and          *//*      delete them since they really belonged to poImageDS.            *//* -------------------------------------------------------------------- */    int iBand;    for( iBand = 0; iBand < GetRasterCount(); iBand++ )        papoBands[iBand] = NULL;}

/** * LoadMetadata() */void GDALMDReaderResursDK1::LoadMetadata(){    if(m_bIsMetadataLoad)        return;    if (!m_osXMLSourceFilename.empty())    {        CPLXMLNode* psNode = CPLParseXMLFile(m_osXMLSourceFilename);        if(psNode != NULL)        {            CPLXMLNode* pMSPRootNode = CPLSearchXMLNode(psNode, "=MSP_ROOT");            if(pMSPRootNode != NULL)            {                m_papszIMDMD = ReadXMLToList(pMSPRootNode, m_papszIMDMD, "MSP_ROOT");            }            CPLDestroyXMLNode(psNode);        }    }    m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "MSP");    m_bIsMetadataLoad = true;    if(NULL == m_papszIMDMD)    {        return;    }    //extract imagery metadata    const char* pszSatId = CSLFetchNameValue(m_papszIMDMD, "MSP_ROOT.cCodeKA");    if(NULL != pszSatId)    {        m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_SATELLITE,                                           CPLStripQuotes(pszSatId));    }    const char* pszDate = CSLFetchNameValue(m_papszIMDMD,                                            "MSP_ROOT.Normal.dSceneDate");    if(NULL != pszDate)    {        const char* pszTime = CSLFetchNameValue(m_papszIMDMD,                                         "MSP_ROOT.Normal.tSceneTime");        if(NULL == pszTime)            pszTime = "00:00:00.000000";        char buffer[80];        time_t timeMid = GetAcquisitionTimeFromString(CPLSPrintf( "%s %s",                                                     pszDate, pszTime));        strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid));        m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,                                           MD_NAME_ACQDATETIME, buffer);    }    m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER,                                       MD_CLOUDCOVER_NA);}

OGRGeometryH OGR_G_CreateFromGML( const char *pszGML ){    if( pszGML == NULL || strlen(pszGML) == 0 )    {        CPLError( CE_Failure, CPLE_AppDefined,                   "GML Geometry is empty in GML2OGRGeometry()." );        return NULL;    }/* -------------------------------------------------------------------- *//*      Try to parse the XML snippet using the MiniXML API.  If this    *//*      fails, we assume the minixml api has already posted a CPL       *//*      error, and just return NULL.                                    *//* -------------------------------------------------------------------- */    CPLXMLNode *psGML = CPLParseXMLString( pszGML );    if( psGML == NULL )        return NULL;/* -------------------------------------------------------------------- *//*      Convert geometry recursively.                                   *//* -------------------------------------------------------------------- */    OGRGeometry *poGeometry;    poGeometry = GML2OGRGeometry_XMLNode( psGML );    CPLDestroyXMLNode( psGML );        return (OGRGeometryH) poGeometry;}

void GMLFeature::SetGeometryDirectly( int nIdx, CPLXMLNode* psGeom ){    if( nIdx == 0 && m_nGeometryCount <= 1 )    {        SetGeometryDirectly( psGeom );        return;    }    else if( nIdx > 0 && m_nGeometryCount <= 1 )    {        m_papsGeometry = (CPLXMLNode **) CPLMalloc(2 * sizeof(CPLXMLNode *));        m_papsGeometry[0] = m_apsGeometry[0];        m_papsGeometry[1] = NULL;        m_apsGeometry[0] = NULL;    }    if( nIdx >= m_nGeometryCount )    {        m_papsGeometry = (CPLXMLNode **) CPLRealloc(m_papsGeometry,            (nIdx + 2) * sizeof(CPLXMLNode *));        for( int i = m_nGeometryCount; i <= nIdx + 1; i++ )            m_papsGeometry[i] = NULL;        m_nGeometryCount = nIdx + 1;    }    if (m_papsGeometry[nIdx] != NULL)        CPLDestroyXMLNode(m_papsGeometry[nIdx]);    m_papsGeometry[nIdx] = psGeom;}

int gv_symbol_manager_save_vector_symbol( GvSymbolManager *manager,                                           const char *symbol_name,                                           const char *new_name ){    GvSymbolObj *symbol;    /* allocate a new symbol object */    symbol = g_hash_table_lookup( manager->symbol_cache, symbol_name );    CPLDebug("OpenEV", "save_vector_symbol(%s->%s)", symbol_name, new_name );    if ( symbol && symbol->type == GV_SYMBOL_VECTOR )    {        GvShape     *shape;        CPLXMLNode  *xml_shape;        shape = (GvShape *)symbol->buffer;        xml_shape = gv_shape_to_xml_tree( shape );        if ( CPLSerializeXMLTreeToFile( xml_shape, new_name ) )        {            CPLDestroyXMLNode( xml_shape );            return TRUE;        }    }    return FALSE;}

static OGRGeometry* ParseKMLGeometry(const char* pszKML){    CPLXMLNode* psXML = CPLParseXMLString(pszKML);    if (psXML == nullptr)        return nullptr;    if (psXML->eType != CXT_Element)    {        CPLDestroyXMLNode(psXML);        return nullptr;    }    OGRGeometry* poGeom = ParseKMLGeometry(psXML);    CPLDestroyXMLNode(psXML);    return poGeom;}

void GMLFeature::SetGeometryDirectly( CPLXMLNode* psGeom ){    if (m_apsGeometry[0] != NULL)        CPLDestroyXMLNode(m_apsGeometry[0]);    m_nGeometryCount = 1;    m_apsGeometry[0] = psGeom;}

int OGRFMECacheIndex::Load(){/* -------------------------------------------------------------------- *//*      Lock the cache index file if not already locked.                *//* -------------------------------------------------------------------- */    if( hLock == NULL && !Lock() )        return FALSE;    if( psTree != NULL )    {        CPLDestroyXMLNode( psTree );        psTree = NULL;    }/* -------------------------------------------------------------------- *//*      Open the index file.  If we don't get it, we assume it is       *//*      because it doesn't exist, and we create a "stub" tree in        *//*      memory.                                                         *//* -------------------------------------------------------------------- */    FILE *fpIndex;    int  nLength;    char *pszIndexBuffer;    fpIndex = VSIFOpen( GetPath(), "rb" );    if( fpIndex == NULL )    {        psTree = CPLCreateXMLNode( NULL, CXT_Element, "OGRFMECacheIndex" );        return TRUE;    }    /* -------------------------------------------------------------------- *//*      Load the data from the file.                                    *//* -------------------------------------------------------------------- */    VSIFSeek( fpIndex, 0, SEEK_END );    nLength = VSIFTell( fpIndex );    VSIFSeek( fpIndex, 0, SEEK_SET );    pszIndexBuffer = (char *) CPLMalloc(nLength+1);    if( (int) VSIFRead( pszIndexBuffer, 1, nLength, fpIndex ) != nLength )    {        CPLError( CE_Failure, CPLE_FileIO,                   "Read of %d byte index file failed.", nLength );        return FALSE;    }    VSIFClose( fpIndex );/* -------------------------------------------------------------------- *//*      Parse the result into an inmemory XML tree.                     *//* -------------------------------------------------------------------- */    pszIndexBuffer[nLength] = '/0';    psTree = CPLParseXMLString( pszIndexBuffer );    CPLFree( pszIndexBuffer );        return psTree != NULL;}

/** * LoadMetadata() */void GDALMDReaderRapidEye::LoadMetadata(){    if(m_bIsMetadataLoad)        return;    CPLXMLNode* psNode = CPLParseXMLFile(m_osXMLSourceFilename);    if(psNode != NULL)    {        CPLXMLNode* pRootNode = CPLSearchXMLNode(psNode, "=re:EarthObservation");        if(pRootNode != NULL)        {            m_papszIMDMD = ReadXMLToList(pRootNode->psChild, m_papszIMDMD);        }        CPLDestroyXMLNode(psNode);    }    m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "RE");    m_bIsMetadataLoad = true;    if(NULL == m_papszIMDMD)    {        return;    }    //extract imagery metadata    const char* pszSatId = CSLFetchNameValue(m_papszIMDMD,    "gml:using.eop:EarthObservationEquipment.eop:platform.eop:Platform.eop:serialIdentifier");    if(NULL != pszSatId)    {        m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,                                MD_NAME_SATELLITE, CPLStripQuotes(pszSatId));    }    const char* pszDateTime = CSLFetchNameValue(m_papszIMDMD,    "gml:using.eop:EarthObservationEquipment.eop:acquisitionParameters.re:Acquisition.re:acquisitionDateTime");    if(NULL != pszDateTime)    {        char buffer[80];        time_t timeMid = GetAcquisitionTimeFromString(pszDateTime);        strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid));        m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,                                           MD_NAME_ACQDATETIME, buffer);    }    const char* pszCC = CSLFetchNameValue(m_papszIMDMD,    "gml:resultOf.re:EarthObservationResult.opt:cloudCoverPercentage");    if(NULL != pszSatId)    {        m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,                                MD_NAME_CLOUDCOVER, pszCC);    }}

OGRFMECacheIndex::~OGRFMECacheIndex(){    if( psTree != NULL )    {        Unlock();        CPLDestroyXMLNode( psTree );        psTree = NULL;    }           CPLFree( pszPath );}

GDALDataset *ECRGTOCDataset::Open( GDALOpenInfo * poOpenInfo ){    const char *pszFilename = poOpenInfo->pszFilename;    CPLString osProduct, osDiscId;    if( !Identify( poOpenInfo ) )        return NULL;    if( EQUALN(pszFilename, "ECRG_TOC_ENTRY:",strlen("ECRG_TOC_ENTRY:")))    {        pszFilename += strlen("ECRG_TOC_ENTRY:");        osProduct = pszFilename;        size_t iPos = osProduct.find(":");        if (iPos == std::string::npos)            return NULL;        osProduct.resize(iPos);        pszFilename += iPos + 1;        osDiscId = pszFilename;        iPos = osDiscId.find(":");        if (iPos == std::string::npos)            return NULL;        osDiscId.resize(iPos);        pszFilename += iPos + 1;    }/* -------------------------------------------------------------------- *//*      Parse the XML file                                              *//* -------------------------------------------------------------------- */    CPLXMLNode* psXML = CPLParseXMLFile(pszFilename);    if (psXML == NULL)    {        return NULL;    }    GDALDataset* poDS = Build( pszFilename, psXML, osProduct, osDiscId,                               poOpenInfo->pszFilename);    CPLDestroyXMLNode(psXML);    if (poDS && poOpenInfo->eAccess == GA_Update)    {        CPLError(CE_Failure, CPLE_NotSupported,                 "ECRGTOC driver does not support update mode");        delete poDS;        return NULL;    }    return poDS;}

OGRVRTDataSource::~OGRVRTDataSource(){    CPLFree(pszName);    OGRVRTDataSource::CloseDependentDatasets();    CPLFree(paeLayerType);    if( psTree != nullptr)        CPLDestroyXMLNode(psTree);    delete poLayerPool;}

CPLErr GDALPamRasterBand::SetDefaultHistogram( double dfMin, double dfMax,                                                int nBuckets, int *panHistogram){    CPLXMLNode *psNode;    PamInitialize();    if( psPam == NULL )        return GDALRasterBand::SetDefaultHistogram( dfMin, dfMax,                                                     nBuckets, panHistogram );/* -------------------------------------------------------------------- *//*      Do we have a matching histogram we should replace?              *//* -------------------------------------------------------------------- */    psNode = PamFindMatchingHistogram( psPam->psSavedHistograms,                                        dfMin, dfMax, nBuckets,                                       TRUE, TRUE );    if( psNode != NULL )    {        /* blow this one away */        CPLRemoveXMLChild( psPam->psSavedHistograms, psNode );        CPLDestroyXMLNode( psNode );    }/* -------------------------------------------------------------------- *//*      Translate into a histogram XML tree.                            *//* -------------------------------------------------------------------- */    CPLXMLNode *psHistItem;    psHistItem = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,                                         panHistogram, TRUE, FALSE );    if( psHistItem == NULL )        return CE_Failure;/* -------------------------------------------------------------------- *//*      Insert our new default histogram at the front of the            *//*      histogram list so that it will be the default histogram.        *//* -------------------------------------------------------------------- */    psPam->poParentDS->MarkPamDirty();    if( psPam->psSavedHistograms == NULL )        psPam->psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,                                                     "Histograms" );                psHistItem->psNext = psPam->psSavedHistograms->psChild;    psPam->psSavedHistograms->psChild = psHistItem;        return CE_None;}

VRTRasterBand::~VRTRasterBand(){    CPLFree( pszUnitType );    if( poColorTable != NULL )        delete poColorTable;    CSLDestroy( papszCategoryNames );    if( psSavedHistograms != NULL )        CPLDestroyXMLNode( psSavedHistograms );    delete poMaskBand;}

void VRTDataset::FlushCache(){    GDALDataset::FlushCache();    if( !bNeedsFlush || bWritable == FALSE)        return;    bNeedsFlush = FALSE;    // We don't write to disk if there is no filename.  This is a     // memory only dataset.    if( strlen(GetDescription()) == 0         || EQUALN(GetDescription(),"<VRTDataset",11) )        return;    /* -------------------------------------------------------------------- */    /*      Create the output file.                                         */    /* -------------------------------------------------------------------- */    VSILFILE *fpVRT;    fpVRT = VSIFOpenL( GetDescription(), "w" );    if( fpVRT == NULL )    {        CPLError( CE_Failure, CPLE_AppDefined,                   "Failed to write .vrt file in FlushCache()." );        return;    }    /* -------------------------------------------------------------------- */    /*      Convert tree to a single block of XML text.                     */    /* -------------------------------------------------------------------- */    char *pszVRTPath = CPLStrdup(CPLGetPath(GetDescription()));    CPLXMLNode *psDSTree = SerializeToXML( pszVRTPath );    char *pszXML;    pszXML = CPLSerializeXMLTree( psDSTree );    CPLDestroyXMLNode( psDSTree );    CPLFree( pszVRTPath );    /* -------------------------------------------------------------------- */    /*      Write to disk.                                                  */    /* -------------------------------------------------------------------- */    VSIFWriteL( pszXML, 1, strlen(pszXML), fpVRT );    VSIFCloseL( fpVRT );    CPLFree( pszXML );}

GMLHandler::~GMLHandler(){    if (apsXMLNode.size() >= 2 && apsXMLNode[1].psNode != NULL)        CPLDestroyXMLNode(apsXMLNode[1].psNode);    CPLFree( m_pszCurField );    CPLFree( m_pszGeometry );    CPLFree( m_pszCityGMLGenericAttrName );    CPLFree( m_pszHref );    CPLFree( m_pszUom );    CPLFree( m_pszValue );    CPLFree( pasGeometryNames );}

bool GMLRegistry::Parse(){    if( osRegistryPath.empty() )    {        const char *pszFilename = CPLFindFile("gdal", "gml_registry.xml");        if( pszFilename )            osRegistryPath = pszFilename;    }    if( osRegistryPath.empty() )        return false;    CPLXMLNode *psRootNode = CPLParseXMLFile(osRegistryPath);    if( psRootNode == NULL )        return false;    CPLXMLNode *psRegistryNode = CPLGetXMLNode(psRootNode, "=gml_registry");    if( psRegistryNode == NULL )    {        CPLDestroyXMLNode(psRootNode);        return false;    }    CPLXMLNode *psIter = psRegistryNode->psChild;    while( psIter != NULL )    {        if( psIter->eType == CXT_Element &&            strcmp(psIter->pszValue, "namespace") == 0 )        {            GMLRegistryNamespace oNameSpace;            if( oNameSpace.Parse(osRegistryPath, psIter) )            {                aoNamespaces.push_back(oNameSpace);            }        }        psIter = psIter->psNext;    }    CPLDestroyXMLNode(psRootNode);    return true;}

OGRVRTDataSource::~OGRVRTDataSource(){    int         i;    CPLFree( pszName );    for( i = 0; i < nLayers; i++ )        delete papoLayers[i];        CPLFree( papoLayers );    if( psTree != NULL)        CPLDestroyXMLNode( psTree );}

CPLErr VRTSourcedRasterBand::SetMetadata( char **papszNewMD, const char *pszDomain ){    if( pszDomain != NULL        && (EQUAL(pszDomain,"new_vrt_sources")             || EQUAL(pszDomain,"vrt_sources")) )    {        VRTDriver *poDriver = (VRTDriver *) GDALGetDriverByName( "VRT" );        CPLErr eErr;        int    i;        if( EQUAL(pszDomain,"vrt_sources") )        {            for( int i = 0; i < nSources; i++ )                delete papoSources[i];            CPLFree( papoSources );            papoSources = NULL;            nSources = 0;        }        for( i = 0; i < CSLCount(papszNewMD); i++ )        {            const char *pszXML = CPLParseNameValue( papszNewMD[i], NULL );            CPLXMLNode *psTree = CPLParseXMLString( pszXML );            VRTSource *poSource;                        if( psTree == NULL )                return CE_Failure;            poSource = poDriver->ParseSource( psTree, NULL );            CPLDestroyXMLNode( psTree );            if( poSource != NULL )            {                eErr = AddSource( poSource );                if( eErr != CE_None )                    return eErr;            }            else                return CE_Failure;        }        return CE_None;    }    else        return VRTRasterBand::SetMetadata( papszNewMD, pszDomain );}

int main( int argc, char **argv ){    static char  szXML[20000000];    FILE       *fp;    if( argc == 1 )        fp = stdin;    else if( argv[1][0] == '-' )    {        printf( "Usage: xmlreformat [filename]/n" );        exit( 0 );    }    else    {        fp = fopen( argv[1], "rt" );        if( fp == NULL )        {            printf( "Failed to open file %s./n", argv[1] );            exit( 1 );        }    }    int nLen = fread( szXML, 1, sizeof(szXML), fp );    if( nLen >= (int) sizeof(szXML)-2 ) {        fprintf( stderr,                 "xmlreformat fixed sized buffer (%d bytes) exceeded./n",                 (int) sizeof(szXML) );        exit(1);    }    if( fp != stdin )        fclose( fp );    szXML[nLen] = '/0';    CPLXMLNode *poTree = CPLParseXMLString( szXML );    if( poTree != NULL )    {        char *pszRawXML = CPLSerializeXMLTree( poTree );        printf( "%s", pszRawXML );        CPLFree( pszRawXML );        CPLDestroyXMLNode( poTree );    }    return 0;}

// ************************************************************//		ParseServerException()// ************************************************************void BaseProvider::ParseServerException(CString s){	CPLXMLNode* node = CPLParseXMLString(s);	if (node)	{		while (node) {			CPLXMLNode* nodeException = CPLGetXMLNode(node, "ServiceException");			if (nodeException) {				CString msg = CPLGetXMLValue(nodeException, "", "");				CallbackHelper::ErrorMsg(Debug::Format("WMS Server exception (%s): %s", Name, msg));			}			node = node->psNext;		}		CPLDestroyXMLNode(node);	}}

MEMRasterBand::~MEMRasterBand(){    if( bOwnData )    {        VSIFree( pabyData );    }    if( poColorTable != NULL )        delete poColorTable;    CPLFree( pszUnitType );    CSLDestroy( papszCategoryNames );    if (psSavedHistograms != NULL)        CPLDestroyXMLNode(psSavedHistograms);}

CPLErr GDALWMSRasterBand::ReportWMSException(const char *file_name) {    CPLErr ret = CE_None;    int reported_errors_count = 0;    CPLXMLNode *orig_root = CPLParseXMLFile(file_name);    CPLXMLNode *root = orig_root;    if (root != NULL) {        root = CPLGetXMLNode(root, "=ServiceExceptionReport");    }    if (root != NULL) {        CPLXMLNode *n = CPLGetXMLNode(root, "ServiceException");        while (n != NULL) {            const char *exception = CPLGetXMLValue(n, "=ServiceException", "");            const char *exception_code = CPLGetXMLValue(n, "=ServiceException.code", "");            if (exception[0] != '/0') {                if (exception_code[0] != '/0') {                    CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: The server returned exception code '%s': %s", exception_code, exception);                    ++reported_errors_count;                } else {                    CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: The server returned exception: %s", exception);                    ++reported_errors_count;                }            } else if (exception_code[0] != '/0') {                CPLError(CE_Failure, CPLE_AppDefined, "GDALWMS: The server returned exception code '%s'.", exception_code);                ++reported_errors_count;            }            n = n->psNext;            if (n != NULL) {                n = CPLGetXMLNode(n, "=ServiceException");            }        }    } else {        ret = CE_Failure;    }    if (orig_root != NULL) {        CPLDestroyXMLNode(orig_root);    }    if (reported_errors_count == 0) {        ret = CE_Failure;    }    return ret;}

DIMAPDataset::~DIMAPDataset(){    FlushCache();    CPLDestroyXMLNode( psProduct );    CPLFree( pszGCPProjection );    if( nGCPCount > 0 )    {        GDALDeinitGCPs( nGCPCount, pasGCPList );        CPLFree( pasGCPList );    }    CSLDestroy(papszXMLDimapMetadata);    CloseDependentDatasets();}

/** * /brief Import coordinate system from XML format (GML only currently). * * This method is the same as the C function OSRImportFromXML() * @param pszXML XML string to import * @return OGRERR_NONE on success or OGRERR_CORRUPT_DATA on failure. */OGRErr OGRSpatialReference::importFromXML(const char *pszXML){    CPLXMLNode *psTree;    OGRErr     eErr = OGRERR_UNSUPPORTED_SRS;    this->Clear();/* -------------------------------------------------------------------- *//*      Parse the XML.                                                  *//* -------------------------------------------------------------------- */    psTree = CPLParseXMLString(pszXML);    if (psTree == NULL)        return OGRERR_CORRUPT_DATA;    CPLStripXMLNamespace(psTree, "gml", TRUE);/* -------------------------------------------------------------------- *//*      Import according to the root node type.  We walk through        *//*      root elements as there is sometimes prefix stuff like           *//*      <?xml>.                                                         *//* -------------------------------------------------------------------- */    CPLXMLNode *psNode = psTree;    for (psNode = psTree; psNode != NULL; psNode = psNode->psNext)    {        if (EQUAL(psNode->pszValue, "GeographicCRS"))        {            eErr = importGeogCSFromXML(this, psNode);            break;        }        else if (EQUAL(psNode->pszValue, "ProjectedCRS"))        {            eErr = importProjCSFromXML(this, psNode);            break;        }    }    CPLDestroyXMLNode(psTree);    return eErr;}