CPLXMLNode *WCTSCollectRequest()
{
if( getenv("REQUEST_METHOD") == NULL )
WCTSEmitServiceException( "REQUEST_METHOD not set." );
if( EQUAL(getenv("REQUEST_METHOD"),"GET") )
return WCTSCollectKVPRequest();
/* -------------------------------------------------------------------- */
/* Read the body of the POST message into a buffer. */
/* -------------------------------------------------------------------- */
int nContentLength = 0;
char *pszXML = NULL;
if( getenv("CONTENT_LENGTH") != NULL )
{
nContentLength = atoi(getenv("CONTENT_LENGTH"));
pszXML = (char *) CPLMalloc(nContentLength+1);
if( (int) fread(pszXML, 1, nContentLength, stdin) < nContentLength )
WCTSEmitServiceException( "POST body is short." );
pszXML[nContentLength] = '\0';
}
else
{
int nXMLMax, nXMLLen=0;
nXMLMax = 100;
pszXML = (char *) CPLMalloc(nXMLMax);
while( !feof(stdin) )
{
pszXML[nXMLLen++] = fgetc(stdin);
if( nXMLLen == nXMLMax )
{
nXMLMax = nXMLMax * 2;
pszXML = (char *) CPLRealloc(pszXML, nXMLMax);
}
}
pszXML[nXMLLen] = '\0';
}
/* -------------------------------------------------------------------- */
/* Convert into an XML document. */
/* -------------------------------------------------------------------- */
CPLErrorReset();
CPLXMLNode *psTree = CPLParseXMLString( pszXML );
CPLFree( pszXML );
if( CPLGetLastErrorType() == CE_Failure )
WCTSEmitServiceException( CPLGetLastErrorMsg() );
return psTree;
}
/**********************************************************************
* TABRawBinBlock::CommitAsDeleted()
*
* Commit current block to file using block type 4 (garbage block)
*
* Returns 0 if successful or -1 if an error happened, in which case
* CPLError() will have been called.
**********************************************************************/
int TABRawBinBlock::CommitAsDeleted(GInt32 nNextBlockPtr)
{
CPLErrorReset();
if ( m_pabyBuf == nullptr )
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"CommitAsDeleted(): Block has not been initialized yet!");
return -1;
}
/*-----------------------------------------------------------------
* Create deleted block header
*----------------------------------------------------------------*/
GotoByteInBlock(0x000);
WriteInt16(TABMAP_GARB_BLOCK); // Block type code
WriteInt32(nNextBlockPtr);
int nStatus = CPLGetLastErrorType() == CE_Failure ? -1 : 0;
/*-----------------------------------------------------------------
* OK, call the base class to write the block to disk.
*----------------------------------------------------------------*/
if (nStatus == 0)
{
#ifdef DEBUG_VERBOSE
CPLDebug("MITAB", "Committing GARBAGE block to offset %d", m_nFileOffset);
#endif
nStatus = TABRawBinBlock::CommitToFile();
m_nSizeUsed = 0;
}
return nStatus;
}
/**********************************************************************
* TABRawBinBlock::CommitAsDeleted()
*
* Commit current block to file using block type 4 (garbage block)
*
* Returns 0 if succesful or -1 if an error happened, in which case
* CPLError() will have been called.
**********************************************************************/
int TABRawBinBlock::CommitAsDeleted(GInt32 nNextBlockPtr)
{
int nStatus = 0;
CPLErrorReset();
if ( m_pabyBuf == NULL )
{
CPLError(CE_Failure, CPLE_AssertionFailed,
"CommitAsDeleted(): Block has not been initialized yet!");
return -1;
}
/*-----------------------------------------------------------------
* Create deleted block header
*----------------------------------------------------------------*/
GotoByteInBlock(0x000);
WriteInt32(nNextBlockPtr);
if( CPLGetLastErrorType() == CE_Failure )
nStatus = CPLGetLastErrorNo();
/*-----------------------------------------------------------------
* OK, call the base class to write the block to disk.
*----------------------------------------------------------------*/
if (nStatus == 0)
nStatus = TABRawBinBlock::CommitToFile();
return nStatus;
}
int IMapInfoFile::TestUtf8Capability() const
{
const char* pszEncoding( GetEncoding() );
if( strlen( pszEncoding ) == 0 )
{
return FALSE;
}
CPLClearRecodeWarningFlags();
CPLErrorReset();
CPLPushErrorHandler(CPLQuietErrorHandler);
char* pszTest( CPLRecode( "test", GetEncoding(), CPL_ENC_UTF8 ) );
CPLPopErrorHandler();
if( pszTest == nullptr )
{
return FALSE;
}
CPLFree( pszTest );
if( CPLGetLastErrorType() != 0 )
{
return FALSE;
}
return TRUE;
}
/**********************************************************************
* E00WriteOpen()
*
* Try to open output file, and alloc/initialize a new E00WritePtr
* handle.
*
* nComprLevel must be one of:
* E00_COMPR_NONE, E00_COMPR_PARTIAL or E00_COMPR_FULL
*
* Returns the new handle, or NULL if the file could not be opened.
* E00WriteClose() will eventually have to be called to release
* the resources used by the new handle.
**********************************************************************/
E00WritePtr E00WriteOpen(const char *pszFname, int nComprLevel)
{
E00WritePtr psInfo = NULL;
FILE *fp;
CPLErrorReset();
/* Open the file
*/
fp = VSIFOpen(pszFname, "wt");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Failed to open %s: %s", pszFname, strerror(errno));
return NULL;
}
/* Allocate and initialize a E00ReadPtr handle.
*/
psInfo = (E00WritePtr)CPLCalloc(1, sizeof(struct _E00WriteInfo));
psInfo->fp = fp;
psInfo->nComprLevel = nComprLevel;
return psInfo;
}
void SpatialReference::setFromUserInput(std::string const& v)
{
if (v.empty())
{
m_wkt.clear();
return;
}
OGRSpatialReference srs(NULL);
CPLErrorReset();
const char* input = v.c_str();
OGRErr err = srs.SetFromUserInput(const_cast<char *>(input));
if (err != OGRERR_NONE)
{
std::ostringstream oss;
std::string msg = CPLGetLastErrorMsg();
if (msg.empty())
msg = "(unknown reason)";
oss << "Could not import coordinate system '" << input << "': " <<
msg << ".";
throw pdal_error(oss.str());
}
char *poWKT = 0;
srs.exportToWkt(&poWKT);
std::string tmp(poWKT);
CPLFree(poWKT);
setWKT(tmp);
}
GIntBig OGRESRIFeatureServiceLayer::GetFeatureCount( int bForce )
{
GIntBig nFeatureCount = -1;
if( m_poAttrQuery == NULL && m_poFilterGeom == NULL )
{
CPLString osNewURL = CPLURLAddKVP(poDS->GetURL(), "returnCountOnly", "true");
CPLHTTPResult* pResult = NULL;
CPLErrorReset();
pResult = CPLHTTPFetch( osNewURL, NULL );
if( pResult != NULL && pResult->nDataLen != 0 && CPLGetLastErrorNo() == 0 &&
pResult->nStatus == 0 )
{
const char* pszCount = strstr((const char*)pResult->pabyData, "\"count\"");
if( pszCount )
{
pszCount = strchr(pszCount, ':');
if( pszCount )
{
pszCount++;
nFeatureCount = CPLAtoGIntBig(pszCount);
}
}
}
CPLHTTPDestroyResult( pResult );
}
if( nFeatureCount < 0 )
nFeatureCount = OGRLayer::GetFeatureCount(bForce);
return nFeatureCount;
}
OGRErr OGRESRIFeatureServiceLayer::GetExtent(OGREnvelope *psExtent, int bForce)
{
OGRErr eErr = OGRERR_FAILURE;
CPLString osNewURL = CPLURLAddKVP(poDS->GetURL(), "returnExtentOnly", "true");
osNewURL = CPLURLAddKVP(osNewURL, "f", "geojson");
CPLErrorReset();
CPLHTTPResult* pResult = CPLHTTPFetch( osNewURL, NULL );
if( pResult != NULL && pResult->nDataLen != 0 && CPLGetLastErrorNo() == 0 &&
pResult->nStatus == 0 )
{
const char* pszBBox = strstr((const char*)pResult->pabyData, "\"bbox\"");
if( pszBBox )
{
pszBBox = strstr(pszBBox, ":[");
if( pszBBox )
{
pszBBox+=2;
char** papszTokens = CSLTokenizeString2(pszBBox, ",", 0);
if( CSLCount(papszTokens) >= 4 )
{
psExtent->MinX = CPLAtof(papszTokens[0]);
psExtent->MinY = CPLAtof(papszTokens[1]);
psExtent->MaxX = CPLAtof(papszTokens[2]);
psExtent->MaxY = CPLAtof(papszTokens[3]);
eErr = OGRERR_NONE;
}
CSLDestroy(papszTokens);
}
}
}
CPLHTTPDestroyResult( pResult );
if( eErr == OGRERR_FAILURE )
eErr = OGRLayer::GetExtent(psExtent, bForce);
return eErr;
}
OGRFieldType GeoJSONStringPropertyToFieldType( json_object* poObject )
{
if (poObject == NULL) {
return OFTString;
}
const char* pszStr = json_object_get_string( poObject );
OGRField sWrkField;
CPLPushErrorHandler(CPLQuietErrorHandler);
int bSuccess = OGRParseDate( pszStr, &sWrkField, 0 );
CPLPopErrorHandler();
CPLErrorReset();
if( bSuccess )
{
int bHasDate = strchr( pszStr, '/' ) != NULL ||
strchr( pszStr, '-' ) != NULL;
int bHasTime = strchr( pszStr, ':' ) != NULL;
if( bHasDate && bHasTime )
return OFTDateTime;
else if( bHasDate )
return OFTDate;
else
return OFTTime;
}
return OFTString;
}
/**********************************************************************
* TABSeamless::OpenNextBaseTable()
*
* Open the next base table in the dataset, using GetNextFeature() so that
* the spatial filter is respected.
*
* m_bEOF will be set if there are no more base tables to read.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABSeamless::OpenNextBaseTable(GBool bTestOpenNoError /*=FALSE*/)
{
CPLAssert(m_poIndexTable);
TABFeature *poIndexFeature = (TABFeature*)m_poIndexTable->GetNextFeature();
if (poIndexFeature)
{
if (OpenBaseTable(poIndexFeature, bTestOpenNoError) != 0)
{
// Open Failed... an error has already been reported.
if (bTestOpenNoError)
CPLErrorReset();
delete poIndexFeature;
return -1;
}
delete poIndexFeature;
m_bEOF = FALSE;
}
else
{
// Reached EOF
m_bEOF = TRUE;
}
return 0;
}
/**********************************************************************
* E00ReadOpen()
*
* Try to open a E00 file given its filename and return a E00ReadPtr handle.
*
* Returns NULL if the file could not be opened or if it does not
* appear to be a valid E00 file.
**********************************************************************/
E00ReadPtr E00ReadOpen(const char *pszFname)
{
E00ReadPtr psInfo = NULL;
FILE *fp;
CPLErrorReset();
/* Open the file
*/
fp = VSIFOpen(pszFname, "rt");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Failed to open %s: %s", pszFname, strerror(errno));
return NULL;
}
/* File was succesfully opened, allocate and initialize a
* E00ReadPtr handle and check that the file is valid.
*/
psInfo = (E00ReadPtr)CPLCalloc(1, sizeof(struct _E00ReadInfo));
psInfo->fp = fp;
psInfo = _E00ReadTestOpen(psInfo);
if (psInfo == NULL)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"%s is not a valid E00 file.", pszFname);
}
return psInfo;
}
/**********************************************************************
* E00WriteCallbackOpen()
*
* This is an alternative to E00WriteOpen() for cases where you want to
* do all the file management yourself. You open/close the file yourself
* and provide a callback functions to write one line at a time to the
* file. pRefData is your handle on the physical file and can
* be whatever you want... it is not used by the library, it will be
* passed directly to your callback function when it is called.
*
* The callback function must have the following C prototype:
*
* int myWriteNextLine(void *pRefData, const char *pszLine);
*
* Like printf() does, myWriteNextLine() should return a positive
* value on success (the number of chars written)
* or -1 if an error happened.
* The value passed by the library in pszLine will not be terminated
* by a '\n' character... it is assumed that the myWriteNextLine()
* implementation will take care of terminating the line with a
* '\n' if necessary.
*
* nComprLevel must be one of:
* E00_COMPR_NONE, E00_COMPR_PARTIAL or E00_COMPR_FULL
*
* E00WriteCallbackOpen() returns a new E00ReadWritePtr handle.
* E00WriteClose() will eventually have to be called to release
* the resources used by the new handle.
**********************************************************************/
E00WritePtr E00WriteCallbackOpen(void *pRefData,
int (*pfnWriteNextLine)(void *, const char *),
int nComprLevel)
{
E00WritePtr psInfo = NULL;
CPLErrorReset();
/* Make sure we received a valid function pointer
*/
if (pfnWriteNextLine == NULL)
{
CPLError(CE_Failure, CPLE_IllegalArg,
"Invalid function pointer!");
return NULL;
}
/* Allocate and initialize a E00ReadPtr handle.
*/
psInfo = (E00WritePtr)CPLCalloc(1, sizeof(struct _E00WriteInfo));
psInfo->pRefData = pRefData;
psInfo->pfnWriteNextLine = pfnWriteNextLine;
psInfo->nComprLevel = nComprLevel;
return psInfo;
}
void QgsNewOgrConnection::testConnection()
{
QString uri;
uri = createDatabaseURI( cmbDatabaseTypes->currentText(),
txtHost->text(),
txtDatabase->text(),
txtPort->text(),
mAuthSettingsDatabase->configId(),
mAuthSettingsDatabase->username(),
mAuthSettingsDatabase->password(),
true );
QgsDebugMsg( "Connecting using uri = " + uri );
OGRRegisterAll();
OGRDataSourceH poDS;
OGRSFDriverH pahDriver;
CPLErrorReset();
poDS = OGROpen( uri.toUtf8().constData(), false, &pahDriver );
if ( !poDS )
{
QMessageBox::information( this, tr( "Test Connection" ), tr( "Connection failed - Check settings and try again.\n\nExtended error information:\n%1" ).arg( QString::fromUtf8( CPLGetLastErrorMsg() ) ) );
}
else
{
QMessageBox::information( this, tr( "Test Connection" ), tr( "Connection to %1 was successful." ).arg( uri ) );
OGRReleaseDataSource( poDS );
}
}
void OGRESRIJSONReader::ReadLayers( OGRGeoJSONDataSource* poDS,
GeoJSONSourceType eSourceType )
{
CPLAssert( nullptr == poLayer_ );
if( nullptr == poGJObject_ )
{
CPLDebug( "ESRIJSON",
"Missing parsed ESRIJSON data. Forgot to call Parse()?" );
return;
}
OGRSpatialReference* poSRS = OGRESRIJSONReadSpatialReference( poGJObject_ );
const char* pszName = "ESRIJSON";
if( eSourceType == eGeoJSONSourceFile )
{
pszName = poDS->GetDescription();
if( STARTS_WITH_CI(pszName, "ESRIJSON:") )
pszName += strlen("ESRIJSON:");
pszName = CPLGetBasename(pszName);
}
auto eGeomType = OGRESRIJSONGetGeometryType(poGJObject_);
if( eGeomType == wkbNone && poSRS != nullptr )
{
eGeomType = wkbUnknown;
}
poLayer_ = new OGRGeoJSONLayer( pszName, poSRS,
eGeomType,
poDS, nullptr );
if( poSRS != nullptr )
poSRS->Release();
if( !GenerateLayerDefn() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer schema generation failed." );
delete poLayer_;
return;
}
OGRGeoJSONLayer *poThisLayer = ReadFeatureCollection( poGJObject_ );
if( poThisLayer == nullptr )
{
delete poLayer_;
return;
}
CPLErrorReset();
poLayer_->DetectGeometryType();
poDS->AddLayer(poLayer_);
}
CPLErr VRTSourcedRasterBand::XMLInit( CPLXMLNode * psTree,
const char *pszVRTPath )
{
CPLErr eErr;
eErr = VRTRasterBand::XMLInit( psTree, pszVRTPath );
if( eErr != CE_None )
return eErr;
/* -------------------------------------------------------------------- */
/* Validate a bit. */
/* -------------------------------------------------------------------- */
if( psTree == NULL || psTree->eType != CXT_Element
|| (!EQUAL(psTree->pszValue,"VRTSourcedRasterBand")
&& !EQUAL(psTree->pszValue,"VRTRasterBand")
&& !EQUAL(psTree->pszValue,"VRTDerivedRasterBand")) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Invalid node passed to VRTSourcedRasterBand::XMLInit()." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Process sources. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psChild;
VRTDriver *poDriver = (VRTDriver *) GDALGetDriverByName( "VRT" );
for( psChild = psTree->psChild;
psChild != NULL && poDriver != NULL;
psChild = psChild->psNext)
{
VRTSource *poSource;
if( psChild->eType != CXT_Element )
continue;
CPLErrorReset();
poSource = poDriver->ParseSource( psChild, pszVRTPath );
if( poSource != NULL )
AddSource( poSource );
else if( CPLGetLastErrorType() != CE_None )
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Done. */
/* -------------------------------------------------------------------- */
if( nSources == 0 )
CPLDebug( "VRT", "No valid sources found for band in VRT file:\n%s",
pszVRTPath );
return CE_None;
}
/**********************************************************************
* E00ReadClose()
*
* Close input file and release any memory used by the E00ReadPtr.
**********************************************************************/
void E00ReadClose(E00ReadPtr psInfo)
{
CPLErrorReset();
if (psInfo)
{
if (psInfo->fp)
VSIFClose(psInfo->fp);
CPLFree(psInfo);
}
}
// *************************************************************
// RemoveStyle()
// *************************************************************
bool OgrStyleHelper::RemoveStyle(GDALDataset* dataset, CStringW styleTableName, CStringW layerName, CStringW styleName)
{
USES_CONVERSION;
CStringW sql;
sql.Format(L"DELETE FROM %s WHERE layername = '%s' AND stylename = '%s'", styleTableName, layerName, styleName);
CPLErrorReset();
OGRLayer* layer = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL);
dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL);
return CPLGetLastErrorNo() == OGRERR_NONE;
}
OGRLayer * OGRCARTODBDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* Skip leading spaces */
while(*pszSQLCommand == ' ')
pszSQLCommand ++;
/* -------------------------------------------------------------------- */
/* Use generic implementation for recognized dialects */
/* -------------------------------------------------------------------- */
if( IsGenericSQLDialect(pszDialect) )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Special case DELLAYER: command. */
/* -------------------------------------------------------------------- */
if( EQUALN(pszSQLCommand,"DELLAYER:",9) )
{
const char *pszLayerName = pszSQLCommand + 9;
while( *pszLayerName == ' ' )
pszLayerName++;
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(papoLayers[iLayer]->GetName(),
pszLayerName ))
{
DeleteLayer( iLayer );
break;
}
}
return NULL;
}
OGRCARTODBResultLayer* poLayer = new OGRCARTODBResultLayer( this, pszSQLCommand );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
CPLErrorReset();
poLayer->GetLayerDefn();
if( CPLGetLastErrorNo() != 0 )
{
delete poLayer;
return NULL;
}
return poLayer;
}
OGRLayer * OGRWalkDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Use generic implementation for recognized dialects */
/* -------------------------------------------------------------------- */
if( IsGenericSQLDialect(pszDialect) )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Execute normal SQL statement in Walk. */
/* Table_name = Layer_name + Postfix */
/* Postfix: "Features", "Annotations" or "Styles" */
/* -------------------------------------------------------------------- */
CPLODBCStatement *poStmt = new CPLODBCStatement( &oSession );
CPLDebug( "Walk", "ExecuteSQL(%s) called.", pszSQLCommand );
poStmt->Append( pszSQLCommand );
if( !poStmt->ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s", oSession.GetLastError() );
delete poStmt;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Are there result columns for this statement? */
/* -------------------------------------------------------------------- */
if( poStmt->GetColCount() == 0 )
{
delete poStmt;
CPLErrorReset();
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a results layer. It will take ownership of the */
/* statement. */
/* -------------------------------------------------------------------- */
OGRWalkSelectLayer *poLayer = NULL;
poLayer = new OGRWalkSelectLayer( this, poStmt );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
return poLayer;
}
static OGRLayer* GetLayerAndOverwriteIfNecessary(GDALDataset *poDstDS,
const char* pszNewLayerName,
int bOverwrite,
int* pbErrorOccured)
{
if( pbErrorOccured )
*pbErrorOccured = FALSE;
/* GetLayerByName() can instanciate layers that would have been */
/* 'hidden' otherwise, for example, non-spatial tables in a */
/* Postgis-enabled database, so this apparently useless command is */
/* not useless... (#4012) */
CPLPushErrorHandler(CPLQuietErrorHandler);
OGRLayer* poDstLayer = poDstDS->GetLayerByName(pszNewLayerName);
CPLPopErrorHandler();
CPLErrorReset();
int iLayer = -1;
if (poDstLayer != NULL)
{
int nLayerCount = poDstDS->GetLayerCount();
for( iLayer = 0; iLayer < nLayerCount; iLayer++ )
{
OGRLayer *poLayer = poDstDS->GetLayer(iLayer);
if (poLayer == poDstLayer)
break;
}
if (iLayer == nLayerCount)
/* shouldn't happen with an ideal driver */
poDstLayer = NULL;
}
/* -------------------------------------------------------------------- */
/* If the user requested overwrite, and we have the layer in */
/* question we need to delete it now so it will get recreated */
/* (overwritten). */
/* -------------------------------------------------------------------- */
if( poDstLayer != NULL && bOverwrite )
{
if( poDstDS->DeleteLayer( iLayer ) != OGRERR_NONE )
{
fprintf( stderr,
"DeleteLayer() failed when overwrite requested.\n" );
if( pbErrorOccured )
*pbErrorOccured = TRUE;
}
poDstLayer = NULL;
}
return poDstLayer;
}
GDALDatasetH gv_manager_get_dataset( GvManager *manager, const char * filename)
{
int i;
GvDataset *ds;
GDALDatasetH dataset;
/*
* Check for dataset in existing list of open files. Note that our
* filename check does not account for different possible names for
* one dataset.
*/
for( i = 0; i < manager->datasets->len; i++ )
{
ds = (GvDataset *) g_ptr_array_index(manager->datasets, i);
if( EQUAL(GDALGetDescription(ds->dataset),filename) )
{
return ds->dataset;
}
}
/*
* Try to open the dataset, preferably with update access. We don't
* want to report update access errors so we supress error reporting
* temporarily.
*/
CPLErrorReset();
CPLPushErrorHandler( CPLQuietErrorHandler );
dataset = GDALOpen( filename, GA_Update );
CPLPopErrorHandler();
if( dataset == NULL )
{
dataset = GDALOpen( filename, GA_ReadOnly );
}
if( dataset == NULL )
return NULL;
/*
* Add the dataset to the list of managed datasets.
*/
ds = g_new(GvDataset,1);
ds->dataset = dataset;
ds->rasters = g_new0(GvRaster *, GDALGetRasterCount(dataset));
g_ptr_array_add( manager->datasets, ds );
return dataset;
}
/**********************************************************************
* TABSeamless::OpenBaseTable()
*
* Open the base table for specified IndexFeature.
*
* Returns 0 on success, -1 on error.
**********************************************************************/
int TABSeamless::OpenBaseTable(int nTableId, GBool bTestOpenNoError /*=FALSE*/)
{
if (nTableId == -1)
{
// Open first table from dataset
m_poIndexTable->ResetReading();
if (OpenNextBaseTable(bTestOpenNoError) != 0)
{
// Open Failed... an error has already been reported.
if (bTestOpenNoError)
CPLErrorReset();
return -1;
}
}
else if (nTableId == m_nCurBaseTableId && m_poCurBaseTable != NULL)
{
// The right table is already opened. Not much to do!
m_poCurBaseTable->ResetReading();
return 0;
}
else
{
TABFeature *poIndexFeature = m_poIndexTable->GetFeatureRef(nTableId);
if (poIndexFeature)
{
if (OpenBaseTable(poIndexFeature, bTestOpenNoError) != 0)
{
// Open Failed... an error has already been reported.
if (bTestOpenNoError)
CPLErrorReset();
return -1;
}
}
}
return 0;
}
SEXP
RGDAL_OpenDataset(SEXP filename, SEXP read_only, SEXP silent) {
const char *fn = asString(filename);
GDALAccess RWFlag;
if (asLogical(read_only))
RWFlag = GA_ReadOnly;
else
RWFlag = GA_Update;
/* Modification suggested by Even Rouault, 2009-08-08: */
CPLErrorReset();
if (asLogical(silent))
CPLPushErrorHandler(CPLQuietErrorHandler);
else
installErrorHandler();
GDALDataset *pDataset = (GDALDataset *) GDALOpen(fn, RWFlag);
if (pDataset == NULL)
error("%s\n", CPLGetLastErrorMsg());
if (asLogical(silent))
CPLPopErrorHandler();
else
uninstallErrorHandlerAndTriggerError();
/* Similarly to SWIG bindings, the following lines will cause
RGDAL_OpenDataset() to fail on - uncleared - errors even if pDataset is not
NULL. They could also be just removed. While pDataset != NULL, there's some
hope ;-) */
/* CPLErr eclass = CPLGetLastErrorType();
if (pDataset != NULL && eclass == CE_Failure) {
GDALClose(pDataset);
pDataset = NULL;
__errorHandler(eclass, CPLGetLastErrorNo(), CPLGetLastErrorMsg());
}*/
SEXP sxpHandle = R_MakeExternalPtr((void *) pDataset,
mkChar("GDAL Dataset"),
R_NilValue);
return(sxpHandle);
}
/**********************************************************************
* E00ReadNextLine()
*
* Return the next line of input from the E00 file or NULL if we reached EOF.
*
* Returns a reference to an internal buffer whose contents will be valid
* only until the next call to this function.
**********************************************************************/
const char *E00ReadNextLine(E00ReadPtr psInfo)
{
const char *pszLine = NULL;
char *pszPtr;
CPLErrorReset();
if (psInfo && !psInfo->bEOF)
{
if (!psInfo->bIsCompressed)
{
/* Uncompressed file... return line directly.
*/
_ReadNextSourceLine(psInfo);
pszLine = psInfo->szInBuf;
}
else if (psInfo->bIsCompressed && psInfo->nInputLineNo == 0)
{
/* Header line in a compressed file... return line
* after replacing "EXP 1" with "EXP 0". E00ReadOpen()
* has already verified that this line starts with "EXP "
*/
_ReadNextSourceLine(psInfo);
if ( (pszPtr = strstr(psInfo->szInBuf, " 1")) != NULL)
pszPtr[1] = '0';
pszLine = psInfo->szInBuf;
}
else
{
if (psInfo->nInputLineNo == 1)
{
/* We just read the header line... reload the input buffer
*/
_ReadNextSourceLine(psInfo);
}
/* Uncompress the next line of input and return it
*/
pszLine = _UncompressNextLine(psInfo);
}
/* If we just reached EOF then make sure we don't add an extra
* empty line at the end of the uncompressed oputput.
*/
if (psInfo->bEOF && strlen(pszLine) == 0)
pszLine = NULL;
}
return pszLine;
}
OGRLayer * OGRODBCDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Use generic implementation for recognized dialects */
/* -------------------------------------------------------------------- */
if( IsGenericSQLDialect(pszDialect) )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Execute statement. */
/* -------------------------------------------------------------------- */
CPLODBCStatement *poStmt = new CPLODBCStatement( &oSession );
CPLDebug( "ODBC", "ExecuteSQL(%s) called.", pszSQLCommand );
poStmt->Append( pszSQLCommand );
if( !poStmt->ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s", oSession.GetLastError() );
delete poStmt;
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Are there result columns for this statement? */
/* -------------------------------------------------------------------- */
if( poStmt->GetColCount() == 0 )
{
delete poStmt;
CPLErrorReset();
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Create a results layer. It will take ownership of the */
/* statement. */
/* -------------------------------------------------------------------- */
OGRODBCSelectLayer* poLayer = new OGRODBCSelectLayer( this, poStmt );
if( poSpatialFilter != nullptr )
poLayer->SetSpatialFilter( poSpatialFilter );
return poLayer;
}
// *************************************************************
// SaveStyle()
// *************************************************************
bool OgrStyleHelper::SaveStyle(GDALDataset* dataset, CStringW xml, CStringW layerName, CStringW styleName)
{
xml.Replace(L"\n", L"");
xml.Replace(L"'", L"''''");
if (xml.GetLength() == 0) return false;
CStringW sql;
sql.Format(L"INSERT INTO %s(layername, stylename, style) VALUES ('%s', '%s', '%s')", GetStyleTableName(layerName),
layerName, styleName, xml);
CPLErrorReset();
OGRLayer* layer = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL);
return CPLGetLastErrorNo() == OGRERR_NONE;
}
OGRLayer * OGRGeomediaDataSource::ExecuteSQL( const char *pszSQLCommand,
OGRGeometry *poSpatialFilter,
const char *pszDialect )
{
/* -------------------------------------------------------------------- */
/* Use generic imlplementation for OGRSQL dialect. */
/* -------------------------------------------------------------------- */
if( pszDialect != NULL && EQUAL(pszDialect,"OGRSQL") )
return OGRDataSource::ExecuteSQL( pszSQLCommand,
poSpatialFilter,
pszDialect );
/* -------------------------------------------------------------------- */
/* Execute statement. */
/* -------------------------------------------------------------------- */
CPLODBCStatement *poStmt = new CPLODBCStatement( &oSession );
poStmt->Append( pszSQLCommand );
if( !poStmt->ExecuteSQL() )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s", oSession.GetLastError() );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Are there result columns for this statement? */
/* -------------------------------------------------------------------- */
if( poStmt->GetColCount() == 0 )
{
delete poStmt;
CPLErrorReset();
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a results layer. It will take ownership of the */
/* statement. */
/* -------------------------------------------------------------------- */
OGRGeomediaSelectLayer *poLayer = NULL;
poLayer = new OGRGeomediaSelectLayer( this, poStmt );
if( poSpatialFilter != NULL )
poLayer->SetSpatialFilter( poSpatialFilter );
return poLayer;
}
// *************************************************************
// CreateStyleTable()
// *************************************************************
int OgrStyleHelper::CreateStyleTable(GDALDataset* dataset, CStringW layerName)
{
if (OgrHelper::IsPostGisDatasource(dataset))
{
CPLErrorReset();
CStringW schemaName = GetDbSchemeName(layerName, true);
CStringW sql;
sql.Format(L"CREATE Table %s (StyleId serial primary key, LayerName varchar(128), StyleName varchar(128), Style text, CONSTRAINT layer_style_unique UNIQUE (LayerName,StyleName));", GetStyleTableName());
OGRLayer* lyr = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL);
return CPLGetLastErrorNo() == OGRERR_NONE ? tkNO_ERROR : tkOGR_FAILED_TO_CREATE_STYLE_TABLE;
}
else {
return tkOGR_NO_STYLE_TABLE_CREATION;
}
}
/**********************************************************************
* E00ReadRewind()
*
* Rewind the E00ReadPtr. Allows to start another read pass on the
* input file.
**********************************************************************/
void E00ReadRewind(E00ReadPtr psInfo)
{
CPLErrorReset();
psInfo->szInBuf[0] = psInfo->szOutBuf[0] = '\0';
psInfo->iInBufPtr = 0;
psInfo->nInputLineNo = 0;
if (psInfo->pfnReadRewind == NULL)
VSIRewind(psInfo->fp);
else
psInfo->pfnReadRewind(psInfo->pRefData);
psInfo->bEOF = 0;
}
/**********************************************************************
* E00WriteClose()
*
* Close output file and release any memory used by the E00WritePtr.
**********************************************************************/
void E00WriteClose(E00WritePtr psInfo)
{
CPLErrorReset();
if (psInfo)
{
/* Flush output buffer before closing file.
*/
if (psInfo->iOutBufPtr > 0)
_WriteNextCompressedLine(psInfo, 1);
if (psInfo->fp)
fclose(psInfo->fp);
CPLFree(psInfo);
}
}
