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

CPLXMLNode* GMLXercesHandler::AddAttributes(CPLXMLNode* psNode, void* attr){    const Attributes* attrs = (const Attributes*) attr;    CPLXMLNode* psLastChild = NULL;    for(unsigned int i=0; i < attrs->getLength(); i++)    {        char* pszName = tr_strdup(attrs->getQName(i));        char* pszValue = tr_strdup(attrs->getValue(i));        CPLXMLNode* psChild = CPLCreateXMLNode(NULL, CXT_Attribute, pszName);        CPLCreateXMLNode(psChild, CXT_Text, pszValue);        CPLFree(pszName);        CPLFree(pszValue);        if (psLastChild == NULL)            psNode->psChild = psChild;        else            psLastChild->psNext = psChild;        psLastChild = psChild;    }    return psLastChild;}

CPLXMLNode *GDALSerializeTPSTransformer( void *pTransformArg ){    VALIDATE_POINTER1( pTransformArg, "GDALSerializeTPSTransformer", NULL );    CPLXMLNode *psTree;    TPSTransformInfo *psInfo = static_cast<TPSTransformInfo *>(pTransformArg);    psTree = CPLCreateXMLNode( NULL, CXT_Element, "TPSTransformer" );/* -------------------------------------------------------------------- *//*      Serialize bReversed.                                            *//* -------------------------------------------------------------------- */    CPLCreateXMLElementAndValue(         psTree, "Reversed",         CPLString().Printf( "%d", psInfo->bReversed ) );                                 /* -------------------------------------------------------------------- *//*	Attach GCP List. 						*//* -------------------------------------------------------------------- */    if( psInfo->nGCPCount > 0 )    {        int iGCP;        CPLXMLNode *psGCPList = CPLCreateXMLNode( psTree, CXT_Element,                                                   "GCPList" );        for( iGCP = 0; iGCP < psInfo->nGCPCount; iGCP++ )        {            CPLXMLNode *psXMLGCP;            GDAL_GCP *psGCP = psInfo->pasGCPList + iGCP;            psXMLGCP = CPLCreateXMLNode( psGCPList, CXT_Element, "GCP" );            CPLSetXMLValue( psXMLGCP, "#Id", psGCP->pszId );            if( psGCP->pszInfo != NULL && strlen(psGCP->pszInfo) > 0 )                CPLSetXMLValue( psXMLGCP, "Info", psGCP->pszInfo );            CPLSetXMLValue( psXMLGCP, "#Pixel",                             CPLString().Printf( "%.4f", psGCP->dfGCPPixel ) );            CPLSetXMLValue( psXMLGCP, "#Line",                             CPLString().Printf( "%.4f", psGCP->dfGCPLine ) );            CPLSetXMLValue( psXMLGCP, "#X",                             CPLString().Printf( "%.12E", psGCP->dfGCPX ) );            CPLSetXMLValue( psXMLGCP, "#Y",                             CPLString().Printf( "%.12E", psGCP->dfGCPY ) );            if( psGCP->dfGCPZ != 0.0 )                CPLSetXMLValue( psXMLGCP, "#GCPZ",                                 CPLString().Printf( "%.12E", psGCP->dfGCPZ ) );        }    }    return psTree;}

CPLXMLNode* OGR_G_ExportEnvelopeToKMLTree( OGRGeometryH hGeometry ){    VALIDATE_POINTER1( hGeometry, "OGR_G_ExportEnvelopeToKMLTree", NULL );    CPLXMLNode* psBox = NULL;    CPLXMLNode* psCoord = NULL;    OGREnvelope sEnvelope;    char szCoordinate[256] = { 0 };    char* pszY = NULL;    memset( &sEnvelope, 0, sizeof(sEnvelope) );    ((OGRGeometry*)(hGeometry))->getEnvelope( &sEnvelope );    if( sEnvelope.MinX == 0 && sEnvelope.MaxX == 0            && sEnvelope.MaxX == 0 && sEnvelope.MaxY == 0 )    {        /* there is apparently a special way of representing a null box           geometry ... we should use it here eventually. */        return NULL;    }    psBox = CPLCreateXMLNode( NULL, CXT_Element, "Box" );    /* -------------------------------------------------------------------- */    /*      Add minxy coordinate.                                           */    /* -------------------------------------------------------------------- */    psCoord = CPLCreateXMLNode( psBox, CXT_Element, "coord" );    MakeKMLCoordinate( szCoordinate, sEnvelope.MinX, sEnvelope.MinY, 0.0,                       FALSE );    pszY = strstr(szCoordinate,",") + 1;    pszY[-1] = '/0';    CPLCreateXMLElementAndValue( psCoord, "X", szCoordinate );    CPLCreateXMLElementAndValue( psCoord, "Y", pszY );    /* -------------------------------------------------------------------- */    /*      Add maxxy coordinate.                                           */    /* -------------------------------------------------------------------- */    psCoord = CPLCreateXMLNode( psBox, CXT_Element, "coord" );    MakeKMLCoordinate( szCoordinate, sEnvelope.MaxX, sEnvelope.MaxY, 0.0,                       FALSE );    pszY = strstr(szCoordinate,",") + 1;    pszY[-1] = '/0';    CPLCreateXMLElementAndValue( psCoord, "X", szCoordinate );    CPLCreateXMLElementAndValue( psCoord, "Y", pszY );    return psBox;}

static CPLXMLNode* addAuthorityIDBlock(CPLXMLNode *psTarget,                                       const char *pszElement,                                       const char *pszAuthority,                                       const char *pszObjectType,                                       int nCode,                                       const char *pszVersion = ""){    char szURN[200];/* -------------------------------------------------------------------- *//*      Prepare partial URN without the actual code.                    *//* -------------------------------------------------------------------- */    if (pszVersion == NULL)        pszVersion = "";    CPLAssert(strlen(pszAuthority) + strlen(pszObjectType) < sizeof(szURN) - 30);    sprintf(szURN, "urn:ogc:def:%s:%s:%s:",            pszObjectType, pszAuthority, pszVersion);/* -------------------------------------------------------------------- *//*      Prepare the base name, eg. <srsID>.                             *//* -------------------------------------------------------------------- */    CPLXMLNode *psElement =        CPLCreateXMLNode(psTarget, CXT_Element, pszElement);/* -------------------------------------------------------------------- *//*      Prepare the name element.                                       *//* -------------------------------------------------------------------- */    CPLXMLNode *psName =        CPLCreateXMLNode(psElement, CXT_Element, "gml:name");/* -------------------------------------------------------------------- *//*      Prepare the codespace attribute.                                *//* -------------------------------------------------------------------- */    CPLCreateXMLNode(        CPLCreateXMLNode(psName, CXT_Attribute, "gml:codeSpace"),        CXT_Text, szURN);/* -------------------------------------------------------------------- *//*      Attach code value to name node.                                 *//* -------------------------------------------------------------------- */    char szCode[32];    sprintf(szCode, "%d", nCode);    CPLCreateXMLNode(psName, CXT_Text, szCode);    return psElement;}

CPLXMLNode *VRTWarpedRasterBand::SerializeToXML( const char *pszVRTPath ){    CPLXMLNode *psTree = VRTRasterBand::SerializeToXML( pszVRTPath );/* -------------------------------------------------------------------- *//*      Set subclass.                                                   *//* -------------------------------------------------------------------- */    CPLCreateXMLNode(         CPLCreateXMLNode( psTree, CXT_Attribute, "subClass" ),         CXT_Text, "VRTWarpedRasterBand" );    return psTree;}

CPLXMLNode *WCTSAuthId2crsId( char **papszParms, const char *pszName ){    const char *pszAuthId = CSLFetchNameValue( papszParms, pszName );    CPLXMLNode *psCRSId;    char **papszTokens;    if( pszAuthId == NULL )        WCTSEmitServiceException(             CPLSPrintf( "%s keyword missing", pszName ) );        papszTokens = CSLTokenizeString2( pszAuthId, ":", 0 );    if( CSLCount(papszTokens) != 2 )        WCTSEmitServiceException(             CPLSPrintf( "%.500s value corrupt, use 'authority:code'.",                        pszName ));        psCRSId = CPLCreateXMLNode( NULL, CXT_Element, "crsID" );        CPLCreateXMLElementAndValue( psCRSId, "gml:codeSpace", papszTokens[0]);    CPLCreateXMLElementAndValue( psCRSId, "gml:code", papszTokens[1] );        CSLDestroy( papszTokens );    return psCRSId;}

CPLXMLNode *GDALSerializeTPSTransformer( void *pTransformArg ){    VALIDATE_POINTER1( pTransformArg, "GDALSerializeTPSTransformer", NULL );    CPLXMLNode *psTree;    TPSTransformInfo *psInfo = static_cast<TPSTransformInfo *>(pTransformArg);    psTree = CPLCreateXMLNode( NULL, CXT_Element, "TPSTransformer" );    /* -------------------------------------------------------------------- */    /*      Serialize bReversed.                                            */    /* -------------------------------------------------------------------- */    CPLCreateXMLElementAndValue(        psTree, "Reversed",        CPLString().Printf( "%d", psInfo->bReversed ) );    /* -------------------------------------------------------------------- */    /*	Attach GCP List. 						*/    /* -------------------------------------------------------------------- */    if( psInfo->nGCPCount > 0 )    {        GDALSerializeGCPListToXML( psTree,                                   psInfo->pasGCPList,                                   psInfo->nGCPCount,                                   NULL );    }    return psTree;}

CPLErr VRTRasterBand::GetHistogram( double dfMin, double dfMax,                                    int nBuckets, GUIntBig * panHistogram,                                    int bIncludeOutOfRange, int bApproxOK,                                    GDALProgressFunc pfnProgress,                                    void *pProgressData ){/* -------------------------------------------------------------------- *//*      Check if we have a matching histogram.                          *//* -------------------------------------------------------------------- */    CPLXMLNode *psHistItem = PamFindMatchingHistogram( m_psSavedHistograms,                                           dfMin, dfMax, nBuckets,                                           bIncludeOutOfRange, bApproxOK );    if( psHistItem != NULL )    {        GUIntBig *panTempHist = NULL;        if( PamParseHistogram( psHistItem, &dfMin, &dfMax, &nBuckets,                               &panTempHist,                               &bIncludeOutOfRange, &bApproxOK ) )        {            memcpy( panHistogram, panTempHist, sizeof(GUIntBig) * nBuckets );            CPLFree( panTempHist );            return CE_None;        }    }/* -------------------------------------------------------------------- *//*      We don't have an existing histogram matching the request, so    *//*      generate one manually.                                          *//* -------------------------------------------------------------------- */    CPLErr eErr = GDALRasterBand::GetHistogram( dfMin, dfMax,                                         nBuckets, panHistogram,                                         bIncludeOutOfRange, bApproxOK,                                         pfnProgress, pProgressData );/* -------------------------------------------------------------------- *//*      Save an XML description of this histogram.                      *//* -------------------------------------------------------------------- */    if( eErr == CE_None )    {        CPLXMLNode *psXMLHist = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,                                           panHistogram,                                           bIncludeOutOfRange, bApproxOK );        if( psXMLHist != NULL )        {            reinterpret_cast<VRTDataset *>( poDS )->SetNeedsFlush();            if( m_psSavedHistograms == NULL )                m_psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,                                                      "Histograms" );            CPLAddXMLChild( m_psSavedHistograms, psXMLHist );        }    }    return eErr;}

static void addGMLId(CPLXMLNode *psParent){    static void *hGMLIdMutex = NULL;    CPLMutexHolderD(&hGMLIdMutex);    CPLXMLNode *psId;    static int nNextGMLId = 1;    char       szIdText[40];    sprintf(szIdText, "ogrcrs%d", nNextGMLId++);    psId =        CPLCreateXMLNode(            CPLCreateXMLNode(psParent, CXT_Attribute, "gml:id"),            CXT_Text, szIdText);}

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;}

CPLXMLNode *VRTKernelFilteredSource::SerializeToXML( const char *pszVRTPath ){    CPLXMLNode *psSrc = VRTFilteredSource::SerializeToXML( pszVRTPath );    if( psSrc == nullptr )        return nullptr;    CPLFree( psSrc->pszValue );    psSrc->pszValue = CPLStrdup("KernelFilteredSource" );    if( m_nKernelSize == 0 )        return psSrc;    CPLXMLNode *psKernel = CPLCreateXMLNode( psSrc, CXT_Element, "Kernel" );    if( m_bNormalized )        CPLCreateXMLNode(            CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),            CXT_Text, "1" );    else        CPLCreateXMLNode(            CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),            CXT_Text, "0" );    const int nCoefCount = m_nKernelSize * m_nKernelSize;    const size_t nBufLen = nCoefCount * 32;    char *pszKernelCoefs = static_cast<char *>( CPLMalloc(nBufLen) );    strcpy( pszKernelCoefs, "" );    for( int iCoef = 0; iCoef < nCoefCount; iCoef++ )        CPLsnprintf( pszKernelCoefs + strlen(pszKernelCoefs),                     nBufLen - strlen(pszKernelCoefs),                     "%.8g ", m_padfKernelCoefs[iCoef] );    CPLSetXMLValue( psKernel, "Size", CPLSPrintf( "%d", m_nKernelSize ) );    CPLSetXMLValue( psKernel, "Coefs", pszKernelCoefs );    CPLFree( pszKernelCoefs );    return psSrc;}

CPLXMLNode *VRTKernelFilteredSource::SerializeToXML( const char *pszVRTPath ){    CPLXMLNode *psSrc = VRTFilteredSource::SerializeToXML( pszVRTPath );    CPLXMLNode *psKernel;    char *pszKernelCoefs;    int iCoef, nCoefCount = nKernelSize * nKernelSize;    if( psSrc == NULL )        return NULL;    CPLFree( psSrc->pszValue );    psSrc->pszValue = CPLStrdup("KernelFilteredSource" );    if( nKernelSize == 0 )        return psSrc;    psKernel = CPLCreateXMLNode( psSrc, CXT_Element, "Kernel" );    if( bNormalized )        CPLCreateXMLNode(             CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),             CXT_Text, "1" );    else        CPLCreateXMLNode(             CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),             CXT_Text, "0" );    pszKernelCoefs = (char *) CPLMalloc(nCoefCount * 32);    strcpy( pszKernelCoefs, "" );    for( iCoef = 0; iCoef < nCoefCount; iCoef++ )        CPLsprintf( pszKernelCoefs + strlen(pszKernelCoefs),                  "%.8g ", padfKernelCoefs[iCoef] );        CPLSetXMLValue( psKernel, "Size", CPLSPrintf( "%d", nKernelSize ) );    CPLSetXMLValue( psKernel, "Coefs", pszKernelCoefs );    CPLFree( pszKernelCoefs );    return psSrc;}

CPLXMLNode *GDALSerializeGCPTransformer( void *pTransformArg ){    CPLXMLNode *psTree = NULL;    GCPTransformInfo *psInfo = (GCPTransformInfo *) pTransformArg;    VALIDATE_POINTER1( pTransformArg, "GDALSerializeGCPTransformer", NULL );    psTree = CPLCreateXMLNode( NULL, CXT_Element, "GCPTransformer" );/* -------------------------------------------------------------------- *//*      Serialize Order and bReversed.                                  *//* -------------------------------------------------------------------- */    CPLCreateXMLElementAndValue(        psTree, "Order",        CPLSPrintf( "%d", psInfo->nOrder ) );    CPLCreateXMLElementAndValue(        psTree, "Reversed",        CPLSPrintf( "%d", psInfo->bReversed ) );    if( psInfo->bRefine )    {        CPLCreateXMLElementAndValue(            psTree, "Refine",            CPLSPrintf( "%d", psInfo->bRefine ) );        CPLCreateXMLElementAndValue(            psTree, "MinimumGcps",            CPLSPrintf( "%d", psInfo->nMinimumGcps ) );        CPLCreateXMLElementAndValue(            psTree, "Tolerance",            CPLSPrintf( "%f", psInfo->dfTolerance ) );    }/* -------------------------------------------------------------------- *//*     Attach GCP List.                                                 *//* -------------------------------------------------------------------- */    if( psInfo->nGCPCount > 0 )    {        if(psInfo->bRefine)        {            remove_outliers(psInfo);        }        GDALSerializeGCPListToXML( psTree,                                   psInfo->pasGCPList,                                   psInfo->nGCPCount,                                   NULL );    }    return psTree;}

static void addProjArg(const OGRSpatialReference *poSRS, CPLXMLNode *psBase,                       const char *pszMeasureType, double dfDefault,                       int nParameterID, const char *pszWKTName){    CPLXMLNode *psNode, *psValue;    psNode = CPLCreateXMLNode(psBase, CXT_Element, "gml:usesParameterValue");/* -------------------------------------------------------------------- *//*      Handle the UOM.                                                 *//* -------------------------------------------------------------------- */    const char *pszUOMValue;    if (EQUAL(pszMeasureType, "Angular"))        pszUOMValue = "urn:ogc:def:uom:EPSG::9102";    else        pszUOMValue = "urn:ogc:def:uom:EPSG::9001";    psValue = CPLCreateXMLNode(psNode, CXT_Element, "gml:value");    CPLCreateXMLNode(        CPLCreateXMLNode(psValue, CXT_Attribute, "gml:uom"),        CXT_Text, pszUOMValue);/* -------------------------------------------------------------------- *//*      Add the parameter value itself.                                 *//* -------------------------------------------------------------------- */    double dfParmValue        = poSRS->GetNormProjParm(pszWKTName, dfDefault, NULL);    CPLCreateXMLNode(psValue, CXT_Text,                     CPLString().Printf("%.16g", dfParmValue));/* -------------------------------------------------------------------- *//*      Add the valueOfParameter.                                       *//* -------------------------------------------------------------------- */    AddValueIDWithURN(psNode, "gml:valueOfParameter", "EPSG", "parameter",                      nParameterID);}

CPLXMLNode* GMLExpatHandler::AddAttributes(CPLXMLNode* psNode, void* attr){    const char** papszIter = (const char** )attr;    CPLXMLNode* psLastChild = NULL;    while(*papszIter)    {        CPLXMLNode* psChild = CPLCreateXMLNode(NULL, CXT_Attribute, papszIter[0]);        CPLCreateXMLNode(psChild, CXT_Text, papszIter[1]);        if (psLastChild == NULL)            psNode->psChild = psChild;        else            psLastChild->psNext = psChild;        psLastChild = psChild;        papszIter += 2;    }    return psLastChild;}

CPLXMLNode *VRTDerivedRasterBand::SerializeToXML(const char *pszVRTPath){    CPLXMLNode *psTree;    psTree = VRTSourcedRasterBand::SerializeToXML( pszVRTPath );/* -------------------------------------------------------------------- *//*      Set subclass.                                                   *//* -------------------------------------------------------------------- */    CPLCreateXMLNode(         CPLCreateXMLNode( psTree, CXT_Attribute, "subClass" ),         CXT_Text, "VRTDerivedRasterBand" );    /* ---- Encode DerivedBand-specific fields ---- */    if( pszFuncName != NULL && strlen(pszFuncName) > 0 )        CPLSetXMLValue(psTree, "PixelFunctionType", this->pszFuncName);    if( this->eSourceTransferType != GDT_Unknown)        CPLSetXMLValue(psTree, "SourceTransferType", 		       GDALGetDataTypeName(this->eSourceTransferType));    return psTree;}

CPLXMLNode *PamHistogramToXMLTree( double dfMin, double dfMax,                       int nBuckets, GUIntBig * panHistogram,                       int bIncludeOutOfRange, int bApprox ){    char *pszHistCounts;    int iBucket;    size_t iHistOffset;    CPLXMLNode *psXMLHist;    CPLString oFmt;    if( nBuckets > (INT_MAX - 10) / 12 )        return NULL;    const size_t nLen = 22 * static_cast<size_t>(nBuckets) + 10;    pszHistCounts = (char *) VSIMalloc(nLen);    if( pszHistCounts == NULL )        return NULL;    psXMLHist = CPLCreateXMLNode( NULL, CXT_Element, "HistItem" );    CPLSetXMLValue( psXMLHist, "HistMin",                    oFmt.Printf( "%.16g", dfMin ));    CPLSetXMLValue( psXMLHist, "HistMax",                    oFmt.Printf( "%.16g", dfMax ));    CPLSetXMLValue( psXMLHist, "BucketCount",                    oFmt.Printf( "%d", nBuckets ));    CPLSetXMLValue( psXMLHist, "IncludeOutOfRange",                    oFmt.Printf( "%d", bIncludeOutOfRange ));    CPLSetXMLValue( psXMLHist, "Approximate",                    oFmt.Printf( "%d", bApprox ));    iHistOffset = 0;    pszHistCounts[0] = '/0';    for( iBucket = 0; iBucket < nBuckets; iBucket++ )    {        snprintf( pszHistCounts + iHistOffset,                  nLen - iHistOffset,                  CPL_FRMT_GUIB, panHistogram[iBucket] );        if( iBucket < nBuckets-1 )            strcat( pszHistCounts + iHistOffset, "|" );        iHistOffset += strlen(pszHistCounts+iHistOffset);    }    CPLSetXMLValue( psXMLHist, "HistCounts", pszHistCounts );    CPLFree( pszHistCounts );    return psXMLHist;}

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;}

static void addURN(CPLXMLNode *psTarget,                   const char *pszAuthority,                   const char *pszObjectType,                   int nCode,                   const char *pszVersion = ""){    char szURN[200];    if (pszVersion == NULL)        pszVersion = "";    CPLAssert(strlen(pszAuthority) + strlen(pszObjectType) < sizeof(szURN) - 30);    sprintf(szURN, "urn:ogc:def:%s:%s:%s:",            pszObjectType, pszAuthority, pszVersion);    if (nCode != 0)        sprintf(szURN + strlen(szURN), "%d", nCode);    CPLCreateXMLNode(        CPLCreateXMLNode(psTarget, CXT_Attribute, "xlink:href"),        CXT_Text, szURN);}

static CPLXMLNode*AddValueIDWithURN(CPLXMLNode *psTarget,                  const char *pszElement,                  const char *pszAuthority,                  const char *pszObjectType,                  int nCode,                  const char *pszVersion = ""){    CPLXMLNode *psElement;    psElement = CPLCreateXMLNode(psTarget, CXT_Element, pszElement);    addURN(psElement, pszAuthority, pszObjectType, nCode, pszVersion);    return psElement;}

CPLErr VRTRasterBand::SetDefaultHistogram( double dfMin, double dfMax,                                            int nBuckets, GUIntBig *panHistogram){    CPLXMLNode *psNode;/* -------------------------------------------------------------------- *//*      Do we have a matching histogram we should replace?              *//* -------------------------------------------------------------------- */    psNode = PamFindMatchingHistogram( psSavedHistograms,                                        dfMin, dfMax, nBuckets,                                       TRUE, TRUE );    if( psNode != NULL )    {        /* blow this one away */        CPLRemoveXMLChild( 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.        *//* -------------------------------------------------------------------- */    ((VRTDataset *) poDS)->SetNeedsFlush();    if( psSavedHistograms == NULL )        psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,                                              "Histograms" );                psHistItem->psNext = psSavedHistograms->psChild;    psSavedHistograms->psChild = psHistItem;        return CE_None;}

int GMLReader::SaveClasses( const char *pszFile ){    // Add logic later to determine reasonable default schema file.     if( pszFile == NULL )        return FALSE;/* -------------------------------------------------------------------- *//*      Create in memory schema tree.                                   *//* -------------------------------------------------------------------- */    CPLXMLNode *psRoot;    psRoot = CPLCreateXMLNode( NULL, CXT_Element, "GMLFeatureClassList" );    for( int iClass = 0; iClass < GetClassCount(); iClass++ )    {        GMLFeatureClass *poClass = GetClass( iClass );                CPLAddXMLChild( psRoot, poClass->SerializeToXML() );    }/* -------------------------------------------------------------------- *//*      Serialize to disk.                                              *//* -------------------------------------------------------------------- */    FILE        *fp;    int         bSuccess = TRUE;    char        *pszWholeText = CPLSerializeXMLTree( psRoot );        CPLDestroyXMLNode( psRoot );     fp = VSIFOpen( pszFile, "wb" );        if( fp == NULL )        bSuccess = FALSE;    else if( VSIFWrite( pszWholeText, strlen(pszWholeText), 1, fp ) != 1 )        bSuccess = FALSE;    else        VSIFClose( fp );    CPLFree( pszWholeText );    return bSuccess;}

CPLXMLNode *VRTDataset::SerializeToXML( const char *pszVRTPath ){    /* -------------------------------------------------------------------- */    /*      Setup root node and attributes.                                 */    /* -------------------------------------------------------------------- */    CPLXMLNode *psDSTree = NULL;    CPLXMLNode *psMD = NULL;    char       szNumber[128];    psDSTree = CPLCreateXMLNode( NULL, CXT_Element, "VRTDataset" );    sprintf( szNumber, "%d", GetRasterXSize() );    CPLSetXMLValue( psDSTree, "#rasterXSize", szNumber );    sprintf( szNumber, "%d", GetRasterYSize() );    CPLSetXMLValue( psDSTree, "#rasterYSize", szNumber ); /* -------------------------------------------------------------------- */ /*      SRS                                                             */ /* -------------------------------------------------------------------- */    if( pszProjection != NULL && strlen(pszProjection) > 0 )        CPLSetXMLValue( psDSTree, "SRS", pszProjection ); /* -------------------------------------------------------------------- */ /*      Geotransform.                                                   */ /* -------------------------------------------------------------------- */    if( bGeoTransformSet )    {        CPLSetXMLValue( psDSTree, "GeoTransform",                         CPLSPrintf( "%24.16e,%24.16e,%24.16e,%24.16e,%24.16e,%24.16e",                                    adfGeoTransform[0],                                    adfGeoTransform[1],                                    adfGeoTransform[2],                                    adfGeoTransform[3],                                    adfGeoTransform[4],                                    adfGeoTransform[5] ) );    }/* -------------------------------------------------------------------- *//*      Metadata                                                        *//* -------------------------------------------------------------------- */    psMD = oMDMD.Serialize();    if( psMD != NULL )        CPLAddXMLChild( psDSTree, psMD ); /* -------------------------------------------------------------------- */ /*      GCPs                                                            */ /* -------------------------------------------------------------------- */    if( nGCPCount > 0 )    {        CPLXMLNode *psGCPList = CPLCreateXMLNode( psDSTree, CXT_Element,                                                   "GCPList" );        CPLXMLNode* psLastChild = NULL;        if( pszGCPProjection != NULL && strlen(pszGCPProjection) > 0 )        {            CPLSetXMLValue( psGCPList, "#Projection", pszGCPProjection );            psLastChild = psGCPList->psChild;        }        for( int iGCP = 0; iGCP < nGCPCount; iGCP++ )        {            CPLXMLNode *psXMLGCP;            GDAL_GCP *psGCP = pasGCPList + iGCP;            psXMLGCP = CPLCreateXMLNode( NULL, CXT_Element, "GCP" );            if( psLastChild == NULL )                psGCPList->psChild = psXMLGCP;            else                psLastChild->psNext = psXMLGCP;            psLastChild = psXMLGCP;            CPLSetXMLValue( psXMLGCP, "#Id", psGCP->pszId );            if( psGCP->pszInfo != NULL && strlen(psGCP->pszInfo) > 0 )                CPLSetXMLValue( psXMLGCP, "Info", psGCP->pszInfo );            CPLSetXMLValue( psXMLGCP, "#Pixel",                             CPLSPrintf( "%.4f", psGCP->dfGCPPixel ) );            CPLSetXMLValue( psXMLGCP, "#Line",                             CPLSPrintf( "%.4f", psGCP->dfGCPLine ) );            CPLSetXMLValue( psXMLGCP, "#X",                             CPLSPrintf( "%.12E", psGCP->dfGCPX ) );            CPLSetXMLValue( psXMLGCP, "#Y",                             CPLSPrintf( "%.12E", psGCP->dfGCPY ) );            if( psGCP->dfGCPZ != 0.0 )                CPLSetXMLValue( psXMLGCP, "#GCPZ",                                 CPLSPrintf( "%.12E", psGCP->dfGCPZ ) );        }    }    /* -------------------------------------------------------------------- */    /*      Serialize bands.                                                *///.........这里部分代码省略.........

CPLXMLNode *GDALSerializeGCPTransformer( void *pTransformArg ){    CPLXMLNode *psTree;    GCPTransformInfo *psInfo = (GCPTransformInfo *) pTransformArg;    VALIDATE_POINTER1( pTransformArg, "GDALSerializeGCPTransformer", NULL );    psTree = CPLCreateXMLNode( NULL, CXT_Element, "GCPTransformer" );/* -------------------------------------------------------------------- *//*      Serialize Order and bReversed.                                  *//* -------------------------------------------------------------------- */    CPLCreateXMLElementAndValue(         psTree, "Order",         CPLSPrintf( "%d", psInfo->nOrder ) );                             CPLCreateXMLElementAndValue(         psTree, "Reversed",         CPLSPrintf( "%d", psInfo->bReversed ) );    if( psInfo->bRefine )    {        CPLCreateXMLElementAndValue(            psTree, "Refine",            CPLSPrintf( "%d", psInfo->bRefine ) );        CPLCreateXMLElementAndValue(            psTree, "MinimumGcps",            CPLSPrintf( "%d", psInfo->nMinimumGcps ) );        CPLCreateXMLElementAndValue(            psTree, "Tolerance",            CPLSPrintf( "%f", psInfo->dfTolerance ) );    }                                 /* -------------------------------------------------------------------- *//*	Attach GCP List. 						*//* -------------------------------------------------------------------- */    if( psInfo->nGCPCount > 0 )    {        int iGCP;        CPLXMLNode *psGCPList = CPLCreateXMLNode( psTree, CXT_Element,                                                   "GCPList" );	if(psInfo->bRefine)	{	  remove_outliers(psInfo);	}	        for( iGCP = 0; iGCP < psInfo->nGCPCount; iGCP++ )        {            CPLXMLNode *psXMLGCP;            GDAL_GCP *psGCP = psInfo->pasGCPList + iGCP;            psXMLGCP = CPLCreateXMLNode( psGCPList, CXT_Element, "GCP" );            CPLSetXMLValue( psXMLGCP, "#Id", psGCP->pszId );            if( psGCP->pszInfo != NULL && strlen(psGCP->pszInfo) > 0 )                CPLSetXMLValue( psXMLGCP, "Info", psGCP->pszInfo );            CPLSetXMLValue( psXMLGCP, "#Pixel",                             CPLSPrintf( "%.4f", psGCP->dfGCPPixel ) );            CPLSetXMLValue( psXMLGCP, "#Line",                             CPLSPrintf( "%.4f", psGCP->dfGCPLine ) );            CPLSetXMLValue( psXMLGCP, "#X",                             CPLSPrintf( "%.12E", psGCP->dfGCPX ) );            CPLSetXMLValue( psXMLGCP, "#Y",                             CPLSPrintf( "%.12E", psGCP->dfGCPY ) );            if( psGCP->dfGCPZ != 0.0 )                CPLSetXMLValue( psXMLGCP, "#GCPZ",                                 CPLSPrintf( "%.12E", psGCP->dfGCPZ ) );        }    }    return psTree;}

CPLXMLNode *VRTRasterBand::SerializeToXML( const char *pszVRTPath ){    CPLXMLNode *psTree;    psTree = CPLCreateXMLNode( NULL, CXT_Element, "VRTRasterBand" );/* -------------------------------------------------------------------- *//*      Various kinds of metadata.                                      *//* -------------------------------------------------------------------- */    CPLXMLNode *psMD;    CPLSetXMLValue( psTree, "#dataType",                     GDALGetDataTypeName( GetRasterDataType() ) );    if( nBand > 0 )        CPLSetXMLValue( psTree, "#band", CPLSPrintf( "%d", GetBand() ) );    psMD = oMDMD.Serialize();    if( psMD != NULL )        CPLAddXMLChild( psTree, psMD );    if( strlen(GetDescription()) > 0 )        CPLSetXMLValue( psTree, "Description", GetDescription() );    if( bNoDataValueSet )    {        if (CPLIsNan(dfNoDataValue))            CPLSetXMLValue( psTree, "NoDataValue", "nan");        else            CPLSetXMLValue( psTree, "NoDataValue",                             CPLSPrintf( "%.14E", dfNoDataValue ) );    }        if( bHideNoDataValue )        CPLSetXMLValue( psTree, "HideNoDataValue",                         CPLSPrintf( "%d", bHideNoDataValue ) );    if( pszUnitType != NULL )        CPLSetXMLValue( psTree, "UnitType", pszUnitType );    if( dfOffset != 0.0 )        CPLSetXMLValue( psTree, "Offset",                         CPLSPrintf( "%.16g", dfOffset ) );    if( dfScale != 1.0 )        CPLSetXMLValue( psTree, "Scale",                         CPLSPrintf( "%.16g", dfScale ) );    if( eColorInterp != GCI_Undefined )        CPLSetXMLValue( psTree, "ColorInterp",                         GDALGetColorInterpretationName( eColorInterp ) );/* -------------------------------------------------------------------- *//*      Category names.                                                 *//* -------------------------------------------------------------------- */    if( papszCategoryNames != NULL )    {        CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,                                                  "CategoryNames" );        CPLXMLNode* psLastChild = NULL;        for( int iEntry=0; papszCategoryNames[iEntry] != NULL; iEntry++ )        {            CPLXMLNode *psNode = CPLCreateXMLElementAndValue( NULL, "Category",                                         papszCategoryNames[iEntry] );            if( psLastChild == NULL )                psCT_XML->psChild = psNode;            else                psLastChild->psNext = psNode;            psLastChild = psNode;        }    }/* -------------------------------------------------------------------- *//*      Histograms.                                                     *//* -------------------------------------------------------------------- */    if( psSavedHistograms != NULL )        CPLAddXMLChild( psTree, CPLCloneXMLTree( psSavedHistograms ) );/* -------------------------------------------------------------------- *//*      Color Table.                                                    *//* -------------------------------------------------------------------- */    if( poColorTable != NULL )    {        CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,                                                  "ColorTable" );        CPLXMLNode* psLastChild = NULL;        for( int iEntry=0; iEntry < poColorTable->GetColorEntryCount();              iEntry++ )        {            GDALColorEntry sEntry;            CPLXMLNode *psEntry_XML = CPLCreateXMLNode( NULL, CXT_Element,                                                        "Entry" );            if( psLastChild == NULL )                psCT_XML->psChild = psEntry_XML;            else                psLastChild->psNext = psEntry_XML;            psLastChild = psEntry_XML;//.........这里部分代码省略.........