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

int OGRMDBDataSource::Open( const char * pszNewName, int bUpdate,                              int bTestOpen ){    CPLAssert( nLayers == 0 );    pszName = CPLStrdup( pszNewName );    if (!env.Init())        return FALSE;    poDB = OGRMDBDatabase::Open(&env, pszNewName);    if (!poDB)        return FALSE;    poDB->FetchTableNames();    /* Is it a ESRI Personal Geodatabase ? */    OGRMDBTable* poGDB_GeomColumns = poDB->GetTable("GDB_GeomColumns");    if (poGDB_GeomColumns && !CSLTestBoolean(CPLGetConfigOption("MDB_RAW", "OFF")))    {        int nRet = OpenGDB(poGDB_GeomColumns);        delete poGDB_GeomColumns;        return nRet;    }    delete poGDB_GeomColumns;    /* Is it a Geomedia warehouse ? */    OGRMDBTable* poGAliasTable = poDB->GetTable("GAliasTable");    if (poGAliasTable && !CSLTestBoolean(CPLGetConfigOption("MDB_RAW", "OFF")))    {        int nRet = OpenGeomediaWarehouse(poGAliasTable);        delete poGAliasTable;        return nRet;    }    delete poGAliasTable;    /* Well, no, just a regular MDB */    int nTables = (int) poDB->apoTableNames.size();    for(int i=0;i<nTables;i++)    {        OGRMDBTable* poTable = poDB->GetTable(poDB->apoTableNames[i]);        if (poTable == NULL)            continue;        OGRMDBLayer* poLayer = new OGRMDBLayer( this, poTable );        if( poLayer->BuildFeatureDefn() != CE_None )        {            delete poLayer;            continue;        }        papoLayers = (OGRMDBLayer**)CPLRealloc(papoLayers, (nLayers+1) * sizeof(OGRMDBLayer*));        papoLayers[nLayers++] = poLayer;    }    return TRUE;}

/*!  /brief VFKReaderSQLite constructor*/VFKReaderSQLite::VFKReaderSQLite(const char *pszFilename) : VFKReader(pszFilename){    const char *pszDbNameConf;    CPLString   pszDbName;    CPLString   osCommand;    VSIStatBufL sStatBuf;    bool        bNewDb;        /* open tmp SQLite DB (re-use DB file if already exists) */    pszDbNameConf = CPLGetConfigOption("OGR_VFK_DB_NAME", NULL);    if (pszDbNameConf) {	pszDbName = pszDbNameConf;    }    else {	pszDbName.Printf("%s.db", m_pszFilename);    }        if (CSLTestBoolean(CPLGetConfigOption("OGR_VFK_DB_SPATIAL", "YES")))	m_bSpatial = TRUE;    /* build geometry from DB */    else	m_bSpatial = FALSE;   /* store also geometry in DB */        bNewDb = TRUE;    if (VSIStatL(pszDbName, &sStatBuf ) == 0) {	if (CSLTestBoolean(CPLGetConfigOption("OGR_VFK_DB_OVERWRITE", "NO"))) {	    bNewDb = TRUE;     /* overwrite existing DB */	    VSIUnlink(pszDbName);	}	else {	    bNewDb = FALSE;    /* re-use exising DB */	}    }    else {      	CPLError(CE_Warning, CPLE_AppDefined,                  "SQLite DB not found. Reading VFK data may take some time...");    }    CPLDebug("OGR-VFK", "New DB: %s Spatial: %s",	     bNewDb ? "yes" : "no", m_bSpatial ? "yes" : "no");    if (SQLITE_OK != sqlite3_open(pszDbName, &m_poDB)) {        CPLError(CE_Failure, CPLE_AppDefined,                  "Creating SQLite DB failed");    }    else {        char* pszErrMsg = NULL;        sqlite3_exec(m_poDB, "PRAGMA synchronous = OFF", NULL, NULL, &pszErrMsg);        sqlite3_free(pszErrMsg);    }        if (bNewDb) {        /* new DB, create support metadata tables */        osCommand = "CREATE TABLE 'vfk_blocks' "	  "(file_name text, table_name text, num_records integer, "	    "num_geometries integer, table_defn text)";        ExecuteSQL(osCommand.c_str());    }}

OGRLayer * OGRGPXDataSource::CreateLayer( const char * pszLayerName,                                          OGRSpatialReference *poSRS,                                          OGRwkbGeometryType eType,                                          char ** papszOptions ){    GPXGeometryType gpxGeomType;    if (eType == wkbPoint || eType == wkbPoint25D)    {        if (EQUAL(pszLayerName, "track_points"))            gpxGeomType = GPX_TRACK_POINT;        else if (EQUAL(pszLayerName, "route_points"))            gpxGeomType = GPX_ROUTE_POINT;        else            gpxGeomType = GPX_WPT;    }    else if (eType == wkbLineString || eType == wkbLineString25D)    {        const char *pszForceGPXTrack = CSLFetchNameValue( papszOptions, "FORCE_GPX_TRACK");        if (pszForceGPXTrack && CSLTestBoolean(pszForceGPXTrack))            gpxGeomType = GPX_TRACK;        else            gpxGeomType = GPX_ROUTE;    }    else if (eType == wkbMultiLineString || eType == wkbMultiLineString25D)    {        const char *pszForceGPXRoute = CSLFetchNameValue( papszOptions, "FORCE_GPX_ROUTE");        if (pszForceGPXRoute && CSLTestBoolean(pszForceGPXRoute))            gpxGeomType = GPX_ROUTE;        else            gpxGeomType = GPX_TRACK;    }    else if (eType == wkbUnknown)    {        CPLError(CE_Failure, CPLE_NotSupported,                 "Cannot create GPX layer %s with unknown geometry type", pszLayerName);        return NULL;    }    else    {        CPLError( CE_Failure, CPLE_NotSupported,                    "Geometry type of `%s' not supported in GPX./n",                    OGRGeometryTypeToName(eType) );        return NULL;    }    nLayers++;    papoLayers = (OGRGPXLayer **) CPLRealloc(papoLayers, nLayers * sizeof(OGRGPXLayer*));    papoLayers[nLayers-1] = new OGRGPXLayer( pszName, pszLayerName, gpxGeomType, this, TRUE );        return papoLayers[nLayers-1];}

FILE *VSIFOpen( const char * pszFilename, const char * pszAccess ){    FILE *fp = NULL;    int     nError;#if defined(WIN32) && !defined(WIN32CE)    if( CSLTestBoolean(            CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )    {        wchar_t *pwszFilename =             CPLRecodeToWChar( pszFilename, CPL_ENC_UTF8, CPL_ENC_UCS2 );        wchar_t *pwszAccess =             CPLRecodeToWChar( pszAccess, CPL_ENC_UTF8, CPL_ENC_UCS2 );        fp = _wfopen( pwszFilename, pwszAccess );        CPLFree( pwszFilename );        CPLFree( pwszAccess );    }    else#endif    fp = fopen( (char *) pszFilename, (char *) pszAccess );    nError = errno;    VSIDebug3( "VSIFOpen(%s,%s) = %p", pszFilename, pszAccess, fp );    errno = nError;    return( fp );}

VSIVirtualHandle* VSICurlStreamingFSHandler::Open( const char *pszFilename,                                                   const char *pszAccess ){    if (strchr(pszAccess, 'w') != NULL ||        strchr(pszAccess, '+') != NULL)    {        CPLError(CE_Failure, CPLE_AppDefined,                 "Only read-only mode is supported for /vsicurl_streaming");        return NULL;    }    VSICurlStreamingHandle* poHandle = new VSICurlStreamingHandle(        this, pszFilename + strlen("/vsicurl_streaming/"));    /* If we didn't get a filelist, check that the file really exists */    if (!poHandle->Exists())    {        delete poHandle;        poHandle = NULL;    }    if( CSLTestBoolean( CPLGetConfigOption( "VSI_CACHE", "FALSE" ) ) )        return VSICreateCachedFile( poHandle );    else        return poHandle;}

char* OGRGetXML_UTF8_EscapedString(const char* pszString){    char *pszEscaped;    if (!CPLIsUTF8(pszString, -1) &&         CSLTestBoolean(CPLGetConfigOption("OGR_FORCE_ASCII", "YES")))    {        static int bFirstTime = TRUE;        if (bFirstTime)        {            bFirstTime = FALSE;            CPLError(CE_Warning, CPLE_AppDefined,                    "%s is not a valid UTF-8 string. Forcing it to ASCII./n"                    "If you still want the original string and change the XML file encoding/n"                    "afterwards, you can define OGR_FORCE_ASCII=NO as configuration option./n"                    "This warning won't be issued anymore", pszString);        }        else        {            CPLDebug("OGR", "%s is not a valid UTF-8 string. Forcing it to ASCII",                    pszString);        }        char* pszTemp = CPLForceToASCII(pszString, -1, '?');        pszEscaped = CPLEscapeString( pszTemp, -1, CPLES_XML );        CPLFree(pszTemp);    }    else        pszEscaped = CPLEscapeString( pszString, -1, CPLES_XML );    return pszEscaped;}

VSIVirtualHandle *VSIUnixStdioFilesystemHandler::Open( const char *pszFilename,                                      const char *pszAccess ){    FILE    *fp = VSI_FOPEN64( pszFilename, pszAccess );    int     nError = errno;        VSIDebug3( "VSIUnixStdioFilesystemHandler::Open(/"%s/",/"%s/") = %p",               pszFilename, pszAccess, fp );    if( fp == NULL )    {        errno = nError;        return NULL;    }    VSIUnixStdioHandle *poHandle = new VSIUnixStdioHandle(this, fp);    errno = nError;/* -------------------------------------------------------------------- *//*      If VSI_CACHE is set we want to use a cached reader instead      *//*      of more direct io on the underlying file.                       *//* -------------------------------------------------------------------- */    if( (EQUAL(pszAccess,"r") || EQUAL(pszAccess,"rb"))        && CSLTestBoolean( CPLGetConfigOption( "VSI_CACHE", "FALSE" ) ) )    {        return VSICreateCachedFile( poHandle );    }    else    {        return poHandle;    }}

void OGRSXFDataSource::SetVertCS(const long iVCS, SXFPassport& passport){    if (!CSLTestBoolean(CPLGetConfigOption("SXF_SET_VERTCS", "NO")))        return;    const long nEPSG = aoVCS[iVCS];    if (nEPSG == 0)    {        CPLError(CE_Warning, CPLE_NotSupported, "SXF. Vertical coordinate system (SXF index %ld) not supported", iVCS);        return;    }    OGRSpatialReference* sr = new OGRSpatialReference();    OGRErr eImportFromEPSGErr = sr->importFromEPSG(nEPSG);    if (eImportFromEPSGErr != OGRERR_NONE)    {        CPLError( CE_Warning, CPLE_None, "SXF. Vertical coordinate system (SXF index %ld, EPSG %ld) import from EPSG error", iVCS, nEPSG);        return;    }    if (sr->IsVertical() != 1)    {        CPLError( CE_Warning, CPLE_None, "SXF. Coordinate system (SXF index %ld, EPSG %ld) is not Vertical", iVCS, nEPSG);        return;    }    //passport.stMapDescription.pSpatRef->SetVertCS("Baltic", "Baltic Sea");    OGRErr eSetVertCSErr = passport.stMapDescription.pSpatRef->SetVertCS(sr->GetAttrValue("VERT_CS"), sr->GetAttrValue("VERT_DATUM"));    if (eSetVertCSErr != OGRERR_NONE)    {        CPLError(CE_Warning, CPLE_None, "SXF. Vertical coordinate system (SXF index %ld, EPSG %ld) set error", iVCS, nEPSG);        return;    }}

CPLErr GDALDefaultOverviews::CleanOverviews(){    // Anything to do?    if( poODS == NULL )        return CE_None;    // Delete the overview file(s).     GDALDriver *poOvrDriver;    poOvrDriver = poODS->GetDriver();    GDALClose( poODS );    poODS = NULL;    CPLErr eErr;    if( poOvrDriver != NULL )        eErr = poOvrDriver->Delete( osOvrFilename );    else        eErr = CE_None;    // Reset the saved overview filename.     if( !EQUAL(poDS->GetDescription(),":::VIRTUAL:::") )    {        int bUseRRD = CSLTestBoolean(CPLGetConfigOption("USE_RRD","NO"));        if( bUseRRD )            osOvrFilename = CPLResetExtension( poDS->GetDescription(), "aux" );        else            osOvrFilename.Printf( "%s.ovr", poDS->GetDescription() );    }    else        osOvrFilename = "";    return eErr;}

OGRErr OGRPGDumpLayer::CreateFeature( OGRFeature *poFeature ){    if( NULL == poFeature )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "NULL pointer to OGRFeature passed to CreateFeature()." );        return OGRERR_FAILURE;    }    nFeatures ++;    // We avoid testing the config option too often.    if( bUseCopy == USE_COPY_UNSET )        bUseCopy = CSLTestBoolean( CPLGetConfigOption( "PG_USE_COPY", "NO") );    if( !bUseCopy )    {        return CreateFeatureViaInsert( poFeature );    }    else    {        if ( !bCopyActive )        {            /* This is a heuristics. If the first feature to be copied has a */            /* FID set (and that a FID column has been identified), then we will */            /* try to copy FID values from features. Otherwise, we will not */            /* do and assume that the FID column is an autoincremented column. */            StartCopy(poFeature->GetFID() != OGRNullFID);        }        return CreateFeatureViaCopy( poFeature );    }}

int VSIWin32FilesystemHandler::Stat( const char * pszFilename,                                      VSIStatBufL * pStatBuf,                                     int nFlags ){    (void) nFlags;#if (defined(WIN32) && _MSC_VER >= 1310) || __MSVCRT_VERSION__ >= 0x0601    if( CSLTestBoolean(            CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )    {        int nResult;        wchar_t *pwszFilename =             CPLRecodeToWChar( pszFilename, CPL_ENC_UTF8, CPL_ENC_UCS2 );        nResult = _wstat64( pwszFilename, pStatBuf );        CPLFree( pwszFilename );        return nResult;    }    else#endif    {        return( VSI_STAT64( pszFilename, pStatBuf ) );    }}

int OGRGPSBabelWriteDataSource::Create( const char * pszName,                                        char **papszOptions ){    GDALDriver* poGPXDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("GPX");    if (poGPXDriver == NULL)    {        CPLError(CE_Failure, CPLE_AppDefined, "GPX driver is necessary for GPSBabel write support");        return FALSE;    }    if (!EQUALN(pszName, "GPSBABEL:", 9))    {        const char* pszOptionGPSBabelDriverName =                CSLFetchNameValue(papszOptions, "GPSBABEL_DRIVER");        if (pszOptionGPSBabelDriverName != NULL)            pszGPSBabelDriverName = CPLStrdup(pszOptionGPSBabelDriverName);        else        {            CPLError(CE_Failure, CPLE_AppDefined, "GPSBABEL_DRIVER dataset creation option expected");            return FALSE;        }        pszFilename = CPLStrdup(pszName);    }    else    {        const char* pszSep = strchr(pszName + 9, ':');        if (pszSep == NULL)        {            CPLError(CE_Failure, CPLE_AppDefined,                    "Wrong syntax. Expected GPSBabel:driver_name[,options]*:file_name");            return FALSE;        }        pszGPSBabelDriverName = CPLStrdup(pszName + 9);        *(strchr(pszGPSBabelDriverName, ':')) = '/0';        pszFilename = CPLStrdup(pszSep+1);    }    /* A bit of validation to avoid command line injection */    if (!OGRGPSBabelDataSource::IsValidDriverName(pszGPSBabelDriverName))        return FALSE;    const char* pszOptionUseTempFile = CSLFetchNameValue(papszOptions, "USE_TEMPFILE");    if (pszOptionUseTempFile == NULL)        pszOptionUseTempFile = CPLGetConfigOption("USE_TEMPFILE", NULL);    if (pszOptionUseTempFile && CSLTestBoolean(pszOptionUseTempFile))        osTmpFileName = CPLGenerateTempFilename(NULL);    else        osTmpFileName.Printf("/vsimem/ogrgpsbabeldatasource_%p", this);    poGPXDS = poGPXDriver->Create(osTmpFileName.c_str(), 0, 0, 0, GDT_Unknown, papszOptions);    if (poGPXDS == NULL)        return FALSE;    this->pszName = CPLStrdup(pszName);    return TRUE;}

OGRSEGP1Layer::OGRSEGP1Layer( const char* pszFilename,                              VSILFILE* fp,                              int nLatitudeCol ){    this->fp = fp;    this->nLatitudeCol = nLatitudeCol;    nNextFID = 0;    bEOF = FALSE;    poSRS = NULL;    poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );    SetDescription( poFeatureDefn->GetName() );    poFeatureDefn->Reference();    poFeatureDefn->SetGeomType( wkbPoint );    for(int i=0;i<(int)(sizeof(SEGP1Fields)/sizeof(SEGP1Fields[0]));i++)    {        OGRFieldDefn    oField( SEGP1Fields[i].pszName,                                SEGP1Fields[i].eType );        poFeatureDefn->AddFieldDefn( &oField );    }    bUseEastingNorthingAsGeometry =        CSLTestBoolean(CPLGetConfigOption("SEGP1_USE_EASTING_NORTHING", "NO"));    ResetReading();}

staticvoid* OGRSQLiteRegisterRegExpFunction(#ifndef HAVE_PCRECPL_UNUSED#endif                                      sqlite3* hDB){#ifdef HAVE_PCRE    /* For debugging purposes mostly */    if( !CSLTestBoolean(CPLGetConfigOption("OGR_SQLITE_REGEXP", "YES")) )        return NULL;    /* Check if we really need to define our own REGEXP function */    int rc = sqlite3_exec(hDB, "SELECT 'a' REGEXP 'a'", NULL, NULL, NULL);    if( rc == SQLITE_OK )    {        CPLDebug("SQLITE", "REGEXP already available");        return NULL;    }    cache_entry *cache = (cache_entry*) CPLCalloc(CACHE_SIZE, sizeof(cache_entry));    sqlite3_create_function(hDB, "REGEXP", 2, SQLITE_UTF8, cache,                            OGRSQLiteREGEXPFunction, NULL, NULL);    /* To clear the error flag */    sqlite3_exec(hDB, "SELECT 1", NULL, NULL, NULL);    return cache;#else // HAVE_PCRE    return NULL;#endif // HAVE_PCRE}

int VSIWin32FilesystemHandler::Rename( const char *oldpath,                                           const char *newpath ){#if (defined(WIN32) && _MSC_VER >= 1310) || __MSVCRT_VERSION__ >= 0x0601    if( CSLTestBoolean(            CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )    {        int nResult;        wchar_t *pwszOldPath =             CPLRecodeToWChar( oldpath, CPL_ENC_UTF8, CPL_ENC_UCS2 );        wchar_t *pwszNewPath =             CPLRecodeToWChar( newpath, CPL_ENC_UTF8, CPL_ENC_UCS2 );        nResult = _wrename( pwszOldPath, pwszNewPath );        CPLFree( pwszOldPath );        CPLFree( pwszNewPath );        return nResult;    }    else#endif    {        return rename( oldpath, newpath );    }}

FILE *VSIFOpen( const char * pszFilename, const char * pszAccess ){    FILE *fp = NULL;#if defined(WIN32)    if( CSLTestBoolean(            CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )    {        wchar_t *pwszFilename =            CPLRecodeToWChar( pszFilename, CPL_ENC_UTF8, CPL_ENC_UCS2 );        wchar_t *pwszAccess =            CPLRecodeToWChar( pszAccess, CPL_ENC_UTF8, CPL_ENC_UCS2 );        fp = _wfopen( pwszFilename, pwszAccess );        CPLFree( pwszFilename );        CPLFree( pwszAccess );    }    else#endif    fp = fopen( (char *) pszFilename, (char *) pszAccess );#ifdef VSI_DEBUG    // Capture the error from fopen to avoid being overwritten by errors    // from VSIDebug3.    const int nError = errno;    VSIDebug3( "VSIFOpen(%s,%s) = %p", pszFilename, pszAccess, fp );    errno = nError;#endif    return fp;}

OGRErr OGRPGDumpLayer::CreateFeature( OGRFeature *poFeature ){    if( NULL == poFeature )    {        CPLError( CE_Failure, CPLE_AppDefined,                  "NULL pointer to OGRFeature passed to CreateFeature()." );        return OGRERR_FAILURE;    }    nFeatures ++;    // We avoid testing the config option too often.     if( bUseCopy == USE_COPY_UNSET )        bUseCopy = CSLTestBoolean( CPLGetConfigOption( "PG_USE_COPY", "NO") );    if( !bUseCopy )    {        return CreateFeatureViaInsert( poFeature );    }    else    {        if ( !bCopyActive )            StartCopy();        return CreateFeatureViaCopy( poFeature );    }}

int OGRCouchDBDataSource::IsOK(json_object* poAnswerObj,                               const char* pszErrorMsg){    if ( poAnswerObj == NULL ||        !json_object_is_type(poAnswerObj, json_type_object) )    {        CPLError(CE_Failure, CPLE_AppDefined, "%s",                 pszErrorMsg);        return FALSE;    }    json_object* poOK = json_object_object_get(poAnswerObj, "ok");    if ( !poOK )    {        IsError(poAnswerObj, pszErrorMsg);        return FALSE;    }    const char* pszOK = json_object_get_string(poOK);    if ( !pszOK || !CSLTestBoolean(pszOK) )    {        CPLError(CE_Failure, CPLE_AppDefined, "%s", pszErrorMsg);        return FALSE;    }    return TRUE;}

OGRMSSQLSpatialDataSource::OGRMSSQLSpatialDataSource(){    pszName = NULL;    pszCatalog = NULL;    papoLayers = NULL;    nLayers = 0;    nKnownSRID = 0;    panSRID = NULL;    papoSRS = NULL;    nGeometryFormat = MSSQLGEOMETRY_NATIVE;    bUseGeometryColumns = CSLTestBoolean(CPLGetConfigOption("MSSQLSPATIAL_USE_GEOMETRY_COLUMNS", "YES"));    bListAllTables = CSLTestBoolean(CPLGetConfigOption("MSSQLSPATIAL_LIST_ALL_TABLES", "NO"));}

static void GDALDestructor(void){    if( bGDALDestroyAlreadyCalled )        return;    if( !CSLTestBoolean(CPLGetConfigOption("GDAL_DESTROY", "YES")) )        return;    GDALDestroy();}

void VSICurlStreamingHandle::DownloadInThread(){    VSICurlSetOptions(hCurlHandle, pszURL);    static int bHasCheckVersion = FALSE;    static int bSupportGZip = FALSE;    if (!bHasCheckVersion)    {        bSupportGZip = strstr(curl_version(), "zlib/") != NULL;        bHasCheckVersion = TRUE;    }    if (bSupportGZip && CSLTestBoolean(CPLGetConfigOption("CPL_CURL_GZIP", "YES")))    {        curl_easy_setopt(hCurlHandle, CURLOPT_ENCODING, "gzip");    }    if (pabyHeaderData == NULL)        pabyHeaderData = (GByte*) CPLMalloc(HEADER_SIZE + 1);    nHeaderSize = 0;    nBodySize = 0;    nHTTPCode = 0;    curl_easy_setopt(hCurlHandle, CURLOPT_HEADERDATA, this);    curl_easy_setopt(hCurlHandle, CURLOPT_HEADERFUNCTION, VSICurlStreamingHandleReceivedBytesHeader);    curl_easy_setopt(hCurlHandle, CURLOPT_WRITEDATA, this);    curl_easy_setopt(hCurlHandle, CURLOPT_WRITEFUNCTION, VSICurlStreamingHandleReceivedBytes);    char szCurlErrBuf[CURL_ERROR_SIZE+1];    szCurlErrBuf[0] = '/0';    curl_easy_setopt(hCurlHandle, CURLOPT_ERRORBUFFER, szCurlErrBuf );    CURLcode eRet = curl_easy_perform(hCurlHandle);    curl_easy_setopt(hCurlHandle, CURLOPT_WRITEDATA, NULL);    curl_easy_setopt(hCurlHandle, CURLOPT_WRITEFUNCTION, NULL);    curl_easy_setopt(hCurlHandle, CURLOPT_HEADERDATA, NULL);    curl_easy_setopt(hCurlHandle, CURLOPT_HEADERFUNCTION, NULL);    AcquireMutex();    if (!bAskDownloadEnd && eRet == 0 && !bHastComputedFileSize)    {        poFS->AcquireMutex();        CachedFileProp* cachedFileProp = poFS->GetCachedFileProp(pszURL);        cachedFileProp->fileSize = fileSize = nBodySize;        cachedFileProp->bHastComputedFileSize = bHastComputedFileSize = TRUE;        if (ENABLE_DEBUG)            CPLDebug("VSICURL", "File size = " CPL_FRMT_GUIB, fileSize);        poFS->ReleaseMutex();    }    bDownloadInProgress = FALSE;    bDownloadStopped = TRUE;    /* Signal to the consumer that the download has ended */    CPLCondSignal(hCondProducer);    ReleaseMutex();}

void *CPLCreateZip( const char *pszZipFilename, char **papszOptions ){    (void) papszOptions;    int bAppend = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "APPEND", "FALSE"));    return cpl_zipOpen( pszZipFilename, bAppend ? APPEND_STATUS_ADDINZIP : APPEND_STATUS_CREATE);}

/** * /fn OGRwkbGeometryType OGRFeatureDefn::GetGeomType(); * * /brief Fetch the geometry base type. * * Note that some drivers are unable to determine a specific geometry * type for a layer, in which case wkbUnknown is returned.  A value of * wkbNone indicates no geometry is available for the layer at all. * Many drivers do not properly mark the geometry * type as 25D even if some or all geometries are in fact 25D.  A few (broken) * drivers return wkbPolygon for layers that also include wkbMultiPolygon.   * * Starting with GDAL 1.11, this method returns GetGeomFieldDefn(0)->GetType(). * * This method is the same as the C function OGR_FD_GetGeomType(). * * @return the base type for all geometry related to this definition. */OGRwkbGeometryType OGRFeatureDefn::GetGeomType(){    if( GetGeomFieldCount() == 0 )        return wkbNone;    OGRwkbGeometryType eType = GetGeomFieldDefn(0)->GetType();    if( eType == (wkbUnknown | wkb25DBitInternalUse) && CSLTestBoolean(CPLGetConfigOption("QGIS_HACK", "NO")) )        eType = wkbUnknown;    return eType;}

OGRGMLLayer::OGRGMLLayer( const char * pszName,                          int bWriterIn,                          OGRGMLDataSource *poDSIn ){    iNextGMLId = 0;    nTotalGMLCount = -1;    bInvalidFIDFound = FALSE;    pszFIDPrefix = NULL;    bFaceHoleNegative = FALSE;            poDS = poDSIn;    if ( EQUALN(pszName, "ogr:", 4) )      poFeatureDefn = new OGRFeatureDefn( pszName+4 );    else      poFeatureDefn = new OGRFeatureDefn( pszName );    SetDescription( poFeatureDefn->GetName() );    poFeatureDefn->Reference();    poFeatureDefn->SetGeomType( wkbNone );    bWriter = bWriterIn;    bSameSRS = FALSE;/* -------------------------------------------------------------------- *//*      Reader's should get the corresponding GMLFeatureClass and       *//*      cache it.                                                       *//* -------------------------------------------------------------------- */    if( !bWriter )        poFClass = poDS->GetReader()->GetClass( pszName );    else        poFClass = NULL;    hCacheSRS = GML_BuildOGRGeometryFromList_CreateCache();    /* Compatibility option. Not advertized, because hopefully won't be needed */    /* Just put here in provision... */    bUseOldFIDFormat = CSLTestBoolean(CPLGetConfigOption("GML_USE_OLD_FID_FORMAT", "FALSE"));    /* Must be in synced in OGR_G_CreateFromGML(), OGRGMLLayer::OGRGMLLayer() and GMLReader::GMLReader() */    bFaceHoleNegative = CSLTestBoolean(CPLGetConfigOption("GML_FACE_HOLE_NEGATIVE", "NO"));}

int OGRXLSDataSource::Open( const char * pszFilename, int bUpdateIn){    if (bUpdateIn)    {        return FALSE;    }#ifdef _WIN32    if( CSLTestBoolean( 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;}

OGRShapeDataSource::OGRShapeDataSource(){    pszName = NULL;    papoLayers = NULL;    nLayers = 0;    bSingleFileDataSource = FALSE;    poPool = new OGRLayerPool();    b2GBLimit = CSLTestBoolean(CPLGetConfigOption("SHAPE_2GB_LIMIT", "FALSE"));    papszOpenOptions = NULL;}

 bool isEmbedded() {     if (isAssocClass)         for (NodeVector::const_iterator it = oFields.begin(); it != oFields.end(); ++it)         {             if (*it == NULL) continue;             if (CSLTestBoolean(CPLGetXMLValue( *it, "EmbeddedTransfer", "FALSE" )))                 return true;         }     return false; }

OGRLayer * OGRJMLDataset::ICreateLayer( const char * pszLayerName,                                             CPL_UNUSED OGRSpatialReference *poSRS,                                             CPL_UNUSED OGRwkbGeometryType eType,                                             char ** papszOptions ){    if (!bWriteMode || poLayer != NULL)        return NULL;    int bAddRGBField = CSLTestBoolean(        CSLFetchNameValueDef(papszOptions, "CREATE_R_G_B_FIELD", "YES"));    int bAddOGRStyleField = CSLTestBoolean(        CSLFetchNameValueDef(papszOptions, "CREATE_OGR_STYLE_FIELD", "NO"));    int bClassicGML = CSLTestBoolean(        CSLFetchNameValueDef(papszOptions, "CLASSIC_GML", "NO"));    poLayer = new OGRJMLWriterLayer( pszLayerName, this, fp,                                          bAddRGBField, bAddOGRStyleField,                                          bClassicGML);    return poLayer;}