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

EIRDataset::~EIRDataset(){    FlushCache();    if( nBands > 0 && GetAccess() == GA_Update )    {        int bNoDataSet;        double dfNoData;        RawRasterBand *poBand = (RawRasterBand *) GetRasterBand( 1 );        dfNoData = poBand->GetNoDataValue(&bNoDataSet);        if( bNoDataSet )        {            ResetKeyValue( "NODATA",                            CPLString().Printf( "%.8g", dfNoData ) );        }    }    if( fpImage != NULL )        VSIFCloseL( fpImage );        CSLDestroy( papszHDR );    CSLDestroy( papszExtraFiles );}

CPLString GMLASConfiguration::GetBaseCacheDirectory(){#ifdef WIN32    const char* pszHome = CPLGetConfigOption("USERPROFILE", NULL);#else    const char* pszHome = CPLGetConfigOption("HOME", NULL);#endif    if( pszHome != NULL )    {        return CPLFormFilename( pszHome, ".gdal", NULL) ;    }    else    {        const char *pszDir = CPLGetConfigOption( "CPL_TMPDIR", NULL );        if( pszDir == NULL )            pszDir = CPLGetConfigOption( "TMPDIR", NULL );        if( pszDir == NULL )            pszDir = CPLGetConfigOption( "TEMP", NULL );        const char* pszUsername = CPLGetConfigOption("USERNAME", NULL);        if( pszUsername == NULL )            pszUsername = CPLGetConfigOption("USER", NULL);        if( pszDir != NULL && pszUsername != NULL )        {            return CPLFormFilename( pszDir,                    CPLSPrintf(".gdal_%s", pszUsername), NULL) ;        }    }    return CPLString();}

int CPLKeywordParser::ReadGroup( const char *pszPathPrefix ){    CPLString osName, osValue;    for( ; TRUE; )    {        if( !ReadPair( osName, osValue ) )            return FALSE;        if( EQUAL(osName,"BEGIN_GROUP") || EQUAL(osName,"GROUP") )        {            if( !ReadGroup( (CPLString(pszPathPrefix) + osValue + ".").c_str() ) )                return FALSE;        }        else if( EQUALN(osName,"END",3) )        {            return TRUE;        }        else        {            osName = pszPathPrefix + osName;            papszKeywordList = CSLSetNameValue( papszKeywordList,                                                 osName, osValue );        }    }}

static size_t CPLWriteFct(void *buffer, size_t size, size_t nmemb, void *reqInfo){    CPLHTTPResult *psResult = (CPLHTTPResult *) reqInfo;    int  nNewSize;    nNewSize = psResult->nDataLen + nmemb*size + 1;    if( nNewSize > psResult->nDataAlloc )    {        psResult->nDataAlloc = (int) (nNewSize * 1.25 + 100);        GByte* pabyNewData = (GByte *) VSIRealloc(psResult->pabyData,                                                  psResult->nDataAlloc);        if( pabyNewData == NULL )        {            VSIFree(psResult->pabyData);            psResult->pabyData = NULL;            psResult->pszErrBuf = CPLStrdup(CPLString().Printf("Out of memory allocating %d bytes for HTTP data buffer.", psResult->nDataAlloc));            psResult->nDataAlloc = psResult->nDataLen = 0;            return 0;        }        psResult->pabyData = pabyNewData;    }    memcpy( psResult->pabyData + psResult->nDataLen, buffer,            nmemb * size );    psResult->nDataLen += nmemb * size;    psResult->pabyData[psResult->nDataLen] = 0;    return nmemb;}

void GDALGMLJP2Expr::ReportError( const char* pszOriStr,                                  const char* pszStr,                                  const char* pszIntroMessage ){    size_t nDist = static_cast<size_t>(pszStr - pszOriStr);    if( nDist > 40 )        nDist = 40;    CPLString osErrMsg(pszIntroMessage);    CPLString osInvalidExpr = CPLString(pszStr - nDist).substr(0, nDist + 20);    for( int i = static_cast<int>(nDist) - 1; i >= 0; --i )    {        if( osInvalidExpr[i] == '/n' )        {            osInvalidExpr = osInvalidExpr.substr(i+1);            nDist -= i + 1;            break;        }    }    for( size_t i = nDist; i < osInvalidExpr.size(); ++i )    {        if( osInvalidExpr[i] == '/n' )        {            osInvalidExpr.resize(i);            break;        }    }    osErrMsg += osInvalidExpr;    osErrMsg += "/n";    for( size_t i = 0; i < nDist; ++i )        osErrMsg += " ";    osErrMsg += "^";    CPLError(CE_Failure, CPLE_AppDefined, "%s", osErrMsg.c_str());}

OGRPGDumpLayer::OGRPGDumpLayer(OGRPGDumpDataSource* poDS,                               const char* pszSchemaName,                               const char* pszTableName,                               const char* pszGeomColumn,                               const char *pszFIDColumn,                               int         nCoordDimension,                               int         nSRSId,                               int         bWriteAsHexIn,                               int         bCreateTable){    this->poDS = poDS;    poFeatureDefn = new OGRFeatureDefn( pszTableName );    poFeatureDefn->Reference();    nFeatures = 0;    pszSqlTableName = CPLStrdup(CPLString().Printf("%s.%s",                               OGRPGDumpEscapeColumnName(pszSchemaName).c_str(),                               OGRPGDumpEscapeColumnName(pszTableName).c_str() ));    this->pszGeomColumn = (pszGeomColumn) ? CPLStrdup(pszGeomColumn) : NULL;    this->pszFIDColumn = CPLStrdup(pszFIDColumn);    this->nCoordDimension = nCoordDimension;    this->nSRSId = nSRSId;    this->bCreateTable = bCreateTable;    bLaunderColumnNames = TRUE;    bPreservePrecision = TRUE;    bUseCopy = USE_COPY_UNSET;    bWriteAsHex = bWriteAsHexIn;    bCopyActive = FALSE;}

TIF_Band::TIF_Band(GDALMRFDataset *pDS, const ILImage &image, int b, int level):        GDALMRFRasterBand(pDS,image,b,int(level)){    // Increase the page buffer by 1K in case Tiff expands data    pDS->SetPBuffer(image.pageSizeBytes + 1024);    // Static create options for TIFF tiles    papszOptions = CSLAddNameValue(NULL, "COMPRESS", "DEFLATE");    papszOptions = CSLAddNameValue(papszOptions, "TILED", "Yes");    papszOptions = CSLAddNameValue(papszOptions, "BLOCKXSIZE", CPLString().Printf("%d",img.pagesize.x));    papszOptions = CSLAddNameValue(papszOptions, "BLOCKYSIZE", CPLString().Printf("%d",img.pagesize.y));    int q = img.quality / 10;    // Move down so the default 85 maps to 6.  This makes the maz ZLEVEL 8, which is OK    if (q >2) q-=2;    papszOptions = CSLAddNameValue(papszOptions, "ZLEVEL", CPLString().Printf("%d",q));};

CPLString OGRVRTGetSerializedGeometryType(OGRwkbGeometryType eGeomType){    for( const auto& entry: asGeomTypeNames )    {        if( entry.eType == wkbFlatten(eGeomType) )        {            CPLString osRet(entry.pszName);            if( entry.bIsoFlags || OGR_GT_HasM(eGeomType) )            {                if( OGR_GT_HasZ(eGeomType) )                {                    osRet += "Z";                }                if( OGR_GT_HasM(eGeomType) )                {                    osRet += "M";                }            }            else if(OGR_GT_HasZ(eGeomType) )            {                osRet += "25D";            }            return osRet;        }    }    return CPLString();}

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

std::map<CPLString, CPLString>OGRDXFWriterLayer::PrepareTextStyleDefinition( OGRStyleLabel *poLabelTool ){    GBool bDefault;    std::map<CPLString, CPLString> oTextStyleDef;/* -------------------------------------------------------------------- *//*      Fetch the data for this text style.                             *//* -------------------------------------------------------------------- */    const char *pszFontName = poLabelTool->FontName(bDefault);    if( !bDefault )        oTextStyleDef["Font"] = pszFontName;    const GBool bBold = poLabelTool->Bold(bDefault);    if( !bDefault )        oTextStyleDef["Bold"] = bBold ? "1" : "0";    const GBool bItalic = poLabelTool->Italic(bDefault);    if( !bDefault )        oTextStyleDef["Italic"] = bItalic ? "1" : "0";    const double dfStretch = poLabelTool->Stretch(bDefault);    if( !bDefault )    {        oTextStyleDef["Width"] = CPLString().Printf( "%f",            dfStretch / 100.0 );    }    return oTextStyleDef;}

static size_t CPLHTTPWriteFunc(void *buffer, size_t count, size_t nmemb, void *req) {    CPLHTTPRequest *psRequest = reinterpret_cast<CPLHTTPRequest *>(req);    size_t size = count * nmemb;    if (size == 0) return 0;    const size_t required_size = psRequest->nDataLen + size + 1;    if (required_size > psRequest->nDataAlloc) {        size_t new_size = required_size * 2;        if (new_size < 512) new_size = 512;        psRequest->nDataAlloc = new_size;        GByte * pabyNewData = reinterpret_cast<GByte *>(VSIRealloc(psRequest->pabyData, new_size));        if (pabyNewData == NULL) {            VSIFree(psRequest->pabyData);            psRequest->pabyData = NULL;            psRequest->pszError = CPLStrdup(CPLString().Printf("Out of memory allocating %u bytes for HTTP data buffer.", static_cast<int>(new_size)));            psRequest->nDataAlloc = 0;            psRequest->nDataLen = 0;            return 0;        }        psRequest->pabyData = pabyNewData;    }    memcpy(psRequest->pabyData + psRequest->nDataLen, buffer, size);    psRequest->nDataLen += size;    psRequest->pabyData[psRequest->nDataLen] = 0;    return nmemb;}

int NASAKeywordHandler::ReadGroup( const char *pszPathPrefix ){    for( ; true; )    {        CPLString osName, osValue;        if( !ReadPair( osName, osValue ) )            return FALSE;        if( EQUAL(osName,"OBJECT") || EQUAL(osName,"GROUP") )        {            if( !ReadGroup( (CPLString(pszPathPrefix) + osValue + ".").c_str() ) )                return FALSE;        }        else if( EQUAL(osName,"END")                 || EQUAL(osName,"END_GROUP" )                 || EQUAL(osName,"END_OBJECT" ) )        {            return TRUE;        }        else        {            osName = pszPathPrefix + osName;            papszKeywordList = CSLSetNameValue( papszKeywordList,                                                osName, osValue );        }    }}

int ISIS2Dataset::WriteQUBE_Information(    VSILFILE *fpLabel, unsigned int iLevel, unsigned int & nWritingBytes,    unsigned int nXSize,  unsigned int nYSize, unsigned int nBands,    GDALDataType eType, const char * pszInterleaving){    nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "");    nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "/* Qube structure */");    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "OBJECT", "QUBE");    iLevel++;    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "AXES", "3");    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "AXIS_NAME", pszInterleaving);    nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "/* Core description */");    CPLDebug("ISIS2","%d,%d,%d",nXSize,nYSize,nBands);    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEMS",CPLString().Printf("(%d,%d,%d)",nXSize,nYSize,nBands));    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_NAME", "/"RAW DATA NUMBER/"");    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_UNIT", "/"N/A/"");    // TODO change for eType    if( eType == GDT_Byte )    {        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_TYPE", "PC_UNSIGNED_INTEGER");        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_BYTES", "1");    }    else if( eType == GDT_UInt16 )    {        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_TYPE", "PC_UNSIGNED_INTEGER");        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_BYTES", "2");    }    else if( eType == GDT_Int16 )    {        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_TYPE", "PC_INTEGER");        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_BYTES", "2");    }    else if( eType == GDT_Float32 )    {        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_TYPE", "PC_REAL");        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_BYTES", "4");    }    else if( eType == GDT_Float64 )    {        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_TYPE", "PC_REAL");        nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_ITEM_BYTES", "8");    }    // TODO add core null value    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_BASE", "0.0");    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "CORE_MULTIPLIER", "1.0");    nWritingBytes += ISIS2Dataset::WriteFormatting( fpLabel, "/* Suffix description */");    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "SUFFIX_BYTES", "4");    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "SUFFIX_ITEMS", "( 0, 0, 0)");    iLevel--;    nWritingBytes += ISIS2Dataset::WriteKeyword( fpLabel, iLevel, "END_OBJECT", "QUBE");    return TRUE;}

CPLString wxGxObjectDialog::GetPath(void) const{    wxGxObject* pObj = GetLocation();    if (NULL == pObj)        return CPLString();    return pObj->GetPath();}

CPLString BufferToVSIFile(GByte *buffer, size_t size) {    CPLString file_name;    file_name.Printf("/vsimem/wms/%p/wmsresult.dat", buffer);    VSILFILE *f = VSIFileFromMemBuffer(file_name.c_str(), buffer, size, false);    if (f == nullptr) return CPLString();    VSIFCloseL(f);    return file_name;}

int GDALWMSDataset::Identify(GDALOpenInfo *poOpenInfo){    const char* pszFilename = poOpenInfo->pszFilename;    const char* pabyHeader = (const char *) poOpenInfo->pabyHeader;    if (poOpenInfo->nHeaderBytes == 0 &&         EQUALN(pszFilename, "<GDAL_WMS>", 10))    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes >= 10 &&             EQUALN(pabyHeader, "<GDAL_WMS>", 10))    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes == 0 &&             (EQUALN(pszFilename, "WMS:", 4) ||             CPLString(pszFilename).ifind("SERVICE=WMS") != std::string::npos) )    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes != 0 &&             (strstr(pabyHeader, "<WMT_MS_Capabilities") != NULL ||              strstr(pabyHeader, "<WMS_Capabilities") != NULL ||              strstr(pabyHeader, "<!DOCTYPE WMT_MS_Capabilities") != NULL))    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes != 0 &&             strstr(pabyHeader, "<WMS_Tile_Service") != NULL)    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes != 0 &&             strstr(pabyHeader, "<TileMap version=/"1.0.0/"") != NULL)    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes != 0 &&             strstr(pabyHeader, "<Services") != NULL &&             strstr(pabyHeader, "<TileMapService version=/"1.0") != NULL)    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes != 0 &&             strstr(pabyHeader, "<TileMapService version=/"1.0.0/"") != NULL)    {        return TRUE;    }    else if (poOpenInfo->nHeaderBytes == 0 &&             EQUALN(pszFilename, "http", 4) &&             strstr(pszFilename, "/MapServer?f=json") != NULL)    {        return TRUE;    }    else        return FALSE;}

int OGRXLSDataSource::Open( const char * pszFilename, int bUpdateIn){    if (bUpdateIn)    {        return FALSE;    }#ifdef _WIN32    if( CPLTestBool( CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )        pszName = CPLRecode( pszFilename, CPL_ENC_UTF8, CPLString().Printf( "CP%d", GetACP() ) );    else        pszName = CPLStrdup( pszFilename );#else    pszName = CPLStrdup( pszFilename );#endif// --------------------------------------------------------------------//      Does this appear to be a .xls file?// --------------------------------------------------------------------    /* Open only for getting info. To get cell values, we have to use freexl_open */    if (freexl_open_info (pszName, &xlshandle) != FREEXL_OK)        return FALSE;    unsigned int nSheets = 0;    if (freexl_get_info (xlshandle, FREEXL_BIFF_SHEET_COUNT, &nSheets) != FREEXL_OK)        return FALSE;    for(unsigned short i=0; i<(unsigned short)nSheets; i++)    {        freexl_select_active_worksheet(xlshandle, i);        const char* pszSheetname = NULL;        if (freexl_get_worksheet_name(xlshandle, i, &pszSheetname) != FREEXL_OK)            return FALSE;        unsigned int nRows = 0;        unsigned short nCols = 0;        if (freexl_worksheet_dimensions(xlshandle, &nRows, &nCols) != FREEXL_OK)            return FALSE;        /* Skip empty sheets */        if (nRows == 0)            continue;        papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));        papoLayers[nLayers ++] = new OGRXLSLayer(this, pszSheetname, i, (int)nRows, nCols);    }    freexl_close(xlshandle);    xlshandle = NULL;    return TRUE;}

bool netCDFWriterConfiguration::Parse(const char *pszFilename){    CPLXMLNode *psRoot =        STARTS_WITH(pszFilename, "<Configuration")        ? CPLParseXMLString(pszFilename)        : CPLParseXMLFile(pszFilename);    if( psRoot == NULL )        return false;    CPLXMLTreeCloser oCloser(psRoot);    for( CPLXMLNode *psIter = psRoot->psChild; psIter != NULL;         psIter = psIter->psNext )    {        if( psIter->eType != CXT_Element )            continue;        if( EQUAL(psIter->pszValue, "DatasetCreationOption") )        {            SetNameValue(psIter, m_oDatasetCreationOptions);        }        else if( EQUAL(psIter->pszValue, "LayerCreationOption") )        {            SetNameValue(psIter, m_oLayerCreationOptions);        }        else if( EQUAL(psIter->pszValue, "Attribute") )        {            netCDFWriterConfigAttribute oAtt;            if( oAtt.Parse(psIter) )                m_aoAttributes.push_back(oAtt);        }        else if( EQUAL(psIter->pszValue, "Field") )        {            netCDFWriterConfigField oField;            if( oField.Parse(psIter) )                m_oFields[!oField.m_osName.empty()                              ? oField.m_osName                              : CPLString("__") + oField.m_osNetCDFName] =                    oField;        }        else if( EQUAL(psIter->pszValue, "Layer") )        {            netCDFWriterConfigLayer oLayer;            if( oLayer.Parse(psIter) )                m_oLayers[oLayer.m_osName] = oLayer;        }        else        {            CPLDebug("GDAL_netCDF", "Ignoring %s", psIter->pszValue);        }    }    m_bIsValid = true;    return true;}

int FGdbDatabaseConnection::OpenGeodatabase(const char* pszFSName){    m_pGeodatabase = new Geodatabase;    long hr = ::OpenGeodatabase(StringToWString(CPLString(pszFSName)), *m_pGeodatabase);    if (FAILED(hr))    {        delete m_pGeodatabase;        m_pGeodatabase = NULL;        return FALSE;    }    return TRUE;}

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

CPLString VSIOSSHandleHelper::GetSignedURL(CSLConstList papszOptions){    GIntBig nStartDate = static_cast<GIntBig>(time(nullptr));    const char* pszStartDate = CSLFetchNameValue(papszOptions, "START_DATE");    if( pszStartDate )    {        int nYear, nMonth, nDay, nHour, nMin, nSec;        if( sscanf(pszStartDate, "%04d%02d%02dT%02d%02d%02dZ",                   &nYear, &nMonth, &nDay, &nHour, &nMin, &nSec) == 6 )        {            struct tm brokendowntime;            brokendowntime.tm_year = nYear - 1900;            brokendowntime.tm_mon = nMonth - 1;            brokendowntime.tm_mday = nDay;            brokendowntime.tm_hour = nHour;            brokendowntime.tm_min = nMin;            brokendowntime.tm_sec = nSec;            nStartDate = CPLYMDHMSToUnixTime(&brokendowntime);        }    }    GIntBig nExpiresIn = nStartDate + atoi(        CSLFetchNameValueDef(papszOptions, "EXPIRATION_DELAY", "3600"));    CPLString osExpires(CSLFetchNameValueDef(papszOptions, "EXPIRES",                                    CPLSPrintf(CPL_FRMT_GIB, nExpiresIn)));    CPLString osVerb(CSLFetchNameValueDef(papszOptions, "VERB", "GET"));    CPLString osCanonicalizedResource( m_osBucket.empty() ? CPLString("/") :        "/" + m_osBucket +  "/" + m_osObjectKey );    CPLString osStringToSign;    osStringToSign += osVerb + "/n";    osStringToSign += "/n";    osStringToSign += "/n";    osStringToSign += osExpires + "/n";    // osStringToSign += ; // osCanonicalizedHeaders;    osStringToSign += osCanonicalizedResource;#ifdef DEBUG_VERBOSE    CPLDebug("OSS", "osStringToSign = %s", osStringToSign.c_str());#endif    CPLString osSignature(GetSignature(osStringToSign, m_osSecretAccessKey));    ResetQueryParameters();    //  Note: https://www.alibabacloud.com/help/doc-detail/31952.htm?spm=a3c0i.o32002en.b99.294.6d70a0fc7cRJfJ is wrong on the name of the OSSAccessKeyId parameter !    AddQueryParameter("OSSAccessKeyId", m_osAccessKeyId);    AddQueryParameter("Expires", osExpires);    AddQueryParameter("Signature", osSignature);    return m_osURL;}

JP2LuraRasterBand::JP2LuraRasterBand(JP2LuraDataset *poDSIn, int nBandIn,                                     GDALDataType eDataTypeIn,                                     int nBits,                                     int nBlockXSizeIn, int nBlockYSizeIn){    eDataType = eDataTypeIn;    nBlockXSize = nBlockXSizeIn;    nBlockYSize = nBlockYSizeIn;    poDS = poDSIn;    nRasterXSize = poDSIn->nRasterXSize;    nRasterYSize = poDSIn->nRasterYSize;    nBand = nBandIn;    if (nRasterXSize == nBlockXSize && nRasterYSize == nBlockYSize)    {    /* -------------------------------------------------------------------- */    /*      Use a 2048x128 "virtual" block size unless the file is small.   */    /* -------------------------------------------------------------------- */        if (nRasterXSize >= 2048)        {            nBlockXSize = 2048;        }        else        {            nBlockXSize = nRasterXSize;        }        if (nRasterYSize >= 128)        {            nBlockYSize = 128;        }        else        {            nBlockYSize = nRasterYSize;        }    }    if( (nBits % 8) != 0 )    {        GDALRasterBand::SetMetadataItem("NBITS",                        CPLString().Printf("%d",nBits),                        "IMAGE_STRUCTURE" );    }    GDALRasterBand::SetMetadataItem("COMPRESSION", "JPEG2000",                    "IMAGE_STRUCTURE" );    bForceCachedIO = FALSE;}

OGRGFTResultLayer::OGRGFTResultLayer( OGRGFTDataSource* poDSIn,                                      const char* pszSQL ) :    OGRGFTLayer(poDSIn),    osSQL( CPLString() ),    bGotAllRows(FALSE){    // cppcheck-suppress useInitializationList    osSQL = PatchSQL(pszSQL);    poFeatureDefn = new OGRFeatureDefn( "result" );    poFeatureDefn->Reference();    poFeatureDefn->SetGeomType( wkbUnknown );    poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);    SetDescription( poFeatureDefn->GetName() );}

OGRErr OGRGMELayer::SetAttributeFilter( const char *pszWhere ){    OGRErr eErr;    eErr = OGRLayer::SetAttributeFilter(pszWhere);    if( eErr == OGRERR_NONE ) {        if ( pszWhere ) {            char * pszEscaped = CPLEscapeString(pszWhere, -1, CPLES_URL);            osWhere = CPLString(pszEscaped);            CPLFree(pszEscaped);        }        else {            osWhere = "";        }    }    return eErr;}

bool netCDFWriterConfigLayer::Parse(CPLXMLNode *psNode){    const char *pszName = CPLGetXMLValue(psNode, "name", NULL);    const char *pszNetCDFName = CPLGetXMLValue(psNode, "netcdf_name", pszName);    if( pszName == NULL )    {        CPLError(CE_Failure, CPLE_IllegalArg, "Missing name");        return false;    }    m_osName = pszName;    if( pszNetCDFName != NULL )        m_osNetCDFName = pszNetCDFName;    for( CPLXMLNode *psIter = psNode->psChild; psIter != NULL;         psIter = psIter->psNext )    {        if( psIter->eType != CXT_Element )            continue;        if( EQUAL(psIter->pszValue, "LayerCreationOption") )        {            netCDFWriterConfiguration::SetNameValue(psIter,                                                    m_oLayerCreationOptions);        }        else if( EQUAL(psIter->pszValue, "Attribute") )        {            netCDFWriterConfigAttribute oAtt;            if( oAtt.Parse(psIter) )                m_aoAttributes.push_back(oAtt);        }        else if( EQUAL(psIter->pszValue, "Field") )        {            netCDFWriterConfigField oField;            if( oField.Parse(psIter) )                m_oFields[!oField.m_osName.empty()                              ? oField.m_osName                              : CPLString("__") + oField.m_osNetCDFName] =                    oField;        }        else        {            CPLDebug("GDAL_netCDF", "Ignoring %s", psIter->pszValue);        }    }    return true;}

staticOGRFeatureDefn *defineLayer(const char *szName, OGRwkbGeometryType szType, S2I *poHeaders, S2I **ppoHeadersNew) {    OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn( szName );    poFeatureDefn->SetGeomType( szType );    S2I* poHeadersNew  = *ppoHeadersNew;    for (S2I::iterator i=poHeaders->begin(); i!=poHeaders->end(); i++) {                OGRSOSIDataType* poType = SOSIGetType(i->first);                OGRSOSISimpleDataType* poElements = poType->getElements();                for (int k=0; k<poType->getElementCount(); k++) {                    if (strcmp(poElements[k].GetName(),"")==0) continue;                    OGRFieldDefn oFieldTemplate( poElements[k].GetName(), poElements[k].GetType() );                    (*poHeadersNew)[CPLString(poElements[k].GetName())] = poFeatureDefn->GetFieldCount();                    poFeatureDefn->AddFieldDefn( &oFieldTemplate );                }    }    return poFeatureDefn;}

bool wxGISDataset::Rename(const wxString &sNewName, ITrackCancel* const pTrackCancel){	wxCriticalSectionLocker locker(m_CritSect);    Close();    CPLString szDirPath = CPLGetPath(m_sPath);    CPLString szName = CPLGetBasename(m_sPath);	CPLString szNewName(ClearExt(sNewName).mb_str(wxConvUTF8));    char** papszFileList = GetFileList();    papszFileList = CSLAddString( papszFileList, m_sPath );    if(!papszFileList)        {        if(pTrackCancel)            pTrackCancel->PutMessage(_("No files to rename"), wxNOT_FOUND, enumGISMessageErr);        return false;    }    char **papszNewFileList = NULL;    for(int i = 0; papszFileList[i] != NULL; ++i )    {        CPLString szNewPath(CPLFormFilename(szDirPath, szNewName, GetExtension(papszFileList[i], szName)));        papszNewFileList = CSLAddString(papszNewFileList, szNewPath);        if(!RenameFile(papszFileList[i], papszNewFileList[i], pTrackCancel))        {            // Try to put the ones we moved back.            for( --i; i >= 0; i-- )                RenameFile( papszNewFileList[i], papszFileList[i]); 			CSLDestroy( papszFileList );			CSLDestroy( papszNewFileList );            return false;        }    }	m_sPath = CPLString(CPLFormFilename(szDirPath, szNewName, CPLGetExtension(m_sPath)));	CSLDestroy( papszFileList );	CSLDestroy( papszNewFileList );	return true;}

int GDALDefaultOverviews::GetMaskFlags( int nBand ){/* -------------------------------------------------------------------- *//*      Fetch this band's metadata entry.  They are of the form:        *//*        INTERNAL_MASK_FLAGS_n: flags                                  *//* -------------------------------------------------------------------- */    if( !HaveMaskFile() )        return 0;    const char *pszValue =        poMaskDS->GetMetadataItem(            CPLString().Printf( "INTERNAL_MASK_FLAGS_%d", MAX(nBand,1)) );    if( pszValue == NULL )        return 0x8000;    return atoi(pszValue);}

bool ConnectionFactory::createRemoteConnection(const enum ngsCatalogObjectType type,                                               const std::string &path,                                               const Options &options){    switch(type) {    case CAT_CONTAINER_NGW:    {        std::string url = options.asString(KEY_URL);        if(url.empty()) {            return errorMessage(_("Missing required option 'url'"));        }        std::string login = options.asString(KEY_LOGIN);        if(login.empty()) {            login = "guest";        }        else {            std::string oldLogin(login);            login = CPLString(login).Trim();            if(!compare(oldLogin, login, true)) {                warningMessage("Login was trimmed!");            }        }        std::string password = options.asString(KEY_PASSWORD);        bool isGuest = options.asBool(KEY_IS_GUEST);        CPLJSONDocument connectionFile;        CPLJSONObject root = connectionFile.GetRoot();        root.Add(KEY_TYPE, type);        root.Add(KEY_URL, url);        root.Add(KEY_LOGIN, login);        root.Add(KEY_IS_GUEST, isGuest);        if(!password.empty()) {            root.Add(KEY_PASSWORD, encrypt(password));        }        return connectionFile.Save(path);    }    default:        return errorMessage(_("Unsupported connection type %d"), type);    }}