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

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

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