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

OGRGeoJSONSeqWriteLayer::OGRGeoJSONSeqWriteLayer(                                        OGRGeoJSONSeqDataSource* poDS,                                        const char* pszName,                                        CSLConstList papszOptions,                                        OGRCoordinateTransformation* poCT):    m_poDS(poDS){    SetDescription(pszName);    m_poFeatureDefn = new OGRFeatureDefn(pszName);    m_poFeatureDefn->Reference();    m_poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(        OGRSpatialReference::GetWGS84SRS());    m_poCT = poCT;    m_oWriteOptions.SetRFC7946Settings();    m_oWriteOptions.SetIDOptions(papszOptions);    m_oWriteOptions.nCoordPrecision = atoi(        CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "7"));    m_oWriteOptions.nSignificantFigures = atoi(        CSLFetchNameValueDef(papszOptions, "SIGNIFICANT_FIGURES", "-1"));    m_bRS = EQUAL(CPLGetExtension(poDS->GetDescription()), "GEOJSONS");    const char* pszRS = CSLFetchNameValue(papszOptions, "RS");    if( pszRS )    {        m_bRS = CPLTestBool(pszRS);    }}

bool VSIOSSHandleHelper::GetConfiguration(CSLConstList papszOptions,                                          CPLString& osSecretAccessKey,                                          CPLString& osAccessKeyId){    osSecretAccessKey = CSLFetchNameValueDef(papszOptions,        "OSS_SECRET_ACCESS_KEY",        CPLGetConfigOption("OSS_SECRET_ACCESS_KEY", ""));    if( !osSecretAccessKey.empty() )    {        osAccessKeyId = CSLFetchNameValueDef(papszOptions,            "OSS_ACCESS_KEY_ID",            CPLGetConfigOption("OSS_ACCESS_KEY_ID", ""));        if( osAccessKeyId.empty() )        {            VSIError(VSIE_AWSInvalidCredentials,                    "OSS_ACCESS_KEY_ID configuration option not defined");            return false;        }        return true;    }    VSIError(VSIE_AWSInvalidCredentials,                "OSS_SECRET_ACCESS_KEY configuration option not defined");    return false;}

char *OGR_G_ExportToGMLEx( OGRGeometryH hGeometry, char** papszOptions ){    char        *pszText;    int         nLength = 0, nMaxLength = 1;    if( hGeometry == NULL )        return CPLStrdup( "" );    pszText = (char *) CPLMalloc(nMaxLength);    pszText[0] = '/0';    const char* pszFormat = CSLFetchNameValue(papszOptions, "FORMAT");    if (pszFormat && EQUAL(pszFormat, "GML3"))    {        const char* pszLineStringElement = CSLFetchNameValue(papszOptions, "GML3_LINESTRING_ELEMENT");        int bLineStringAsCurve = (pszLineStringElement && EQUAL(pszLineStringElement, "curve"));        int bLongSRS = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "GML3_LONGSRS", "YES"));        const char* pszGMLId = CSLFetchNameValue(papszOptions, "GMLID");        const char* pszSRSDimensionLoc = CSLFetchNameValueDef(papszOptions,"SRSDIMENSION_LOC","POSLIST");        char** papszSRSDimensionLoc = CSLTokenizeString2(pszSRSDimensionLoc, ",", 0);        int nSRSDimensionLocFlags = 0;        for(int i=0; papszSRSDimensionLoc[i] != NULL; i++)        {            if( EQUAL(papszSRSDimensionLoc[i], "POSLIST") )                nSRSDimensionLocFlags |= SRSDIM_LOC_POSLIST;            else if( EQUAL(papszSRSDimensionLoc[i], "GEOMETRY") )                nSRSDimensionLocFlags |= SRSDIM_LOC_GEOMETRY;            else                CPLDebug("OGR", "Unrecognized location for srsDimension : %s",                         papszSRSDimensionLoc[i]);        }        CSLDestroy(papszSRSDimensionLoc);        if( !OGR2GML3GeometryAppend( (OGRGeometry *) hGeometry, NULL, &pszText,                                    &nLength, &nMaxLength, FALSE, bLongSRS,                                     bLineStringAsCurve, pszGMLId, nSRSDimensionLocFlags, FALSE ))        {            CPLFree( pszText );            return NULL;        }        else            return pszText;    }    if( !OGR2GMLGeometryAppend( (OGRGeometry *) hGeometry, &pszText,                                &nLength, &nMaxLength, FALSE ))    {        CPLFree( pszText );        return NULL;    }    else        return pszText;}

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

OGRGeoJSONWriteLayer::OGRGeoJSONWriteLayer( const char* pszName,                                  OGRwkbGeometryType eGType,                                  char** papszOptions,                                  OGRGeoJSONDataSource* poDS )    : poDS_( poDS ), poFeatureDefn_(new OGRFeatureDefn( pszName ) ), nOutCounter_( 0 ){    bWriteBBOX = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "WRITE_BBOX", "FALSE"));    bBBOX3D = FALSE;    poFeatureDefn_->Reference();    poFeatureDefn_->SetGeomType( eGType );    SetDescription( poFeatureDefn_->GetName() );    nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"));}

CPLErr GNMGenericNetwork::CheckLayerDriver(const char* pszDefaultDriverName,                                        char **papszOptions){    if(NULL == m_poLayerDriver)    {        const char* pszDriverName = CSLFetchNameValueDef(papszOptions,                                                         GNM_MD_FORMAT,                                                         pszDefaultDriverName);        if(!CheckStorageDriverSupport(pszDriverName))        {            CPLError( CE_Failure, CPLE_IllegalArg, "%s driver not supported as network storage",                      pszDriverName );            return CE_Failure;        }        m_poLayerDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName );        if(NULL == m_poLayerDriver)        {            CPLError( CE_Failure, CPLE_IllegalArg, "%s driver not available",                      pszDriverName );            return CE_Failure;        }    }    return CE_None;}

static void GDALGeoLocRescale(char**& papszMD, const char* pszItem,                                  double dfRatio, double dfDefaultVal){    double dfVal = CPLAtofM(CSLFetchNameValueDef(papszMD, pszItem,                                            CPLSPrintf("%.18g", dfDefaultVal)));    dfVal *= dfRatio;    papszMD = CSLSetNameValue(papszMD, pszItem, CPLSPrintf("%.18g", dfVal));}

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

OGRGMELayer::OGRGMELayer(OGRGMEDataSource* poDS,                         const char* pszTableName,                         char ** papszOptions){    CPLDebug("GME", "Creating new layer %s", pszTableName);    this->poDS = poDS;    poSRS = new OGRSpatialReference(SRS_WKT_WGS84);    poFeatureDefn = NULL;    current_feature_page = NULL;    bDirty = false;    iBatchPatchSize = 50;    bCreateTablePending = true;    osTableName = pszTableName;    osProjectId = CSLFetchNameValue( papszOptions, "projectId" );    osDraftACL = CSLFetchNameValueDef( papszOptions, "draftAccessList", "Map Editors" );    osPublishedACL = CSLFetchNameValueDef( papszOptions, "publishedAccessList", "Map Viewers" );    // TODO: support tags and description}

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

int GDALGeorefPamDataset::GetPAMGeorefSrcIndex(){    if( !m_bGotPAMGeorefSrcIndex )    {        m_bGotPAMGeorefSrcIndex = true;        const char* pszGeorefSources = CSLFetchNameValueDef( papszOpenOptions,            "GEOREF_SOURCES",            CPLGetConfigOption("GDAL_GEOREF_SOURCES", "PAM,OTHER") );        char** papszTokens = CSLTokenizeString2(pszGeorefSources, ",", 0);        m_nPAMGeorefSrcIndex = CSLFindString(papszTokens, "PAM");        CSLDestroy(papszTokens);    }    return m_nPAMGeorefSrcIndex;}

OGRGeoJSONWriteLayer::OGRGeoJSONWriteLayer( const char* pszName,                                            OGRwkbGeometryType eGType,                                            char** papszOptions,                                            bool bWriteFC_BBOXIn,                                            OGRCoordinateTransformation* poCT,                                            OGRGeoJSONDataSource* poDS ) :    poDS_(poDS),    poFeatureDefn_(new OGRFeatureDefn( pszName )),    nOutCounter_(0),    bWriteBBOX(CPLTestBool(        CSLFetchNameValueDef(papszOptions, "WRITE_BBOX", "FALSE"))),    bBBOX3D(false),    bWriteFC_BBOX(bWriteFC_BBOXIn),    nCoordPrecision_(atoi(        CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"))),    nSignificantFigures_(atoi(        CSLFetchNameValueDef(papszOptions, "SIGNIFICANT_FIGURES", "-1"))),    bRFC7946_(CPLTestBool(        CSLFetchNameValueDef(papszOptions, "RFC7946", "FALSE"))),    poCT_(poCT){    poFeatureDefn_->Reference();    poFeatureDefn_->SetGeomType( eGType );    SetDescription( poFeatureDefn_->GetName() );    if( bRFC7946_ && nCoordPrecision_ < 0 )        nCoordPrecision_ = 7;    oWriteOptions_.bWriteBBOX = bWriteBBOX;    oWriteOptions_.nCoordPrecision = nCoordPrecision_;    oWriteOptions_.nSignificantFigures = nSignificantFigures_;    if( bRFC7946_ )    {        oWriteOptions_.SetRFC7946Settings();    }    oWriteOptions_.SetIDOptions(papszOptions);    oWriteOptions_.bAllowNonFiniteValues = CPLTestBool(        CSLFetchNameValueDef(papszOptions, "WRITE_NON_FINITE_VALUES", "FALSE"));}

bool CPLJSONDocument::LoadUrl(const std::string & /*osUrl*/, char ** /*papszOptions*/,                              GDALProgressFunc /*pfnProgress*/,                              void * /*pProgressArg*/)#endif // HAVE_CURL{#ifdef HAVE_CURL    int nDepth = atoi( CSLFetchNameValueDef( papszOptions, "JSON_DEPTH", "10") );    JsonContext ctx = { nullptr, json_tokener_new_ex(nDepth), 0 };    CPLHTTPFetchWriteFunc pWriteFunc = CPLJSONWriteFunction;    CPLHTTPResult *psResult = CPLHTTPFetchEx( osUrl.c_str(), papszOptions,                                              pfnProgress, pProgressArg,                                              pWriteFunc, &ctx );    bool bResult = true;    if( psResult->nStatus != 0 /*CURLE_OK*/ )    {        bResult = false;    }    CPLHTTPDestroyResult( psResult );    enum json_tokener_error jerr;    if ((jerr = json_tokener_get_error(ctx.pTokener)) != json_tokener_success) {        CPLError(CE_Failure, CPLE_AppDefined, "JSON error: %s/n",               json_tokener_error_desc(jerr));        bResult = false;    }    else {        if( m_poRootJsonObject )            json_object_put( TO_JSONOBJ(m_poRootJsonObject) );        m_poRootJsonObject = ctx.pObject;    }    json_tokener_free(ctx.pTokener);    return bResult;#else    return false;#endif}

// static function- pointer set in driverGDALDataset *KEADataset::Create( const char * pszFilename,                                  int nXSize, int nYSize, int nBands,                                  GDALDataType eType,                                  char ** papszParmList  ){    H5::H5File *keaImgH5File = CreateLL( pszFilename, nXSize, nYSize, nBands,                                         eType, papszParmList  );    if( keaImgH5File == NULL )        return NULL;    bool bThematic =        CPLTestBool(CSLFetchNameValueDef( papszParmList, "THEMATIC", "FALSE" ));    try    {        // create our dataset object        KEADataset *pDataset = new KEADataset( keaImgH5File, GA_Update );        pDataset->SetDescription( pszFilename );        // set all to thematic if asked        if( bThematic )        {            for( int nCount = 0; nCount < nBands; nCount++ )            {                GDALRasterBand *pBand = pDataset->GetRasterBand(nCount+1);                pBand->SetMetadataItem("LAYER_TYPE", "thematic");            }        }        return pDataset;    }    catch (kealib::KEAIOException &e)    {        CPLError( CE_Failure, CPLE_OpenFailed,                  "Attempt to create file `%s' failed. Error: %s/n",                  pszFilename, e.what() );        return NULL;    }}

CPLVirtualMem  *RawRasterBand::GetVirtualMemAuto( GDALRWFlag eRWFlag,                                                  int *pnPixelSpace,                                                  GIntBig *pnLineSpace,                                                  char **papszOptions ){    CPLAssert(pnPixelSpace);    CPLAssert(pnLineSpace);    vsi_l_offset nSize =  (vsi_l_offset)(nRasterYSize - 1) * nLineOffset +        (nRasterXSize - 1) * nPixelOffset + GDALGetDataTypeSize(eDataType) / 8;    if( !bIsVSIL || VSIFGetNativeFileDescriptorL(fpRawL) == NULL ||        !CPLIsVirtualMemFileMapAvailable() || (eDataType != GDT_Byte && !bNativeOrder) ||        (size_t)nSize != nSize || nPixelOffset < 0 || nLineOffset < 0 ||        CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "USE_DEFAULT_IMPLEMENTATION", "NO")) )    {        return GDALRasterBand::GetVirtualMemAuto(eRWFlag, pnPixelSpace,                                                 pnLineSpace, papszOptions);    }    FlushCache();    CPLVirtualMem* pVMem = CPLVirtualMemFileMapNew(        fpRawL, nImgOffset, nSize,        (eRWFlag == GF_Write) ? VIRTUALMEM_READWRITE : VIRTUALMEM_READONLY,        NULL, NULL);    if( pVMem == NULL )    {        return GDALRasterBand::GetVirtualMemAuto(eRWFlag, pnPixelSpace,                                                 pnLineSpace, papszOptions);    }    else    {        *pnPixelSpace = nPixelOffset;        *pnLineSpace = nLineOffset;        return pVMem;    }}

char *OGR_G_ExportToGMLEx( OGRGeometryH hGeometry, char** papszOptions ){    char        *pszText;    int         nLength = 0, nMaxLength = 1;    if( hGeometry == NULL )        return CPLStrdup( "" );    pszText = (char *) CPLMalloc(nMaxLength);    pszText[0] = '/0';    const char* pszFormat = CSLFetchNameValue(papszOptions, "FORMAT");    if (pszFormat && EQUAL(pszFormat, "GML3"))    {        const char* pszLineStringElement = CSLFetchNameValue(papszOptions, "GML3_LINESTRING_ELEMENT");        int bLineStringAsCurve = (pszLineStringElement && EQUAL(pszLineStringElement, "curve"));        int bLongSRS = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "GML3_LONGSRS", "YES"));        const char* pszGMLId = CSLFetchNameValue(papszOptions, "GMLID");        if( !OGR2GML3GeometryAppend( (OGRGeometry *) hGeometry, NULL, &pszText,                                    &nLength, &nMaxLength, FALSE, bLongSRS, bLineStringAsCurve, pszGMLId ))        {            CPLFree( pszText );            return NULL;        }        else            return pszText;    }    if( !OGR2GMLGeometryAppend( (OGRGeometry *) hGeometry, &pszText,                                &nLength, &nMaxLength, FALSE ))    {        CPLFree( pszText );        return NULL;    }    else        return pszText;}

char* OGR_G_ExportToJsonEx( OGRGeometryH hGeometry, char** papszOptions ){    VALIDATE_POINTER1( hGeometry, "OGR_G_ExportToJson", NULL );    OGRGeometry* poGeometry = (OGRGeometry*) (hGeometry);    int nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"));    json_object* poObj = NULL;    poObj = OGRGeoJSONWriteGeometry( poGeometry, nCoordPrecision );    if( NULL != poObj )    {        char* pszJson = CPLStrdup( json_object_to_json_string( poObj ) );        /* Release JSON tree. */        json_object_put( poObj );        return pszJson;    }    /* Translation failed */    return NULL;}

int OGRAmigoCloudDataSource::Open( const char * pszFilename,                                   char** papszOpenOptionsIn,                                   int bUpdateIn ){    bReadWrite = CPL_TO_BOOL(bUpdateIn);    pszName = CPLStrdup( pszFilename );    if( CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID") )        pszProjetctId = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID"));    else    {        pszProjetctId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));        char* pchSpace = strchr(pszProjetctId, ' ');        if( pchSpace )            *pchSpace = '/0';        if( pszProjetctId[0] == 0 )        {            CPLError(CE_Failure, CPLE_AppDefined, "Missing projetc id");            return FALSE;        }    }    osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "API_KEY",                                    CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));    CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");    bUseHTTPS = CPLTestBool(CPLGetConfigOption("AMIGOCLOUD_HTTPS", "YES"));    OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");    if( poSchemaLayer )    {        OGRFeature* poFeat = poSchemaLayer->GetNextFeature();        if( poFeat )        {            if( poFeat->GetFieldCount() == 1 )            {                osCurrentSchema = poFeat->GetFieldAsString(0);            }            delete poFeat;        }        ReleaseResultSet(poSchemaLayer);    }    if( osCurrentSchema.size() == 0 )        return FALSE;    if (osDatasets.size() != 0)    {        char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);        for(int i=0;papszTables && papszTables[i];i++)        {            papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(                papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));            papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);        }        CSLDestroy(papszTables);        return TRUE;    }    return TRUE;}

GDALDataset *WEBPDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,                        int bStrict, char ** papszOptions,                        GDALProgressFunc pfnProgress, void * pProgressData ){    int  nBands = poSrcDS->GetRasterCount();    int  nXSize = poSrcDS->GetRasterXSize();    int  nYSize = poSrcDS->GetRasterYSize();/* -------------------------------------------------------------------- *//*      WEBP library initialization                                     *//* -------------------------------------------------------------------- */    WebPPicture sPicture;    if (!WebPPictureInit(&sPicture))    {        CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureInit() failed");        return NULL;    }/* -------------------------------------------------------------------- *//*      Some some rudimentary checks                                    *//* -------------------------------------------------------------------- */    if( nXSize > 16383 || nYSize > 16383 )    {        CPLError( CE_Failure, CPLE_NotSupported,                  "WEBP maximum image dimensions are 16383 x 16383.");        return NULL;    }    if( nBands != 3#if WEBP_ENCODER_ABI_VERSION >= 0x0100        && nBands != 4#endif        )    {        CPLError( CE_Failure, CPLE_NotSupported,                  "WEBP driver doesn't support %d bands. Must be 3 (RGB) "#if WEBP_ENCODER_ABI_VERSION >= 0x0100                  "or 4 (RGBA) "#endif                  "bands.",                  nBands );        return NULL;    }    GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();    if( eDT != GDT_Byte )    {        CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,                  "WEBP driver doesn't support data type %s. "                  "Only eight bit byte bands supported.",                  GDALGetDataTypeName(                      poSrcDS->GetRasterBand(1)->GetRasterDataType()) );        if (bStrict)            return NULL;    }/* -------------------------------------------------------------------- *//*      What options has the user selected?                             *//* -------------------------------------------------------------------- */    float fQuality = 75.0f;    const char* pszQUALITY = CSLFetchNameValue(papszOptions, "QUALITY");     if( pszQUALITY != NULL )    {        fQuality = (float) CPLAtof(pszQUALITY);        if( fQuality < 0.0f || fQuality > 100.0f )        {            CPLError( CE_Failure, CPLE_IllegalArg,                      "%s=%s is not a legal value.", "QUALITY", pszQUALITY);            return NULL;        }    }    WebPPreset nPreset = WEBP_PRESET_DEFAULT;    const char* pszPRESET = CSLFetchNameValueDef(papszOptions, "PRESET", "DEFAULT");    if (EQUAL(pszPRESET, "DEFAULT"))        nPreset = WEBP_PRESET_DEFAULT;    else if (EQUAL(pszPRESET, "PICTURE"))        nPreset = WEBP_PRESET_PICTURE;    else if (EQUAL(pszPRESET, "PHOTO"))        nPreset = WEBP_PRESET_PHOTO;    else if (EQUAL(pszPRESET, "PICTURE"))        nPreset = WEBP_PRESET_PICTURE;    else if (EQUAL(pszPRESET, "DRAWING"))        nPreset = WEBP_PRESET_DRAWING;    else if (EQUAL(pszPRESET, "ICON"))        nPreset = WEBP_PRESET_ICON;    else if (EQUAL(pszPRESET, "TEXT"))        nPreset = WEBP_PRESET_TEXT;    else    {        CPLError( CE_Failure, CPLE_IllegalArg,                  "%s=%s is not a legal value.", "PRESET", pszPRESET );//.........这里部分代码省略.........

int OGRCSVDataSource::OpenTable( const char * pszFilename,                                 char** papszOpenOptions,                                 const char* pszNfdcRunwaysGeomField,                                 const char* pszGeonamesGeomFieldPrefix){/* -------------------------------------------------------------------- *//*      Open the file.                                                  *//* -------------------------------------------------------------------- */    VSILFILE       * fp;    if( bUpdate )        fp = VSIFOpenL( pszFilename, "rb+" );    else        fp = VSIFOpenL( pszFilename, "rb" );    if( fp == NULL )    {        CPLError( CE_Warning, CPLE_OpenFailed,                   "Failed to open %s, %s.",                   pszFilename, VSIStrerror( errno ) );        return FALSE;    }    if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL &&        strstr(pszFilename, "/vsizip/") == NULL )        fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);    CPLString osLayerName = CPLGetBasename(pszFilename);    CPLString osExt = CPLGetExtension(pszFilename);    if( strncmp(pszFilename, "/vsigzip/", 9) == 0 && EQUAL(osExt, "gz") )    {        if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") )        {            osLayerName = osLayerName.substr(0, osLayerName.size() - 4);            osExt = "csv";        }        else if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") )        {            osLayerName = osLayerName.substr(0, osLayerName.size() - 4);            osExt = "tsv";        }    }/* -------------------------------------------------------------------- *//*      Read and parse a line.  Did we get multiple fields?             *//* -------------------------------------------------------------------- */    const char* pszLine = CPLReadLineL( fp );    if (pszLine == NULL)    {        VSIFCloseL( fp );        return FALSE;    }    char chDelimiter = CSVDetectSeperator(pszLine);    if( chDelimiter != '/t' && strchr(pszLine, '/t') != NULL )    {        /* Force the delimiter to be TAB for a .tsv file that has a tabulation */        /* in its first line */        if( EQUAL(osExt, "tsv") )        {            chDelimiter = '/t';        }        else        {            for(int bDontHonourStrings=0; bDontHonourStrings<=1; bDontHonourStrings++)            {                // Read the first 2 lines to see if they have the same number of fields, if using tabulation                VSIRewindL( fp );                char** papszTokens = OGRCSVReadParseLineL( fp, '/t', bDontHonourStrings );                int nTokens1 = CSLCount(papszTokens);                CSLDestroy(papszTokens);                papszTokens = OGRCSVReadParseLineL( fp, '/t', bDontHonourStrings );                int nTokens2 = CSLCount(papszTokens);                CSLDestroy(papszTokens);                if( nTokens1 >= 2 && nTokens1 == nTokens2 )                {                    chDelimiter = '/t';                    break;                }            }        }    }    VSIRewindL( fp );#if 0    const char *pszDelimiter = CSLFetchNameValueDef( papszOpenOptions, "SEPARATOR", "AUTO");    if( !EQUAL(pszDelimiter, "AUTO") )    {        if (EQUAL(pszDelimiter, "COMMA"))            chDelimiter = ',';        else if (EQUAL(pszDelimiter, "SEMICOLON"))            chDelimiter = ';';        else if (EQUAL(pszDelimiter, "TAB"))            chDelimiter = '/t';        else if (EQUAL(pszDelimiter, "SPACE"))            chDelimiter = ' ';        else        {            CPLError( CE_Warning, CPLE_AppDefined, //.........这里部分代码省略.........

GDALDataset *KEADataset::CreateCopy( const char * pszFilename, GDALDataset *pSrcDs,                                CPL_UNUSED int bStrict, char **  papszParmList,                                 GDALProgressFunc pfnProgress, void *pProgressData ){    // get the data out of the input dataset    int nXSize = pSrcDs->GetRasterXSize();    int nYSize = pSrcDs->GetRasterYSize();    int nBands = pSrcDs->GetRasterCount();    GDALDataType eType = (nBands == 0) ? GDT_Unknown : pSrcDs->GetRasterBand(1)->GetRasterDataType();    H5::H5File *keaImgH5File = CreateLL( pszFilename, nXSize, nYSize, nBands,                                         eType, papszParmList  );    if( keaImgH5File == NULL )        return NULL;    bool bThematic = CSLTestBoolean(CSLFetchNameValueDef( papszParmList, "THEMATIC", "FALSE" ));    try    {        // create the imageio        kealib::KEAImageIO *pImageIO = new kealib::KEAImageIO();                // open the file        pImageIO->openKEAImageHeader( keaImgH5File );        // copy file        if( !KEACopyFile( pSrcDs, pImageIO, pfnProgress, pProgressData) )        {            delete pImageIO;            return NULL;        }        // close it        try        {            pImageIO->close();        }        catch (kealib::KEAIOException &e)        {        }        delete pImageIO;        // now open it again - because the constructor loads all the info        // in we need to copy the data first....        keaImgH5File = kealib::KEAImageIO::openKeaH5RW( pszFilename );        // and wrap it in a dataset        KEADataset *pDataset = new KEADataset( keaImgH5File, GA_Update );        pDataset->SetDescription( pszFilename );        // set all to thematic if asked - overrides whatever set by CopyFile        if( bThematic )        {            for( int nCount = 0; nCount < nBands; nCount++ )            {                GDALRasterBand *pBand = pDataset->GetRasterBand(nCount+1);                pBand->SetMetadataItem("LAYER_TYPE", "thematic");            }        }        for( int nCount = 0; nCount < nBands; nCount++ )        {            pDataset->GetRasterBand(nCount+1)->SetColorInterpretation(                pSrcDs->GetRasterBand(nCount+1)->GetColorInterpretation());        }                // KEA has no concept of per-dataset mask band for now.        for( int nCount = 0; nCount < nBands; nCount++ )        {            if( pSrcDs->GetRasterBand(nCount+1)->GetMaskFlags() == 0 ) // Per-band mask            {                pDataset->GetRasterBand(nCount+1)->CreateMaskBand(0);                GDALRasterBandCopyWholeRaster(                    (GDALRasterBandH)pSrcDs->GetRasterBand(nCount+1)->GetMaskBand(),                    (GDALRasterBandH)pDataset->GetRasterBand(nCount+1)->GetMaskBand(),                    NULL, NULL, NULL);            }        }        return pDataset;    }    catch (kealib::KEAException &e)    {        CPLError( CE_Failure, CPLE_OpenFailed,                  "Attempt to create file `%s' failed. Error: %s/n",                  pszFilename, e.what() );        return NULL;    }}

static GDALDataset *EpsilonDatasetCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,                       CPL_UNUSED int bStrict, char ** papszOptions,                       GDALProgressFunc pfnProgress, void * pProgressData ){    int nBands = poSrcDS->GetRasterCount();    if ((nBands != 1 && nBands != 3) ||        (nBands > 0 && poSrcDS->GetRasterBand(1)->GetColorTable() != NULL))    {        CPLError(CE_Failure, CPLE_NotSupported,                 "The EPSILON driver only supports 1 band (grayscale) "                 "or 3 band (RGB) data");        return NULL;    }/* -------------------------------------------------------------------- *//*      Fetch and check creation options                                *//* -------------------------------------------------------------------- */    int nBlockXSize =        atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));    int nBlockYSize =        atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));    if ((nBlockXSize != 32 && nBlockXSize != 64 && nBlockXSize != 128 &&         nBlockXSize != 256 && nBlockXSize != 512 && nBlockXSize != 1024) ||        (nBlockYSize != 32 && nBlockYSize != 64 && nBlockYSize != 128 &&         nBlockYSize != 256 && nBlockYSize != 512 && nBlockYSize != 1024))    {        CPLError(CE_Failure, CPLE_NotSupported,                "Block size must be a power of 2 between 32 et 1024");        return NULL;    }    const char* pszFilter =        CSLFetchNameValueDef(papszOptions, "FILTER", "daub97lift");    char** papszFBID = eps_get_fb_info(EPS_FB_ID);    char** papszFBIDIter = papszFBID;    int bFound = FALSE;    int nIndexFB = 0;    while(papszFBIDIter && *papszFBIDIter && !bFound)    {        if (strcmp(*papszFBIDIter, pszFilter) == 0)            bFound = TRUE;        else            nIndexFB ++;        papszFBIDIter ++;    }    eps_free_fb_info(papszFBID);    if (!bFound)    {        CPLError(CE_Failure, CPLE_NotSupported, "FILTER='%s' not supported",                 pszFilter);        return NULL;    }    int eMode = EPS_MODE_OTLPF;    const char* pszMode = CSLFetchNameValueDef(papszOptions, "MODE", "OTLPF");    if (EQUAL(pszMode, "NORMAL"))        eMode = EPS_MODE_NORMAL;    else if (EQUAL(pszMode, "OTLPF"))        eMode = EPS_MODE_OTLPF;    else    {        CPLError(CE_Failure, CPLE_NotSupported, "MODE='%s' not supported",                 pszMode);        return NULL;    }    char** papszFBType = eps_get_fb_info(EPS_FB_TYPE);    int bIsBiOrthogonal = EQUAL(papszFBType[nIndexFB], "biorthogonal");    eps_free_fb_info(papszFBType);    if (eMode == EPS_MODE_OTLPF && !bIsBiOrthogonal)    {        CPLError(CE_Failure, CPLE_NotSupported,                 "MODE=OTLPF can only be used with biorthogonal filters. "                 "Use MODE=NORMAL instead");        return NULL;    }    int bRasterliteOutput =        CPLTestBool(CSLFetchNameValueDef(papszOptions,                                            "RASTERLITE_OUTPUT", "NO"));    int nYRatio = EPS_Y_RT;    int nCbRatio = EPS_Cb_RT;    int nCrRatio = EPS_Cr_RT;    int eResample;    if (CPLTestBool(CSLFetchNameValueDef(papszOptions,                                            "RGB_RESAMPLE", "YES")))        eResample = EPS_RESAMPLE_420;    else        eResample = EPS_RESAMPLE_444;    const char* pszTarget = CSLFetchNameValueDef(papszOptions, "TARGET", "96");    double dfReductionFactor = 1 - CPLAtof(pszTarget) / 100;    if (dfReductionFactor > 1)        dfReductionFactor = 1;    else if (dfReductionFactor < 0)//.........这里部分代码省略.........

//.........这里部分代码省略........./* -------------------------------------------------------------------- */    char *pszFilenameWithoutExt;    if(  bSingleFileDataSource && nLayers == 0 )    {        char *pszPath = CPLStrdup(CPLGetPath(pszName));        char *pszFBasename = CPLStrdup(CPLGetBasename(pszName));        pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath, pszFBasename, NULL));        CPLFree( pszFBasename );        CPLFree( pszPath );    }    else if(  bSingleFileDataSource )    {        /* This is a very weird use case : the user creates/open a datasource */        /* made of a single shapefile 'foo.shp' and wants to add a new layer */        /* to it, 'bar'. So we create a new shapefile 'bar.shp' in the same */        /* directory as 'foo.shp' */        /* So technically, we will not be any longer a single file */        /* datasource ... Ahem ahem */        char *pszPath = CPLStrdup(CPLGetPath(pszName));        pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath,pszLayerName,NULL));        CPLFree( pszPath );    }    else        pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszName,pszLayerName,NULL));/* -------------------------------------------------------------------- *//*      Create the shapefile.                                           *//* -------------------------------------------------------------------- */    char        *pszFilename;    int b2GBLimit = CSLTestBoolean(CSLFetchNameValueDef( papszOptions, "2GB_LIMIT", "FALSE" ));    if( nShapeType != SHPT_NULL )    {        pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "shp" ));        hSHP = SHPCreateLL( pszFilename, nShapeType, (SAHooks*) VSI_SHP_GetHook(b2GBLimit) );                if( hSHP == NULL )        {            CPLError( CE_Failure, CPLE_OpenFailed,                      "Failed to open Shapefile `%s'./n",                      pszFilename );            CPLFree( pszFilename );            CPLFree( pszFilenameWithoutExt );            return NULL;        }                SHPSetFastModeReadObject( hSHP, TRUE );        CPLFree( pszFilename );    }    else        hSHP = NULL;/* -------------------------------------------------------------------- *//*      Has a specific LDID been specified by the caller?               *//* -------------------------------------------------------------------- */    const char *pszLDID = CSLFetchNameValue( papszOptions, "ENCODING" );/* -------------------------------------------------------------------- *//*      Create a DBF file.                                              *//* -------------------------------------------------------------------- */

int OGRAmigoCloudDataSource::Open( const char * pszFilename,                                   char** papszOpenOptionsIn,                                   int bUpdateIn ){    bReadWrite = CPL_TO_BOOL(bUpdateIn);    pszName = CPLStrdup( pszFilename );    pszProjectId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));    char* pchSpace = strchr(pszProjectId, ' ');    if( pchSpace )        *pchSpace = '/0';    if( pszProjectId[0] == 0 )    {        CPLError(CE_Failure, CPLE_AppDefined, "Missing project id");        return FALSE;    }    osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "AMIGOCLOUD_API_KEY",                                    CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));    if (osAPIKey.empty())    {        osAPIKey = OGRAMIGOCLOUDGetOptionValue(pszFilename, "AMIGOCLOUD_API_KEY");    }    if (osAPIKey.empty())    {        CPLError(CE_Failure, CPLE_AppDefined, "AMIGOCLOUD_API_KEY is not defined./n");        return FALSE;    }    OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");    if( poSchemaLayer )    {        OGRFeature* poFeat = poSchemaLayer->GetNextFeature();        if( poFeat )        {            if( poFeat->GetFieldCount() == 1 )            {                osCurrentSchema = poFeat->GetFieldAsString(0);            }            delete poFeat;        }        ReleaseResultSet(poSchemaLayer);    }    if( osCurrentSchema.empty() )        return FALSE;    CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");    if (!osDatasets.empty())    {        char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);        for(int i=0;papszTables && papszTables[i];i++)        {            papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(                papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));            papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);        }        CSLDestroy(papszTables);        // If OVERWRITE: YES, truncate the layer.        if( nLayers==1 &&            CPLFetchBool(papszOpenOptionsIn, "OVERWRITE", false) )        {           TruncateDataset(papoLayers[0]->GetTableName());        }        return TRUE;    } else {        // If 'datasets' word is in the filename, but no dataset id specified,        // print the list of available datasets        if(std::string(pszFilename).find("datasets") != std::string::npos)            ListDatasets();    }    return TRUE;}

OGRLayer *GNMGenericNetwork::GetPath(GNMGFID nStartFID, GNMGFID nEndFID,                          GNMGraphAlgorithmType eAlgorithm, char **papszOptions){    if(!m_bIsGraphLoaded && LoadGraph() != CE_None)    {        return NULL;    }    GDALDriver* poMEMDrv =            OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("Memory");    if (poMEMDrv == NULL)    {        CPLError(CE_Failure, CPLE_AppDefined, "Cannot load 'Memory' driver");        return NULL;    }    GDALDataset* poMEMDS =            poMEMDrv->Create("dummy_name", 0, 0, 0, GDT_Unknown, NULL);    OGRSpatialReference oDstSpaRef(GetProjectionRef());    OGRLayer* poMEMLayer = poMEMDS->CreateLayer(GetAlgorithmName(eAlgorithm,                               true), &oDstSpaRef, wkbGeometryCollection, NULL);    OGRGNMWrappedResultLayer* poResLayer =                              new OGRGNMWrappedResultLayer(poMEMDS, poMEMLayer);    const bool bReturnEdges = CPLFetchBool(papszOptions, GNM_MD_FETCHEDGES, true);    const bool bReturnVertices = CPLFetchBool(papszOptions, GNM_MD_FETCHVERTEX, true);    switch (eAlgorithm)    {    case GATDijkstraShortestPath:        {            GNMPATH path = m_oGraph.DijkstraShortestPath(nStartFID, nEndFID);            // fill features in result layer            FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);        }        break;    case GATKShortestPath:        {            int nK = atoi(CSLFetchNameValueDef(papszOptions, GNM_MD_NUM_PATHS,                                               "1"));            CPLDebug("GNM", "Search %d path(s)", nK);            std::vector<GNMPATH> paths = m_oGraph.KShortestPaths(nStartFID,                                                                 nEndFID, nK);            // fill features in result layer            for(size_t i = 0; i < paths.size(); ++i)            {                FillResultLayer(poResLayer, paths[i], static_cast<int>(i + 1), bReturnVertices,                                bReturnEdges);            }        }        break;    case GATConnectedComponents:        {            GNMVECTOR anEmitters;            if(NULL != papszOptions)            {                char** papszEmitter = CSLFetchNameValueMultiple(papszOptions, GNM_MD_EMITTER);                for(int i = 0; papszEmitter[i] != NULL; ++i)                {                    GNMGFID nEmitter = atol(papszEmitter[i]);                    anEmitters.push_back(nEmitter);                }                CSLDestroy(papszEmitter);            }            if(nStartFID != -1)            {                anEmitters.push_back(nStartFID);            }            if(nStartFID != -1)            {                anEmitters.push_back(nEndFID);            }            GNMPATH path = m_oGraph.ConnectedComponents(anEmitters);            // fill features in result layer            FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);        }        break;    }    return poResLayer;}

OGRLayer   *OGRCouchDBDataSource::ICreateLayer( const char *pszNameIn,                                           OGRSpatialReference *poSpatialRef,                                           OGRwkbGeometryType eGType,                                           char ** papszOptions ){    if( !bReadWrite )    {        CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");        return NULL;    }/* -------------------------------------------------------------------- *//*      Do we already have this layer?  If so, should we blow it        *//*      away?                                                           *//* -------------------------------------------------------------------- */    for( int iLayer = 0; iLayer < nLayers; iLayer++ )    {        if( EQUAL(pszNameIn,papoLayers[iLayer]->GetName()) )        {            if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL                && !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )            {                DeleteLayer( pszNameIn );                break;            }            else            {                CPLError( CE_Failure, CPLE_AppDefined,                          "Layer %s already exists, CreateLayer failed./n"                          "Use the layer creation option OVERWRITE=YES to "                          "replace it.",                          pszNameIn );                return NULL;            }        }    }    char* pszEscapedName = CPLEscapeString(pszNameIn, -1, CPLES_URL);    CPLString osEscapedName = pszEscapedName;    CPLFree(pszEscapedName);/* -------------------------------------------------------------------- *//*      Create "database"                                               *//* -------------------------------------------------------------------- */    CPLString osURI;    osURI = "/";    osURI += osEscapedName;    json_object* poAnswerObj = PUT(osURI, NULL);    if (poAnswerObj == NULL)        return NULL;    if( !IsOK(poAnswerObj, "Layer creation failed") )    {        json_object_put(poAnswerObj);        return NULL;    }    json_object_put(poAnswerObj);/* -------------------------------------------------------------------- *//*      Create "spatial index"                                          *//* -------------------------------------------------------------------- */    int nUpdateSeq = 0;    if (eGType != wkbNone)    {        osURI = "/";        osURI += osEscapedName;        osURI += "/_design/ogr_spatial";        CPLString osContent("{ /"spatial/": { /"spatial/" : /"function(doc) { if (doc.geometry && doc.geometry.coordinates && doc.geometry.coordinates.length != 0) { emit(doc.geometry, null); } } /" } }");        poAnswerObj = PUT(osURI, osContent);        if( IsOK(poAnswerObj, "Spatial index creation failed") )            nUpdateSeq ++;        json_object_put(poAnswerObj);    }/* -------------------------------------------------------------------- *//*      Create validation function                                      *//* -------------------------------------------------------------------- */    const char* pszUpdatePermissions = CSLFetchNameValueDef(papszOptions, "UPDATE_PERMISSIONS", "LOGGED_USER");    CPLString osValidation;    if (EQUAL(pszUpdatePermissions, "LOGGED_USER"))    {        osValidation = "{/"validate_doc_update/": /"function(new_doc, old_doc, userCtx) { if(!userCtx.name) { throw({forbidden: ///"Please log in first.///"}); } }/" }";    }    else if (EQUAL(pszUpdatePermissions, "ALL"))    {        osValidation = "{/"validate_doc_update/": /"function(new_doc, old_doc, userCtx) {  }/" }";    }    else if (EQUAL(pszUpdatePermissions, "ADMIN"))    {        osValidation = "{/"validate_doc_update/": /"function(new_doc, old_doc, userCtx) {if (userCtx.roles.indexOf('_admin') === -1) { throw({forbidden: ///"No changes allowed except by admin.///"}); } }/" }";    }    else if (STARTS_WITH(pszUpdatePermissions, "function("))    {        osValidation = "{/"validate_doc_update/": /"";//.........这里部分代码省略.........

int OGRTABDataSource::Create( const char * pszName, char **papszOptions ){    CPLAssert(m_pszName == nullptr);    m_pszName = CPLStrdup(pszName);    m_papszOptions = CSLDuplicate(papszOptions);    m_bUpdate = TRUE;    const char *pszOpt = CSLFetchNameValue(papszOptions, "FORMAT");    if( pszOpt != nullptr && EQUAL(pszOpt, "MIF") )        m_bCreateMIF = TRUE;    else if( EQUAL(CPLGetExtension(pszName),"mif") ||             EQUAL(CPLGetExtension(pszName),"mid") )        m_bCreateMIF = TRUE;    if( (pszOpt = CSLFetchNameValue(papszOptions,"SPATIAL_INDEX_MODE")) != nullptr )    {        if( EQUAL(pszOpt, "QUICK") )            m_bQuickSpatialIndexMode = TRUE;        else if( EQUAL(pszOpt, "OPTIMIZED") )            m_bQuickSpatialIndexMode = FALSE;    }    m_nBlockSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKSIZE", "512"));    // Create a new empty directory.    VSIStatBufL sStat;    if( strlen(CPLGetExtension(pszName)) == 0 )    {        if( VSIStatL( pszName, &sStat ) == 0 )        {            if( !VSI_ISDIR(sStat.st_mode) )            {                CPLError(CE_Failure, CPLE_OpenFailed,                         "Attempt to create dataset named %s,/n"                         "but that is an existing file.",                         pszName);                return FALSE;            }        }        else        {            if( VSIMkdir(pszName, 0755) != 0 )            {                CPLError(CE_Failure, CPLE_AppDefined,                         "Unable to create directory %s.",                         pszName);                return FALSE;            }        }        m_pszDirectory = CPLStrdup(pszName);    }    // Create a new single file.    else    {        IMapInfoFile *poFile = nullptr;        const char *pszEncoding( CSLFetchNameValue( papszOptions, "ENCODING" ) );        const char *pszCharset( IMapInfoFile::EncodingToCharset( pszEncoding ) );        if( m_bCreateMIF )        {            poFile = new MIFFile;            if( poFile->Open(m_pszName, TABWrite, FALSE, pszCharset) != 0 )            {                delete poFile;                return FALSE;            }        }        else        {            TABFile *poTabFile = new TABFile;            if( poTabFile->Open(m_pszName, TABWrite, FALSE,                                m_nBlockSize, pszCharset) != 0 )            {                delete poTabFile;                return FALSE;            }            poFile = poTabFile;        }        m_nLayerCount = 1;        m_papoLayers = static_cast<IMapInfoFile **>(CPLMalloc(sizeof(void *)));        m_papoLayers[0] = poFile;        m_pszDirectory = CPLStrdup(CPLGetPath(pszName));        m_bSingleFile = TRUE;    }    return TRUE;}

int OGROCIDataSource::Open( const char * pszNewName,                            char** papszOpenOptionsIn,                            int bUpdate,                            int bTestOpen ){    CPLAssert( nLayers == 0 && poSession == NULL );/* -------------------------------------------------------------------- *//*      Verify Oracle prefix.                                           *//* -------------------------------------------------------------------- */    if( !STARTS_WITH_CI(pszNewName,"OCI:") )    {        if( !bTestOpen )        {            CPLError( CE_Failure, CPLE_AppDefined,                      "%s does not conform to Oracle OCI driver naming convention,"                      " OCI:*/n", pszNewName );        }        return FALSE;    }/* -------------------------------------------------------------------- *//*      Try to parse out name, password and database name.              *//* -------------------------------------------------------------------- */    char *pszUserid;    const char *pszPassword = "";    const char *pszDatabase = "";    char **papszTableList = NULL;    const char *pszWorkspace = "";    int   i;    if( pszNewName[4] == '/0' )    {        pszUserid = CPLStrdup(CSLFetchNameValueDef(papszOpenOptionsIn, "USER", ""));        pszPassword = CSLFetchNameValueDef(papszOpenOptionsIn, "PASSWORD", "");        pszDatabase = CSLFetchNameValueDef(papszOpenOptionsIn, "DBNAME", "");        const char* pszTables = CSLFetchNameValue(papszOpenOptionsIn, "TABLES");        if( pszTables )            papszTableList = CSLTokenizeStringComplex(pszTables, ",", TRUE, FALSE );        pszWorkspace = CSLFetchNameValueDef(papszOpenOptions, "WORKSPACE", "");    }    else    {        pszUserid = CPLStrdup( pszNewName + 4 );        // Is there a table list?        for( i = static_cast<int>(strlen(pszUserid))-1; i > 1; i-- )        {            if( pszUserid[i] == ':' )            {                papszTableList = CSLTokenizeStringComplex( pszUserid+i+1, ",",                                                        TRUE, FALSE );                pszUserid[i] = '/0';                break;            }            if( pszUserid[i] == '/' || pszUserid[i] == '@' )                break;        }        for( i = 0;            pszUserid[i] != '/0' && pszUserid[i] != '/' && pszUserid[i] != '@';            i++ ) {}        if( pszUserid[i] == '/' )        {            pszUserid[i++] = '/0';            pszPassword = pszUserid + i;            for( ; pszUserid[i] != '/0' && pszUserid[i] != '@'; i++ ) {}        }        if( pszUserid[i] == '@' )        {            pszUserid[i++] = '/0';            pszDatabase = pszUserid + i;        }    }/* -------------------------------------------------------------------- *//*      Try to establish connection.                                    *//* -------------------------------------------------------------------- */    CPLDebug( "OCI", "Userid=%s, Password=%s, Database=%s",              pszUserid, pszPassword, pszDatabase );    if( EQUAL(pszDatabase, "") &&        EQUAL(pszPassword, "") &&        EQUAL(pszUserid, "") )    {        /* Use username/password OS Authentication and ORACLE_SID database */        poSession = OGRGetOCISession( "/", "", "" );    }    else    {        poSession = OGRGetOCISession( pszUserid, pszPassword, pszDatabase );    }    if( poSession == NULL )//.........这里部分代码省略.........