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