/*! \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; }