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; }
/** * Return the value matching a key from a key=value pair in a URL. * * @param pszURL the URL. * @param pszKey the key to find. * @return the value of empty string if not found. * @since GDAL 1.9.0 */ CPLString CPLURLGetValue(const char* pszURL, const char* pszKey) { CPLString osKey(pszKey); osKey += "="; size_t nKeyPos = CPLString(pszURL).ifind(osKey); if (nKeyPos != std::string::npos) { CPLString osValue(pszURL + nKeyPos + strlen(osKey)); const char* pszValue = osValue.c_str(); const char* pszSep = strchr(pszValue, '&'); if (pszSep) { osValue.resize(pszSep - pszValue); } return osValue; } return ""; }
static OGRFeatureDefn *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 = "******"; } 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); } }