int OGRLayer::GetFeatureCount( int bForce )
{
OGRFeature *poFeature;
int nFeatureCount = 0;
if( !bForce )
return -1;
ResetReading();
while( (poFeature = GetNextFeature()) != NULL )
{
nFeatureCount++;
delete poFeature;
}
ResetReading();
return nFeatureCount;
}
OGRErr OGRLayer::GetExtent(OGREnvelope *psExtent, int bForce )
{
OGRFeature *poFeature;
OGREnvelope oEnv;
GBool bExtentSet = FALSE;
if( !bForce )
return OGRERR_FAILURE;
ResetReading();
while( (poFeature = GetNextFeature()) != NULL )
{
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if (poGeom && !bExtentSet)
{
poGeom->getEnvelope(psExtent);
bExtentSet = TRUE;
}
else if (poGeom)
{
poGeom->getEnvelope(&oEnv);
if (oEnv.MinX < psExtent->MinX)
psExtent->MinX = oEnv.MinX;
if (oEnv.MinY < psExtent->MinY)
psExtent->MinY = oEnv.MinY;
if (oEnv.MaxX > psExtent->MaxX)
psExtent->MaxX = oEnv.MaxX;
if (oEnv.MaxY > psExtent->MaxY)
psExtent->MaxY = oEnv.MaxY;
}
delete poFeature;
}
ResetReading();
return (bExtentSet ? OGRERR_NONE : OGRERR_FAILURE);
}
int OGRAmigoCloudResultLayer::IsOK()
{
CPLErrorReset();
poFirstFeature = GetNextFeature();
return CPLGetLastErrorType() == 0;
}
OGRErr OGRLayer::GetExtent(OGREnvelope *psExtent, int bForce )
{
OGRFeature *poFeature;
OGREnvelope oEnv;
GBool bExtentSet = FALSE;
psExtent->MinX = 0.0;
psExtent->MaxX = 0.0;
psExtent->MinY = 0.0;
psExtent->MaxY = 0.0;
/* -------------------------------------------------------------------- */
/* If this layer has a none geometry type, then we can */
/* reasonably assume there are not extents available. */
/* -------------------------------------------------------------------- */
if( GetLayerDefn()->GetGeomType() == wkbNone )
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* If not forced, we should avoid having to scan all the */
/* features and just return a failure. */
/* -------------------------------------------------------------------- */
if( !bForce )
return OGRERR_FAILURE;
/* -------------------------------------------------------------------- */
/* OK, we hate to do this, but go ahead and read through all */
/* the features to collect geometries and build extents. */
/* -------------------------------------------------------------------- */
ResetReading();
while( (poFeature = GetNextFeature()) != NULL )
{
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if (poGeom == NULL || poGeom->IsEmpty())
{
/* Do nothing */
}
else if (!bExtentSet)
{
poGeom->getEnvelope(psExtent);
bExtentSet = TRUE;
}
else
{
poGeom->getEnvelope(&oEnv);
if (oEnv.MinX < psExtent->MinX)
psExtent->MinX = oEnv.MinX;
if (oEnv.MinY < psExtent->MinY)
psExtent->MinY = oEnv.MinY;
if (oEnv.MaxX > psExtent->MaxX)
psExtent->MaxX = oEnv.MaxX;
if (oEnv.MaxY > psExtent->MaxY)
psExtent->MaxY = oEnv.MaxY;
}
delete poFeature;
}
ResetReading();
return (bExtentSet ? OGRERR_NONE : OGRERR_FAILURE);
}
void SDTSLineReader::AttachToPolygons( SDTSTransfer * poTransfer,
int iTargetPolyLayer )
{
/* -------------------------------------------------------------------- */
/* We force a filling of the index because when we attach the */
/* lines we are just providing a pointer back to the line */
/* features in this readers index. If they aren't cached in */
/* the index then the pointer will be invalid. */
/* -------------------------------------------------------------------- */
FillIndex();
/* ==================================================================== */
/* Loop over all lines, attaching them to the polygons they */
/* have as right and left faces. */
/* ==================================================================== */
Rewind();
SDTSRawLine *poLine;
SDTSPolygonReader *poPolyReader = NULL;
while( (poLine = reinterpret_cast<SDTSRawLine *>( GetNextFeature()) )
!= NULL )
{
/* -------------------------------------------------------------------- */
/* Skip lines with the same left and right polygon face. These */
/* are dangles, and will not contribute in any useful fashion */
/* to the resulting polygon. */
/* -------------------------------------------------------------------- */
if( poLine->oLeftPoly.nRecord == poLine->oRightPoly.nRecord )
continue;
/* -------------------------------------------------------------------- */
/* If we don't have our indexed polygon reader yet, try to get */
/* it now. */
/* -------------------------------------------------------------------- */
if( poPolyReader == NULL )
{
int iPolyLayer = -1;
if( poLine->oLeftPoly.nRecord != -1 )
{
iPolyLayer = poTransfer->FindLayer(poLine->oLeftPoly.szModule);
}
else if( poLine->oRightPoly.nRecord != -1 )
{
iPolyLayer = poTransfer->FindLayer(poLine->oRightPoly.szModule);
}
if( iPolyLayer == -1 )
continue;
if( iPolyLayer != iTargetPolyLayer )
continue;
poPolyReader = reinterpret_cast<SDTSPolygonReader *>(
poTransfer->GetLayerIndexedReader(iPolyLayer) );
if( poPolyReader == NULL )
return;
}
/* -------------------------------------------------------------------- */
/* Attach line to right and/or left polygons. */
/* -------------------------------------------------------------------- */
if( poLine->oLeftPoly.nRecord != -1 )
{
SDTSRawPolygon *poPoly = reinterpret_cast<SDTSRawPolygon *>(
poPolyReader->GetIndexedFeatureRef( poLine->oLeftPoly.nRecord ) );
if( poPoly != NULL )
poPoly->AddEdge( poLine );
}
if( poLine->oRightPoly.nRecord != -1 )
{
SDTSRawPolygon *poPoly = reinterpret_cast<SDTSRawPolygon *>(
poPolyReader->GetIndexedFeatureRef(
poLine->oRightPoly.nRecord ) );
if( poPoly != NULL )
poPoly->AddEdge( poLine );
}
}
}
OGRFeature *OGRNTFLayer::GetNextFeature()
{
OGRFeature *poFeature = NULL;
/* -------------------------------------------------------------------- */
/* Have we processed all features already? */
/* -------------------------------------------------------------------- */
if( iCurrentReader == poDS->GetFileCount() )
return NULL;
/* -------------------------------------------------------------------- */
/* Do we need to open a file? */
/* -------------------------------------------------------------------- */
if( iCurrentReader == -1 )
{
iCurrentReader++;
nCurrentPos = -1;
}
NTFFileReader *poCurrentReader = poDS->GetFileReader(iCurrentReader);
if( poCurrentReader->GetFP() == NULL )
{
poCurrentReader->Open();
}
/* -------------------------------------------------------------------- */
/* Ensure we are reading on from the same point we were reading */
/* from for the last feature, even if some other access */
/* mechanism has moved the file pointer. */
/* -------------------------------------------------------------------- */
if( nCurrentPos != -1 )
poCurrentReader->SetFPPos( nCurrentPos, nCurrentFID );
else
poCurrentReader->Reset();
/* -------------------------------------------------------------------- */
/* Read features till we find one that satisfies our current */
/* spatial criteria. */
/* -------------------------------------------------------------------- */
while( TRUE )
{
poFeature = poCurrentReader->ReadOGRFeature( this );
if( poFeature == NULL )
break;
m_nFeaturesRead++;
if( (m_poFilterGeom == NULL
|| poFeature->GetGeometryRef() == NULL
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == NULL
|| m_poAttrQuery->Evaluate( poFeature )) )
break;
delete poFeature;
}
/* -------------------------------------------------------------------- */
/* If we get NULL the file must be all consumed, advance to the */
/* next file that contains features for this layer. */
/* -------------------------------------------------------------------- */
if( poFeature == NULL )
{
poCurrentReader->Close();
if( poDS->GetOption("CACHING") != NULL
&& EQUAL(poDS->GetOption("CACHING"),"OFF") )
{
poCurrentReader->DestroyIndex();
}
do {
iCurrentReader++;
} while( iCurrentReader < poDS->GetFileCount()
&& !poDS->GetFileReader(iCurrentReader)->TestForLayer(this) );
nCurrentPos = -1;
nCurrentFID = 1;
poFeature = GetNextFeature();
}
else
{
poCurrentReader->GetFPPos(&nCurrentPos, &nCurrentFID);
}
return poFeature;
}
OGRFeature *OGRNTFDataSource::GetNextFeature()
{
OGRFeature *poFeature = NULL;
/* -------------------------------------------------------------------- */
/* If we have already read all the conventional features, we */
/* should try and return feature class features. */
/* -------------------------------------------------------------------- */
if( iCurrentReader == nNTFFileCount )
{
if( iCurrentFC < nFCCount )
return poFCLayer->GetFeature( iCurrentFC++ );
else
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we need to open a file? */
/* -------------------------------------------------------------------- */
if( iCurrentReader == -1 )
{
iCurrentReader++;
nCurrentPos = -1;
}
if( papoNTFFileReader[iCurrentReader]->GetFP() == NULL )
{
papoNTFFileReader[iCurrentReader]->Open();
}
/* -------------------------------------------------------------------- */
/* Ensure we are reading on from the same point we were reading */
/* from for the last feature, even if some other access */
/* mechanism has moved the file pointer. */
/* -------------------------------------------------------------------- */
if( nCurrentPos != -1 )
papoNTFFileReader[iCurrentReader]->SetFPPos( nCurrentPos,
nCurrentFID );
/* -------------------------------------------------------------------- */
/* Read a feature. If we get NULL the file must be all */
/* consumed, advance to the next file. */
/* -------------------------------------------------------------------- */
poFeature = papoNTFFileReader[iCurrentReader]->ReadOGRFeature();
if( poFeature == NULL )
{
papoNTFFileReader[iCurrentReader]->Close();
if( GetOption("CACHING") != NULL
&& EQUAL(GetOption("CACHING"),"OFF") )
papoNTFFileReader[iCurrentReader]->DestroyIndex();
iCurrentReader++;
nCurrentPos = -1;
nCurrentFID = 1;
poFeature = GetNextFeature();
}
else
{
papoNTFFileReader[iCurrentReader]->GetFPPos(&nCurrentPos,
&nCurrentFID);
}
return poFeature;
}
int OGRMySQLDataSource::Open( const char * pszNewName, char** papszOpenOptionsIn,
int bUpdate )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Use options process to get .my.cnf file contents. */
/* -------------------------------------------------------------------- */
int nPort = 0;
char **papszTableNames=nullptr;
std::string oHost, oPassword, oUser, oDB;
CPLString osNewName(pszNewName);
const char* apszOpenOptions[] = { "dbname", "port", "user", "password",
"host", "tables" };
for(int i=0; i <(int)(sizeof(apszOpenOptions)/sizeof(char*));i++)
{
const char* pszVal = CSLFetchNameValue(papszOpenOptionsIn, apszOpenOptions[i]);
if( pszVal )
{
if( osNewName.back() != ':' )
osNewName += ",";
if( i > 0 )
{
osNewName += apszOpenOptions[i];
osNewName += "=";
}
if( EQUAL(apszOpenOptions[i], "tables") )
{
for( ; *pszVal; ++pszVal )
{
if( *pszVal == ',' )
osNewName += ";";
else
osNewName += *pszVal;
}
}
else
osNewName += pszVal;
}
}
/* -------------------------------------------------------------------- */
/* Parse out connection information. */
/* -------------------------------------------------------------------- */
char **papszItems = CSLTokenizeString2( osNewName+6, ",",
CSLT_HONOURSTRINGS );
if( CSLCount(papszItems) < 1 )
{
CSLDestroy( papszItems );
CPLError( CE_Failure, CPLE_AppDefined,
"MYSQL: request missing databasename." );
return FALSE;
}
oDB = papszItems[0];
for( int i = 1; papszItems[i] != nullptr; i++ )
{
if( STARTS_WITH_CI(papszItems[i], "user="******"password="******"host=") )
oHost = papszItems[i] + 5;
else if( STARTS_WITH_CI(papszItems[i], "port=") )
nPort = atoi(papszItems[i] + 5);
else if( STARTS_WITH_CI(papszItems[i], "tables=") )
{
CSLDestroy(papszTableNames);
papszTableNames = CSLTokenizeStringComplex(
papszItems[i] + 7, ";", FALSE, FALSE );
}
else
CPLError( CE_Warning, CPLE_AppDefined,
"'%s' in MYSQL datasource definition not recognised and ignored.", papszItems[i] );
}
CSLDestroy( papszItems );
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
hConn = mysql_init( nullptr );
if( hConn == nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined,
"mysql_init() failed." );
}
/* -------------------------------------------------------------------- */
/* Set desired options on the connection: charset and timeout. */
/* -------------------------------------------------------------------- */
if( hConn )
{
const char *pszTimeoutLength =
CPLGetConfigOption( "MYSQL_TIMEOUT", "0" );
unsigned int timeout = atoi(pszTimeoutLength);
mysql_options(hConn, MYSQL_OPT_CONNECT_TIMEOUT, (char*)&timeout);
mysql_options(hConn, MYSQL_SET_CHARSET_NAME, "utf8" );
}
/* -------------------------------------------------------------------- */
/* Perform connection. */
/* -------------------------------------------------------------------- */
if( hConn
&& mysql_real_connect( hConn,
oHost.length() ? oHost.c_str() : nullptr,
oUser.length() ? oUser.c_str() : nullptr,
oPassword.length() ? oPassword.c_str() : nullptr,
oDB.length() ? oDB.c_str() : nullptr,
nPort, nullptr, CLIENT_INTERACTIVE ) == nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined,
"MySQL connect failed for: %s\n%s",
pszNewName + 6, mysql_error( hConn ) );
mysql_close( hConn );
hConn = nullptr;
}
if( hConn == nullptr )
{
CSLDestroy( papszTableNames );
return FALSE;
}
else
{
// Enable automatic reconnection
#if defined(LIBMYSQL_VERSION_ID) && (LIBMYSQL_VERSION_ID >= 80000)
bool reconnect = 1;
#else
my_bool reconnect = 1;
#endif
// Must be called after mysql_real_connect() on MySQL < 5.0.19
// and at any point on more recent versions.
mysql_options(hConn, MYSQL_OPT_RECONNECT, &reconnect);
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Check version. */
/* -------------------------------------------------------------------- */
auto versionLyr = ExecuteSQL("SELECT VERSION()", nullptr, nullptr);
if( versionLyr )
{
auto versionFeat = versionLyr->GetNextFeature();
if( versionFeat )
{
const char* pszVersion = versionFeat->GetFieldAsString(0);
m_nMajor = atoi(pszVersion);
const char* pszDot = strchr(pszVersion, '.');
if( pszDot )
m_nMinor = atoi(pszDot+1);
m_bIsMariaDB = strstr(pszVersion, "MariaDB") != nullptr;
}
delete versionFeat;
ReleaseResultSet(versionLyr);
}
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == nullptr )
{
MYSQL_RES *hResultSet;
MYSQL_ROW papszRow;
if( mysql_query( hConn, "SHOW TABLES" ) )
{
ReportError( "SHOW TABLES Failed" );
return FALSE;
}
hResultSet = mysql_store_result( hConn );
if( hResultSet == nullptr )
{
ReportError( "mysql_store_result() failed on SHOW TABLES result.");
return FALSE;
}
while( (papszRow = mysql_fetch_row( hResultSet )) != nullptr )
{
if( papszRow[0] == nullptr )
continue;
if( EQUAL(papszRow[0],"spatial_ref_sys")
|| EQUAL(papszRow[0],"geometry_columns") )
continue;
papszTableNames = CSLAddString(papszTableNames, papszRow[0] );
}
mysql_free_result( hResultSet );
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
for( int iRecord = 0;
papszTableNames != nullptr && papszTableNames[iRecord] != nullptr;
iRecord++ )
{
// FIXME: This should be fixed to deal with tables
// for which we can't open because the name is bad/
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return nLayers > 0 || bUpdate;
}