/*!
\brief Load data block definitions (&B)
Call VFKReader::OpenFile() before this function.
\return number of data blocks or -1 on error
*/
int VFKReaderSQLite::ReadDataBlocks()
{
int nDataBlocks = -1;
CPLString osSQL;
const char *pszName, *pszDefn;
IVFKDataBlock *poNewDataBlock;
sqlite3_stmt *hStmt;
osSQL.Printf("SELECT table_name, table_defn FROM %s", VFK_DB_TABLE);
hStmt = PrepareStatement(osSQL.c_str());
while(ExecuteSQL(hStmt) == OGRERR_NONE) {
pszName = (const char*) sqlite3_column_text(hStmt, 0);
pszDefn = (const char*) sqlite3_column_text(hStmt, 1);
poNewDataBlock = (IVFKDataBlock *) CreateDataBlock(pszName);
poNewDataBlock->SetGeometryType();
poNewDataBlock->SetProperties(pszDefn);
VFKReader::AddDataBlock(poNewDataBlock, NULL);
}
if (m_nDataBlockCount == 0) {
CPL_IGNORE_RET_VAL(sqlite3_exec(m_poDB, "BEGIN", NULL, NULL, NULL));
/* CREATE TABLE ... */
nDataBlocks = VFKReader::ReadDataBlocks();
CPL_IGNORE_RET_VAL(sqlite3_exec(m_poDB, "COMMIT", NULL, NULL, NULL));
StoreInfo2DB();
}
return nDataBlocks;
}
int main(int argc, char* argv[])
{
CPLJoinableThread* hThread;
printf("main thread %p\n", (void*)CPLGetPID());
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
CPLSetConfigOption("GDAL_CACHEMAX", "0");
CPLSetConfigOption("GDAL_DEBUG_BLOCK_CACHE", "ON");
MyDataset* poDS = new MyDataset();
char buf1[] = { 1 } ;
CPL_IGNORE_RET_VAL(GDALRasterIO(GDALGetRasterBand(poDS, 1), GF_Write, 0, 0, 1, 1, buf1, 1, 1, GDT_Byte, 0, 0));
hThread = CPLCreateJoinableThread(thread_func, NULL);
CPLSleep(0.3);
CPL_IGNORE_RET_VAL(GDALRasterIO(GDALGetRasterBand(poDS, 1), GF_Write, 1, 0, 1, 1, buf1, 1, 1, GDT_Byte, 0, 0));
GDALFlushCacheBlock();
CPLJoinThread(hThread);
delete poDS;
GDALDestroyDriverManager();
CSLDestroy( argv );
return 0;
}
CPLErr CTable2Dataset::SetGeoTransform( double * padfTransform )
{
if( eAccess == GA_ReadOnly )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Unable to update geotransform on readonly file." );
return CE_Failure;
}
if( padfTransform[2] != 0.0 || padfTransform[4] != 0.0 )
{
CPLError(
CE_Failure, CPLE_AppDefined,
"Rotated and sheared geotransforms not supported for CTable2." );
return CE_Failure;
}
memcpy( adfGeoTransform, padfTransform, sizeof(double)*6 );
/* -------------------------------------------------------------------- */
/* Update grid header. */
/* -------------------------------------------------------------------- */
const double dfDegToRad = M_PI / 180.0;
// read grid header
CPL_IGNORE_RET_VAL(VSIFSeekL( fpImage, 0, SEEK_SET ));
char achHeader[160] = { '\0' };
CPL_IGNORE_RET_VAL(VSIFReadL( achHeader, 1, sizeof(achHeader), fpImage ));
// lower left origin (longitude, center of pixel, radians)
double dfValue = (adfGeoTransform[0] + adfGeoTransform[1]*0.5) * dfDegToRad;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 96, &dfValue, 8 );
// lower left origin (latitude, center of pixel, radians)
dfValue = (adfGeoTransform[3] + adfGeoTransform[5] * (nRasterYSize-0.5))
* dfDegToRad;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 104, &dfValue, 8 );
// pixel width (radians)
dfValue = adfGeoTransform[1] * dfDegToRad;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 112, &dfValue, 8 );
// pixel height (radians)
dfValue = adfGeoTransform[5] * -1 * dfDegToRad;
CPL_LSBPTR64( &dfValue );
memcpy( achHeader + 120, &dfValue, 8 );
// write grid header.
CPL_IGNORE_RET_VAL(VSIFSeekL( fpImage, 0, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFWriteL( achHeader, 11, 16, fpImage ));
return CE_None;
}
void OGRBNALayer::WriteCoord(VSILFILE* fp, double dfX, double dfY)
{
char szBuffer[64];
OGRFormatDouble(szBuffer, sizeof(szBuffer), dfX, '.', poDS->GetCoordinatePrecision());
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "%s", szBuffer));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "%s", poDS->GetCoordinateSeparator()));
OGRFormatDouble(szBuffer, sizeof(szBuffer), dfY, '.', poDS->GetCoordinatePrecision());
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "%s", szBuffer));
}
FASTDataset::~FASTDataset()
{
FlushCache();
CPLFree( pszDirname );
CPLFree( pszProjection );
for ( int i = 0; i < nBands; i++ )
if ( fpChannels[i] )
CPL_IGNORE_RET_VAL(VSIFCloseL( fpChannels[i] ));
if( fpHeader != NULL )
CPL_IGNORE_RET_VAL(VSIFCloseL( fpHeader ));
}
void BTDataset::FlushCache()
{
GDALDataset::FlushCache();
if( !bHeaderModified )
return;
bHeaderModified = FALSE;
CPL_IGNORE_RET_VAL(VSIFSeekL( fpImage, 0, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFWriteL( abyHeader, 256, 1, fpImage ));
}
JDEMDataset::~JDEMDataset()
{
FlushCache();
if( fp != NULL )
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
}
GSCDataset::~GSCDataset()
{
FlushCache();
if( fpImage != NULL )
CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage ));
}
static int ReadInt( VSILFILE *fp )
{
char c;
int nRead = 0;
char szBuffer[12];
bool bInProlog = true;
while( true )
{
if (VSIFReadL(&c, 1, 1, fp) != 1)
{
return 0;
}
if( bInProlog )
{
if ( !isspace( static_cast<int>(c) ) )
{
bInProlog = false;
}
}
if( !bInProlog )
{
if( c != '-' && c != '+' && !(c >= '0' && c <= '9') )
{
CPL_IGNORE_RET_VAL(VSIFSeekL(fp, VSIFTellL(fp) - 1, SEEK_SET));
break;
}
if( nRead < 11 )
szBuffer[nRead] = c;
nRead ++;
}
}
szBuffer[std::min(nRead, 11)] = 0;
return atoi(szBuffer);
}
static CPLErr PAuxDelete( const char * pszBasename )
{
VSILFILE *fp = VSIFOpenL( CPLResetExtension( pszBasename, "aux" ), "r" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset, there is no .aux file.",
pszBasename );
return CE_Failure;
}
const char *pszLine = CPLReadLineL( fp );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
if( pszLine == NULL || !STARTS_WITH_CI(pszLine, "AuxilaryTarget") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset,\n"
"the .aux file does not start with AuxilaryTarget",
pszBasename );
return CE_Failure;
}
if( VSIUnlink( pszBasename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"OS unlinking file %s.", pszBasename );
return CE_Failure;
}
VSIUnlink( CPLResetExtension( pszBasename, "aux" ) );
return CE_None;
}
CPLErr JDEMRasterBand::IReadBlock( CPL_UNUSED int nBlockXOff,
int nBlockYOff,
void * pImage )
{
JDEMDataset *poGDS = static_cast<JDEMDataset *>(poDS);
if (pszRecord == nullptr)
{
if (bBufferAllocFailed)
return CE_Failure;
pszRecord = static_cast<char *>(VSI_MALLOC_VERBOSE(nRecordSize));
if (pszRecord == nullptr)
{
bBufferAllocFailed = true;
return CE_Failure;
}
}
CPL_IGNORE_RET_VAL(
VSIFSeekL(poGDS->fp, 1011 + nRecordSize * nBlockYOff, SEEK_SET));
CPL_IGNORE_RET_VAL(VSIFReadL(pszRecord, 1, nRecordSize, poGDS->fp));
if( !EQUALN(reinterpret_cast<char *>(poGDS->abyHeader), pszRecord, 6) )
{
CPLError(CE_Failure, CPLE_AppDefined,
"JDEM Scanline corrupt. Perhaps file was not transferred "
"in binary mode?");
return CE_Failure;
}
if( JDEMGetField(pszRecord + 6, 3) != nBlockYOff + 1 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"JDEM scanline out of order, JDEM driver does not "
"currently support partial datasets.");
return CE_Failure;
}
for( int i = 0; i < nBlockXSize; i++ )
static_cast<float *>(pImage)[i] =
JDEMGetField(pszRecord + 9 + 5 * i, 5) * 0.1f;
return CE_None;
}
DOQ1Dataset::~DOQ1Dataset()
{
FlushCache();
CPLFree( pszProjection );
if( fpImage != NULL )
CPL_IGNORE_RET_VAL(VSIFCloseL( fpImage ));
}
USGSDEMDataset::~USGSDEMDataset()
{
FlushCache();
CPLFree( pszProjection );
if( fp != nullptr )
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
}
static void GDALWriteIMDMultiLine( VSILFILE *fp, const char *pszValue )
{
char **papszItems = CSLTokenizeStringComplex( pszValue, "(,) ",
FALSE, FALSE );
const int nItemCount = CSLCount(papszItems);
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "(\n" ));
for( int i = 0; i < nItemCount; i++ )
{
if( i == nItemCount-1 )
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "\t%s );\n", papszItems[i] ));
else
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "\t%s,\n", papszItems[i] ));
}
CSLDestroy( papszItems );
}
GDALDataset *JDEMDataset::Open( GDALOpenInfo *poOpenInfo )
{
// Confirm that the header is compatible with a JDEM dataset.
if (!Identify(poOpenInfo))
return nullptr;
// Confirm the requested access is supported.
if( poOpenInfo->eAccess == GA_Update )
{
CPLError(CE_Failure, CPLE_NotSupported,
"The JDEM driver does not support update access to existing "
"datasets.");
return nullptr;
}
// Check that the file pointer from GDALOpenInfo* is available.
if( poOpenInfo->fpL == nullptr )
{
return nullptr;
}
// Create a corresponding GDALDataset.
JDEMDataset *poDS = new JDEMDataset();
// Borrow the file pointer from GDALOpenInfo*.
poDS->fp = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
// Read the header.
CPL_IGNORE_RET_VAL(VSIFReadL(poDS->abyHeader, 1, 1012, poDS->fp));
const char *psHeader = reinterpret_cast<char *>(poDS->abyHeader);
poDS->nRasterXSize = JDEMGetField(psHeader + 23, 3);
poDS->nRasterYSize = JDEMGetField(psHeader + 26, 3);
if( poDS->nRasterXSize <= 0 || poDS->nRasterYSize <= 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Invalid dimensions : %d x %d",
poDS->nRasterXSize, poDS->nRasterYSize);
delete poDS;
return nullptr;
}
// Create band information objects.
poDS->SetBand(1, new JDEMRasterBand(poDS, 1));
// Initialize any PAM information.
poDS->SetDescription(poOpenInfo->pszFilename);
poDS->TryLoadXML();
// Check for overviews.
poDS->oOvManager.Initialize(poDS, poOpenInfo->pszFilename);
return poDS;
}
void HFADictionary::Dump( FILE * fp )
{
CPL_IGNORE_RET_VAL(VSIFPrintf( fp, "\nHFADictionary:\n" ));
for( int i = 0; i < nTypes; i++ )
{
papoTypes[i]->Dump( fp );
}
}
void OGRBNALayer::ResetReading()
{
if( fpBNA == NULL )
return;
eof = FALSE;
failed = FALSE;
curLine = 0;
nNextFID = 0;
CPL_IGNORE_RET_VAL(VSIFSeekL( fpBNA, 0, SEEK_SET ));
}
static toff_t
_tiffSizeProc(thandle_t th)
{
GDALTiffHandle* psGTH = (GDALTiffHandle*) th;
vsi_l_offset old_off;
toff_t file_size;
if( psGTH->bAtEndOfFile )
{
return (toff_t) psGTH->nExpectedPos;
}
old_off = VSIFTellL( psGTH->fpL );
CPL_IGNORE_RET_VAL(VSIFSeekL( psGTH->fpL, 0, SEEK_END ));
file_size = (toff_t) VSIFTellL( psGTH->fpL );
CPL_IGNORE_RET_VAL(VSIFSeekL( psGTH->fpL, old_off, SEEK_SET ));
return file_size;
}
CPLErr LANDataset::SetGeoTransform( double * padfTransform )
{
unsigned char abyHeader[128] = { '\0' };
memcpy( adfGeoTransform, padfTransform, sizeof(double) * 6 );
CPL_IGNORE_RET_VAL(VSIFSeekL( fpImage, 0, SEEK_SET ));
CPL_IGNORE_RET_VAL(VSIFReadL( abyHeader, 128, 1, fpImage ));
// Upper Left X.
float f32Val = static_cast<float>(
adfGeoTransform[0] + 0.5 * adfGeoTransform[1] );
memcpy( abyHeader + 112, &f32Val, 4 );
// Upper Left Y.
f32Val = static_cast<float>(
adfGeoTransform[3] + 0.5 * adfGeoTransform[5] );
memcpy( abyHeader + 116, &f32Val, 4 );
// Width of pixel.
f32Val = static_cast<float>( adfGeoTransform[1] );
memcpy( abyHeader + 120, &f32Val, 4 );
// Height of pixel.
f32Val = static_cast<float>( std::abs( adfGeoTransform[5] ) );
memcpy( abyHeader + 124, &f32Val, 4 );
if( VSIFSeekL( fpImage, 0, SEEK_SET ) != 0
|| VSIFWriteL( abyHeader, 128, 1, fpImage ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"File IO Error writing header with new geotransform." );
return CE_Failure;
}
return CE_None;
}
HDF5ImageRasterBand::HDF5ImageRasterBand( HDF5ImageDataset *poDSIn, int nBandIn,
GDALDataType eType ) :
bNoDataSet(false),
dfNoDataValue(-9999.0)
{
poDS = poDSIn;
nBand = nBandIn;
eDataType = eType;
nBlockXSize = poDS->GetRasterXSize( );
nBlockYSize = 1;
/* -------------------------------------------------------------------- */
/* Take a copy of Global Metadata since I can't pass Raster */
/* variable to Iterate function. */
/* -------------------------------------------------------------------- */
char **papszMetaGlobal = CSLDuplicate( poDSIn->papszMetadata );
CSLDestroy( poDSIn->papszMetadata );
poDSIn->papszMetadata = NULL;
if( poDSIn->poH5Objects->nType == H5G_DATASET ) {
poDSIn->CreateMetadata( poDSIn->poH5Objects, H5G_DATASET );
}
/* -------------------------------------------------------------------- */
/* Recover Global Metadata and set Band Metadata */
/* -------------------------------------------------------------------- */
SetMetadata( poDSIn->papszMetadata );
CSLDestroy( poDSIn->papszMetadata );
poDSIn->papszMetadata = CSLDuplicate( papszMetaGlobal );
CSLDestroy( papszMetaGlobal );
/* check for chunksize and set it as the blocksize (optimizes read) */
const hid_t listid = H5Dget_create_plist(poDSIn->dataset_id);
if (listid>0)
{
if(H5Pget_layout(listid) == H5D_CHUNKED)
{
hsize_t panChunkDims[3] = {0, 0, 0};
const int nDimSize = H5Pget_chunk(listid, 3, panChunkDims);
CPL_IGNORE_RET_VAL(nDimSize);
CPLAssert(nDimSize == poDSIn->ndims);
nBlockXSize = (int) panChunkDims[poDSIn->GetXIndex()];
nBlockYSize = (int) panChunkDims[poDSIn->GetYIndex()];
}
H5Pclose(listid);
}
}
void OGRBNALayer::WriteFeatureAttributes(VSILFILE* fp, OGRFeature *poFeature )
{
OGRFieldDefn *poFieldDefn;
int nbOutID = poDS->GetNbOutId();
if (nbOutID < 0)
nbOutID = poFeatureDefn->GetFieldCount();
for(int i = 0; i < nbOutID; i++ )
{
if (i < poFeatureDefn->GetFieldCount())
{
poFieldDefn = poFeatureDefn->GetFieldDefn( i );
if( poFeature->IsFieldSet( i ) )
{
if (poFieldDefn->GetType() == OFTReal)
{
char szBuffer[64];
OGRFormatDouble(szBuffer, sizeof(szBuffer),
poFeature->GetFieldAsDouble(i), '.');
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "\"%s\",", szBuffer));
}
else
{
const char *pszRaw = poFeature->GetFieldAsString( i );
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "\"%s\",", pszRaw));
}
}
else
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "\"\","));
}
}
else
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "\"\","));
}
}
}
static void USGSDEMSetCurrentFilePos( Buffer* psBuffer, vsi_l_offset nNewPos )
{
vsi_l_offset nCurPosFP = VSIFTellL(psBuffer->fp);
if( nNewPos >= nCurPosFP - psBuffer->buffer_size && nNewPos < nCurPosFP )
{
psBuffer->cur_index =
static_cast<int>(nNewPos - (nCurPosFP - psBuffer->buffer_size));
}
else
{
CPL_IGNORE_RET_VAL( VSIFSeekL(psBuffer->fp, nNewPos, SEEK_SET) );
psBuffer->buffer_size = 0;
psBuffer->cur_index = 0;
}
}
static double DConvert( VSILFILE *fp, int nCharCount )
{
char szBuffer[100];
CPL_IGNORE_RET_VAL(VSIFReadL( szBuffer, nCharCount, 1, fp ));
szBuffer[nCharCount] = '\0';
for( int i = 0; i < nCharCount; i++ )
{
if( szBuffer[i] == 'D' )
szBuffer[i] = 'E';
}
return CPLAtof(szBuffer);
}
static void ReadRaster(GDALDataset* poDS, int nXSize, int nYSize, int nBands,
GByte* pBuffer, int nXOff, int nYOff, int nXWin, int nYWin)
{
CPL_IGNORE_RET_VAL(poDS->RasterIO(GF_Read, nXOff, nYOff, nXWin, nYWin,
pBuffer, nXWin, nYWin,
GDT_Byte,
nBands, NULL,
0, 0, 0
#ifdef GDAL_COMPILATION
, NULL
#endif
));
if( bCheck )
{
Check(pBuffer, nXSize, nYSize, nBands,
nXOff, nYOff, nXWin, nYWin);
}
}
void DDFModule::Close()
{
/* -------------------------------------------------------------------- */
/* Close the file. */
/* -------------------------------------------------------------------- */
if( fpDDF != NULL )
{
CPL_IGNORE_RET_VAL(VSIFCloseL( fpDDF ));
fpDDF = NULL;
}
/* -------------------------------------------------------------------- */
/* Cleanup the working record. */
/* -------------------------------------------------------------------- */
if( poRecord != NULL )
{
delete poRecord;
poRecord = NULL;
}
/* -------------------------------------------------------------------- */
/* Cleanup the clones. */
/* -------------------------------------------------------------------- */
for( int i = 0; i < nCloneCount; i++ )
{
papoClones[i]->RemoveIsCloneFlag();
delete papoClones[i];
}
nCloneCount = 0;
nMaxCloneCount = 0;
CPLFree( papoClones );
papoClones = NULL;
/* -------------------------------------------------------------------- */
/* Cleanup the field definitions. */
/* -------------------------------------------------------------------- */
for( int i = 0; i < nFieldDefnCount; i++ )
delete papoFieldDefns[i];
CPLFree( papoFieldDefns );
papoFieldDefns = NULL;
nFieldDefnCount = 0;
}
CPLErr GNMGenericNetwork::DisconnectAll()
{
if(!m_bIsGraphLoaded && LoadGraph() != CE_None)
{
return CE_Failure;
}
// delete everything from m_pGraphLayer
OGRFeature *poFeature;
m_poGraphLayer->ResetReading();
while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL)
{
CPL_IGNORE_RET_VAL(m_poGraphLayer->DeleteFeature(poFeature->GetFID()));
OGRFeature::DestroyFeature( poFeature );
}
m_oGraph.Clear();
return CE_None;
}
int CPLSpawn(const char * const papszArgv[], VSILFILE* fin, VSILFILE* fout,
int bDisplayErr)
{
CPLSpawnedProcess* sp = CPLSpawnAsync(NULL, papszArgv, TRUE, TRUE, TRUE, NULL);
if( sp == NULL )
return -1;
CPL_FILE_HANDLE in_child = CPLSpawnAsyncGetOutputFileHandle(sp);
if (fin != NULL)
FillPipeFromFile(fin, in_child);
CPLSpawnAsyncCloseOutputFileHandle(sp);
CPL_FILE_HANDLE out_child = CPLSpawnAsyncGetInputFileHandle(sp);
if (fout != NULL)
FillFileFromPipe(out_child, fout);
CPLSpawnAsyncCloseInputFileHandle(sp);
CPL_FILE_HANDLE err_child = CPLSpawnAsyncGetErrorFileHandle(sp);
CPLString osName;
osName.Printf("/vsimem/child_stderr_" CPL_FRMT_GIB, CPLGetPID());
VSILFILE* ferr = VSIFOpenL(osName.c_str(), "w");
FillFileFromPipe(err_child, ferr);
CPLSpawnAsyncCloseErrorFileHandle(sp);
CPL_IGNORE_RET_VAL(VSIFCloseL(ferr));
vsi_l_offset nDataLength = 0;
GByte* pData = VSIGetMemFileBuffer(osName.c_str(), &nDataLength, TRUE);
if( nDataLength > 0 )
pData[nDataLength-1] = '\0';
if( pData && strstr(
const_cast<const char *>( reinterpret_cast<char *>( pData ) ),
"An error occurred while forking process") != NULL )
bDisplayErr = TRUE;
if( pData && bDisplayErr )
CPLError(CE_Failure, CPLE_AppDefined, "[%s error] %s", papszArgv[0], pData);
CPLFree(pData);
return CPLSpawnAsyncFinish(sp, TRUE, FALSE);
}
/**
* GDALCheckFileHeader()
*/
bool GDALCheckFileHeader(const CPLString& soFilePath,
const char * pszTestString, int nBufferSize)
{
VSILFILE* fpL = VSIFOpenL( soFilePath, "r" );
if( fpL == NULL )
return false;
char *pBuffer = new char[nBufferSize + 1];
pBuffer[nBufferSize] = '\0';
const int nReadBytes = static_cast<int>(
VSIFReadL( pBuffer, 1, nBufferSize, fpL ) );
CPL_IGNORE_RET_VAL(VSIFCloseL(fpL));
if(nReadBytes == 0)
{
delete [] pBuffer;
return false;
}
const bool bResult = strstr(pBuffer, pszTestString) != NULL;
delete [] pBuffer;
return bResult;
}
CPLErr GNMGenericNetwork::DeleteAllRules()
{
CPLString soFilter;
soFilter.Printf("%s LIKE '%s%%'", GNM_SYSFIELD_PARAMNAME, GNM_MD_RULE);
m_poMetadataLayer->SetAttributeFilter(soFilter);
m_poMetadataLayer->ResetReading();
OGRFeature *poFeature;
std::vector<GIntBig> aFIDs;
while((poFeature = m_poMetadataLayer->GetNextFeature()) != NULL)
{
aFIDs.push_back(poFeature->GetFID());
OGRFeature::DestroyFeature(poFeature);
}
m_poMetadataLayer->SetAttributeFilter(NULL);
for(size_t i = 0; i < aFIDs.size(); ++i)
{
CPL_IGNORE_RET_VAL(m_poMetadataLayer->DeleteFeature(aFIDs[i]));
}
return CE_None;
}
static
char* CPLLoadContentFromFile(const char* pszFilename)
{
VSILFILE* fp = VSIFOpenL(pszFilename, "rb");
if (fp == NULL)
return NULL;
vsi_l_offset nSize;
if( VSIFSeekL(fp, 0, SEEK_END) != 0 )
{
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
nSize = VSIFTellL(fp);
if( VSIFSeekL(fp, 0, SEEK_SET) != 0 )
{
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
if ((vsi_l_offset)(int)nSize != nSize ||
nSize > INT_MAX - 1 )
{
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
char* pszBuffer = (char*)VSIMalloc((size_t)nSize + 1);
if (pszBuffer == NULL)
{
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
if( (size_t)VSIFReadL(pszBuffer, 1, (size_t)nSize, fp) != (size_t)nSize )
{
VSIFree(pszBuffer);
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
pszBuffer[nSize] = '\0';
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return pszBuffer;
}
