OGRAeronavFAAIAPLayer::OGRAeronavFAAIAPLayer( VSILFILE* fp,
const char* pszLayerName ) :
OGRAeronavFAALayer(fp, pszLayerName)
{
poFeatureDefn->SetGeomType( wkbPoint );
{
OGRFieldDefn oField( "CITY", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
{
OGRFieldDefn oField( "STATE", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
{
OGRFieldDefn oField( "APT_NAME", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
{
OGRFieldDefn oField( "APT_CODE", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
psRecordDesc = &IAP;
for( int i=0; i < psRecordDesc->nFields; i++ )
{
OGRFieldDefn oField( psRecordDesc->pasFields[i].pszFieldName, psRecordDesc->pasFields[i].eType );
oField.SetWidth(psRecordDesc->pasFields[i].nLastCol - psRecordDesc->pasFields[i].nStartCol + 1);
poFeatureDefn->AddFieldDefn( &oField );
}
}
OGRAeronavFAARouteLayer::OGRAeronavFAARouteLayer( VSILFILE* fp,
const char* pszLayerName,
int bIsDPOrSTARSIn ) :
OGRAeronavFAALayer(fp, pszLayerName)
{
bIsDPOrSTARS = bIsDPOrSTARSIn;
poFeatureDefn->SetGeomType( wkbLineString );
if (bIsDPOrSTARS)
{
{
OGRFieldDefn oField( "APT_NAME", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
{
OGRFieldDefn oField( "STATE", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
}
{
OGRFieldDefn oField( "NAME", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
}
OGRPLScenesLayer::OGRPLScenesLayer(OGRPLScenesDataset* poDS,
const char* pszName,
const char* pszBaseURL,
json_object* poObjCount10)
{
this->poDS = poDS;
osBaseURL = pszBaseURL;
SetDescription(pszName);
poFeatureDefn = new OGRFeatureDefn(pszName);
poFeatureDefn->SetGeomType(wkbMultiPolygon);
for(int i = 0; i < (int)sizeof(apsAttrs) / (int)sizeof(apsAttrs[0]); i++)
{
OGRFieldDefn oField(apsAttrs[i].pszName, apsAttrs[i].eType);
poFeatureDefn->AddFieldDefn(&oField);
}
poFeatureDefn->Reference();
poSRS = new OGRSpatialReference(SRS_WKT_WGS84);
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
bEOF = FALSE;
nFeatureCount = -1;
nNextFID = 1;
poGeoJSONDS = NULL;
poGeoJSONLayer = NULL;
poMainFilter = NULL;
nPageSize = atoi(CPLGetConfigOption("PLSCENES_PAGE_SIZE", "1000"));
bStillInFirstPage = FALSE;
bAcquiredAscending = -1;
bFilterMustBeClientSideEvaluated = FALSE;
ResetReading();
if( poObjCount10 != NULL )
{
json_object* poCount = json_object_object_get(poObjCount10, "count");
if( poCount != NULL )
nFeatureCount = MAX(0, json_object_get_int64(poCount));
OGRGeoJSONDataSource* poTmpDS = new OGRGeoJSONDataSource();
OGRGeoJSONReader oReader;
oReader.SetFlattenNestedAttributes(true, '.');
oReader.ReadLayer( poTmpDS, "layer", poObjCount10 );
OGRLayer* poTmpLayer = poTmpDS->GetLayer(0);
if( poTmpLayer )
{
OGRFeatureDefn* poTmpFDefn = poTmpLayer->GetLayerDefn();
std::vector<CPLString> aosNewFields;
for(int i=0;i<poTmpFDefn->GetFieldCount();i++)
{
if( poFeatureDefn->GetFieldIndex(poTmpFDefn->GetFieldDefn(i)->GetNameRef()) < 0 )
aosNewFields.push_back(poTmpFDefn->GetFieldDefn(i)->GetNameRef());
}
std::sort(aosNewFields.begin(), aosNewFields.end(), OGRPLScenesLayerFieldNameComparator);
for(int i=0;i<(int)aosNewFields.size();i++)
{
OGRFieldDefn oField(poTmpFDefn->GetFieldDefn(poTmpFDefn->GetFieldIndex(aosNewFields[i])));
poFeatureDefn->AddFieldDefn(&oField);
}
}
delete poTmpDS;
}
}
/*!
\brief Create OGR layer from VFKDataBlock
\param poDataBlock pointer to VFKDataBlock instance
\return poiter to OGRVFKLayer instance
\return NULL on error
*/
OGRVFKLayer *OGRVFKDataSource::CreateLayer(const VFKDataBlock *poDataBlock)
{
OGRVFKLayer *poLayer;
poLayer = NULL;
/* create an empty layer */
poLayer = new OGRVFKLayer(poDataBlock->GetName(), NULL,
poDataBlock->GetGeometryType(), this);
/* define attributes (properties) */
for (int iField = 0; iField < poDataBlock->GetPropertyCount(); iField++) {
VFKPropertyDefn *poProperty = poDataBlock->GetProperty(iField);
OGRFieldDefn oField(poProperty->GetName(), poProperty->GetType());
if(poProperty->GetWidth() > 0)
oField.SetWidth(poProperty->GetWidth());
if(poProperty->GetPrecision() > 0)
oField.SetPrecision(poProperty->GetPrecision());
poLayer->GetLayerDefn()->AddFieldDefn(&oField);
}
return poLayer;
}
OGRSEGP1Layer::OGRSEGP1Layer( const char* pszFilename,
VSILFILE* fp,
int nLatitudeCol )
{
this->fp = fp;
this->nLatitudeCol = nLatitudeCol;
nNextFID = 0;
bEOF = FALSE;
poSRS = NULL;
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbPoint );
for(int i=0;i<(int)(sizeof(SEGP1Fields)/sizeof(SEGP1Fields[0]));i++)
{
OGRFieldDefn oField( SEGP1Fields[i].pszName,
SEGP1Fields[i].eType );
poFeatureDefn->AddFieldDefn( &oField );
}
bUseEastingNorthingAsGeometry =
CSLTestBoolean(CPLGetConfigOption("SEGP1_USE_EASTING_NORTHING", "NO"));
ResetReading();
}
OGRUKOOAP190Layer::OGRUKOOAP190Layer( const char* pszFilename,
VSILFILE* fpIn ) :
poSRS(nullptr),
fp(fpIn),
bUseEastingNorthingAsGeometry(CPLTestBool(
CPLGetConfigOption("UKOOAP190_USE_EASTING_NORTHING", "NO"))),
nYear(0)
{
nNextFID = 0;
bEOF = false;
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbPoint );
for( int i = 0;
i < static_cast<int>(sizeof(UKOOAP190Fields) /
sizeof(UKOOAP190Fields[0]));
i++ )
{
OGRFieldDefn oField( UKOOAP190Fields[i].pszName,
UKOOAP190Fields[i].eType );
poFeatureDefn->AddFieldDefn( &oField );
}
ParseHeaders();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
}
OGRSEGP1Layer::OGRSEGP1Layer( const char* pszFilename,
VSILFILE* fpIn,
int nLatitudeColIn ) :
poSRS(nullptr),
fp(fpIn),
nLatitudeCol(nLatitudeColIn),
bUseEastingNorthingAsGeometry(CPLTestBool(
CPLGetConfigOption("SEGP1_USE_EASTING_NORTHING", "NO")))
{
nNextFID = 0;
bEOF = false;
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbPoint );
for(int i=0;i<(int)(sizeof(SEGP1Fields)/sizeof(SEGP1Fields[0]));i++)
{
OGRFieldDefn oField( SEGP1Fields[i].pszName,
SEGP1Fields[i].eType );
poFeatureDefn->AddFieldDefn( &oField );
}
OGRSEGP1Layer::ResetReading();
}
OGRUKOOAP190Layer::OGRUKOOAP190Layer( const char* pszFilename,
VSILFILE* fp )
{
this->fp = fp;
nNextFID = 0;
bEOF = FALSE;
poSRS = NULL;
nYear = 0;
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbPoint );
for(int i=0;i<(int)(sizeof(UKOOAP190Fields)/sizeof(UKOOAP190Fields[0]));i++)
{
OGRFieldDefn oField( UKOOAP190Fields[i].pszName,
UKOOAP190Fields[i].eType );
poFeatureDefn->AddFieldDefn( &oField );
}
bUseEastingNorthingAsGeometry =
CSLTestBoolean(CPLGetConfigOption("UKOOAP190_USE_EASTING_NORTHING", "NO"));
ParseHeaders();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
}
OGRHTFMetadataLayer::OGRHTFMetadataLayer(std::vector<CPLString> aosMD)
{
this->aosMD = aosMD;
nNextFID = 0;
poFeatureDefn = new OGRFeatureDefn( "metadata" );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
std::vector<CPLString>::const_iterator iter = aosMD.begin();
std::vector<CPLString>::const_iterator eiter = aosMD.end();
while(iter != eiter)
{
const CPLString& osStr = *iter;
char* pszStr = CPLStrdup(osStr.c_str());
char* pszSep = strstr(pszStr, ": ");
if (pszSep)
{
*pszSep = 0;
int i = 0, j = 0;
for(;pszStr[i];i++)
{
if (pszStr[i] == ' ' || pszStr[i] == '-' || pszStr[i] == '&')
{
if (j > 0 && pszStr[j-1] == '_')
continue;
pszStr[j++] = '_';
}
else if (pszStr[i] == '(' || pszStr[i] == ')')
;
else
pszStr[j++] = pszStr[i];
}
pszStr[j] = 0;
OGRFieldDefn oField( pszStr, OFTString);
poFeatureDefn->AddFieldDefn( &oField );
}
CPLFree(pszStr);
++iter;
}
poFeature = new OGRFeature(poFeatureDefn);
iter = aosMD.begin();
eiter = aosMD.end();
int nField = 0;
while(iter != eiter)
{
const CPLString& osStr = *iter;
const char* pszStr = osStr.c_str();
const char* pszSep = strstr(pszStr, ": ");
if (pszSep)
{
if (pszSep[2] != '*')
poFeature->SetField( nField, pszSep + 2 );
nField ++;
}
++iter;
}
}
OGROpenFileGDBSingleFeatureLayer::OGROpenFileGDBSingleFeatureLayer(const char* pszLayerName,
const char *pszVal )
{
poFeatureDefn = new OGRFeatureDefn( pszLayerName );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
OGRFieldDefn oField( "FIELD_1", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
iNextShapeId = 0;
this->pszVal = pszVal ? CPLStrdup(pszVal) : NULL;
}
OGRSQLiteSingleFeatureLayer::OGRSQLiteSingleFeatureLayer(
const char* pszLayerName,
const char *pszValIn ) :
nVal(0),
pszVal(CPLStrdup(pszValIn)),
poFeatureDefn(new OGRFeatureDefn( "SELECT" )),
iNextShapeId(0)
{
poFeatureDefn->Reference();
OGRFieldDefn oField( pszLayerName, OFTString );
poFeatureDefn->AddFieldDefn( &oField );
}
OGRSQLiteSingleFeatureLayer::OGRSQLiteSingleFeatureLayer(
const char* pszLayerName,
int nVal )
{
poFeatureDefn = new OGRFeatureDefn( "SELECT" );
poFeatureDefn->Reference();
OGRFieldDefn oField( pszLayerName, OFTInteger );
poFeatureDefn->AddFieldDefn( &oField );
iNextShapeId = 0;
this->nVal = nVal;
pszVal = NULL;
}
OGRSQLiteSingleFeatureLayer::OGRSQLiteSingleFeatureLayer(
const char* pszLayerName,
int nValIn ) :
nVal(nValIn),
pszVal(NULL),
poFeatureDefn(new OGRFeatureDefn( "SELECT" )),
iNextShapeId(0)
{
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
OGRFieldDefn oField( pszLayerName, OFTInteger );
poFeatureDefn->AddFieldDefn( &oField );
}
OGRSQLiteSingleFeatureLayer::OGRSQLiteSingleFeatureLayer(
const char* pszLayerName,
const char *pszVal )
{
poFeatureDefn = new OGRFeatureDefn( "SELECT" );
poFeatureDefn->Reference();
OGRFieldDefn oField( pszLayerName, OFTString );
poFeatureDefn->AddFieldDefn( &oField );
iNextShapeId = 0;
nVal = 0;
this->pszVal = CPLStrdup(pszVal);
}
OGRNASLayer *OGRNASDataSource::TranslateNASSchema( GMLFeatureClass *poClass )
{
OGRNASLayer *poLayer;
OGRwkbGeometryType eGType
= (OGRwkbGeometryType) poClass->GetGeometryType();
if( poClass->GetFeatureCount() == 0 )
eGType = wkbUnknown;
/* -------------------------------------------------------------------- */
/* Create an empty layer. */
/* -------------------------------------------------------------------- */
poLayer = new OGRNASLayer( poClass->GetName(), NULL, eGType, this );
/* -------------------------------------------------------------------- */
/* Added attributes (properties). */
/* -------------------------------------------------------------------- */
for( int iField = 0; iField < poClass->GetPropertyCount(); iField++ )
{
GMLPropertyDefn *poProperty = poClass->GetProperty( iField );
OGRFieldType eFType;
if( poProperty->GetType() == GMLPT_Untyped )
eFType = OFTString;
else if( poProperty->GetType() == GMLPT_String )
eFType = OFTString;
else if( poProperty->GetType() == GMLPT_Integer )
eFType = OFTInteger;
else if( poProperty->GetType() == GMLPT_Real )
eFType = OFTReal;
else if( poProperty->GetType() == GMLPT_StringList )
eFType = OFTStringList;
else if( poProperty->GetType() == GMLPT_IntegerList )
eFType = OFTIntegerList;
else if( poProperty->GetType() == GMLPT_RealList )
eFType = OFTRealList;
else
eFType = OFTString;
OGRFieldDefn oField( poProperty->GetName(), eFType );
if ( EQUALN(oField.GetNameRef(), "ogr:", 4) )
oField.SetName(poProperty->GetName()+4);
if( poProperty->GetWidth() > 0 )
oField.SetWidth( poProperty->GetWidth() );
poLayer->GetLayerDefn()->AddFieldDefn( &oField );
}
return poLayer;
}
OGRErr OGRPGDumpLayer::CreateField( OGRFieldDefn *poFieldIn,
int bApproxOK )
{
CPLString osCommand;
CPLString osFieldType;
OGRFieldDefn oField( poFieldIn );
/* -------------------------------------------------------------------- */
/* Do we want to "launder" the column names into Postgres */
/* friendly format? */
/* -------------------------------------------------------------------- */
if( bLaunderColumnNames )
{
char *pszSafeName = poDS->LaunderName( oField.GetNameRef() );
oField.SetName( pszSafeName );
CPLFree( pszSafeName );
if( EQUAL(oField.GetNameRef(),"oid") )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Renaming field 'oid' to 'oid_' to avoid conflict with internal oid field." );
oField.SetName( "oid_" );
}
}
const char* pszOverrideType = CSLFetchNameValue(papszOverrideColumnTypes, oField.GetNameRef());
if( pszOverrideType != NULL )
osFieldType = pszOverrideType;
else
{
osFieldType = OGRPGTableLayerGetType(oField, bPreservePrecision, bApproxOK);
if (osFieldType.size() == 0)
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Create the new field. */
/* -------------------------------------------------------------------- */
osCommand.Printf( "ALTER TABLE %s ADD COLUMN %s %s",
pszSqlTableName, OGRPGDumpEscapeColumnName(oField.GetNameRef()).c_str(),
osFieldType.c_str() );
if (bCreateTable)
poDS->Log(osCommand);
poFeatureDefn->AddFieldDefn( &oField );
return OGRERR_NONE;
}
OGRErr OGRCARTODBTableLayer::CreateField( OGRFieldDefn *poFieldIn,
CPL_UNUSED int bApproxOK )
{
GetLayerDefn();
if (!poDS->IsReadWrite())
{
CPLError(CE_Failure, CPLE_AppDefined,
"Operation not available in read-only mode");
return OGRERR_FAILURE;
}
OGRFieldDefn oField(poFieldIn);
if( bLaunderColumnNames )
{
char* pszName = OGRPGCommonLaunderName(oField.GetNameRef());
oField.SetName(pszName);
CPLFree(pszName);
}
/* -------------------------------------------------------------------- */
/* Create the new field. */
/* -------------------------------------------------------------------- */
if( !bDeferedCreation )
{
CPLString osSQL;
osSQL.Printf( "ALTER TABLE %s ADD COLUMN %s %s",
OGRCARTODBEscapeIdentifier(osName).c_str(),
OGRCARTODBEscapeIdentifier(oField.GetNameRef()).c_str(),
OGRPGCommonLayerGetType(oField, FALSE, TRUE).c_str() );
if( !oField.IsNullable() )
osSQL += " NOT NULL";
if( oField.GetDefault() != NULL && !oField.IsDefaultDriverSpecific() )
{
osSQL += " DEFAULT ";
osSQL += OGRPGCommonLayerGetPGDefault(&oField);
}
json_object* poObj = poDS->RunSQL(osSQL);
if( poObj == NULL )
return OGRERR_FAILURE;
json_object_put(poObj);
}
poFeatureDefn->AddFieldDefn( &oField );
return OGRERR_NONE;
}
TigerAltName::TigerAltName( OGRTigerDataSource * poDSIn,
CPL_UNUSED const char * pszPrototypeModule ) :
TigerFileBase(&rt4_info, FILE_CODE)
{
OGRFieldDefn oField("",OFTInteger);
poDS = poDSIn;
poFeatureDefn = new OGRFeatureDefn( "AltName" );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
/* -------------------------------------------------------------------- */
/* Fields from type 4 record. */
/* -------------------------------------------------------------------- */
AddFieldDefns( psRTInfo, poFeatureDefn );
}
OGRAeronavFAANAVAIDLayer::OGRAeronavFAANAVAIDLayer( VSILFILE* fp,
const char* pszLayerName ) :
OGRAeronavFAALayer(fp, pszLayerName)
{
poFeatureDefn->SetGeomType( wkbPoint );
psRecordDesc = &NAVAID;
for( int i=0; i < psRecordDesc->nFields; i++ )
{
OGRFieldDefn oField( psRecordDesc->pasFields[i].pszFieldName,
psRecordDesc->pasFields[i].eType );
oField.SetWidth( psRecordDesc->pasFields[i].nLastCol
- psRecordDesc->pasFields[i].nStartCol + 1 );
poFeatureDefn->AddFieldDefn( &oField );
}
}
TigerPolygonCorrections::TigerPolygonCorrections(
OGRTigerDataSource * poDSIn,
const char * /* pszPrototypeModule */ ) :
TigerFileBase(&rtB_info, FILE_CODE)
{
OGRFieldDefn oField("",OFTInteger);
poDS = poDSIn;
poFeatureDefn = new OGRFeatureDefn( "PolygonCorrections" );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
/* -------------------------------------------------------------------- */
/* Fields from type B record. */
/* -------------------------------------------------------------------- */
AddFieldDefns( psRTInfo, poFeatureDefn );
}
OGRLayer *GNMDatabaseNetwork::ICreateLayer(const char *pszName,
CPL_UNUSED OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType, char **papszOptions)
{
//check if layer with such name exist
for(int i = 0; i < GetLayerCount(); ++i)
{
OGRLayer* pLayer = GetLayer(i);
if(NULL == pLayer)
continue;
if(EQUAL(pLayer->GetName(), pszName))
{
CPLError( CE_Failure, CPLE_IllegalArg,
"The network layer '%s' already exist.", pszName );
return NULL;
}
}
OGRSpatialReference oSpaRef(m_soSRS);
OGRLayer *poLayer = m_poDS->CreateLayer( pszName, &oSpaRef, eGType, papszOptions );
if( poLayer == NULL )
{
CPLError( CE_Failure, CPLE_FileIO, "Layer creation failed." );
return NULL;
}
OGRFieldDefn oField( GNM_SYSFIELD_GFID, GNMGFIDInt );
if( poLayer->CreateField( &oField ) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_FileIO, "Creating global identificator field failed." );
return NULL;
}
OGRFieldDefn oFieldBlock(GNM_SYSFIELD_BLOCKED, OFTInteger);
if( poLayer->CreateField( &oFieldBlock ) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_FileIO, "Creating is blocking field failed." );
return NULL;
}
GNMGenericLayer* pGNMLayer = new GNMGenericLayer(poLayer, this);
m_apoLayers.push_back(pGNMLayer);
return pGNMLayer;
}
void SaveGeometry(const CPLString &path, const OGRPolygon &polygon, const OGRSpatialReference &spaRef)
{
const char *pszDriverName = "ESRI Shapefile";
GDALDriver *poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName );
if( poDriver == NULL )
{
printf( "%s driver not available.\n", pszDriverName );
exit( 1 );
}
GDALDataset *poDS = poDriver->Create( path, 0, 0, 0, GDT_Unknown, NULL );
if( poDS == NULL )
{
printf( "Creation of output file failed.\n" );
exit( 1 );
}
const char* pszLayerName = CPLGetBasename(path);
OGRLayer *poLayer = poDS->CreateLayer( pszLayerName, spaRef.Clone(), wkbPolygon, NULL );
if( poLayer == NULL )
{
printf( "Layer creation failed.\n" );
exit( 1 );
}
OGRFieldDefn oField( "Name", OFTString );
oField.SetWidth(32);
if( poLayer->CreateField( &oField ) != OGRERR_NONE )
{
printf( "Creating Name field failed.\n" );
exit( 1 );
}
OGRFeature *poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
//poFeature->SetField( "Name", szName );
poFeature->SetGeometry( polygon.clone() );
if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE )
{
printf( "Failed to create feature in shapefile.\n" );
exit( 1 );
}
OGRFeature::DestroyFeature( poFeature );
GDALClose( poDS );
}
OGRSEGUKOOALineLayer::OGRSEGUKOOALineLayer(const char* pszFilename,
OGRLayer *poBaseLayer)
{
nNextFID = 0;
bEOF = FALSE;
poFeatureDefn = new OGRFeatureDefn( CPLSPrintf("%s_lines",
CPLGetBasename(pszFilename)) );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbLineString );
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poBaseLayer->GetSpatialRef());
OGRFieldDefn oField( "LINENAME", OFTString );
poFeatureDefn->AddFieldDefn( &oField );
this->poBaseLayer = poBaseLayer;
poNextBaseFeature = NULL;
}
TigerFeatureIds::TigerFeatureIds( OGRTigerDataSource * poDSIn,
const char * pszPrototypeModule )
{
OGRFieldDefn oField("",OFTInteger);
poDS = poDSIn;
poFeatureDefn = new OGRFeatureDefn( "FeatureIds" );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
if (poDS->GetVersion() >= TIGER_2002) {
psRT5Info = &rt5_2002_info;
} else {
psRT5Info = &rt5_info;
}
AddFieldDefns( psRT5Info, poFeatureDefn );
}
TigerAreaLandmarks::TigerAreaLandmarks( OGRTigerDataSource * poDSIn,
const char * pszPrototypeModule )
{
OGRFieldDefn oField("",OFTInteger);
poDS = poDSIn;
poFeatureDefn = new OGRFeatureDefn( "AreaLandmarks" );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
psRT8Info = &rt8_info;
/* -------------------------------------------------------------------- */
/* Fields from type 8 record. */
/* -------------------------------------------------------------------- */
AddFieldDefns( psRT8Info, poFeatureDefn );
}
TigerZeroCellID::TigerZeroCellID( OGRTigerDataSource * poDSIn,
const char * pszPrototypeModule )
{
OGRFieldDefn oField("",OFTInteger);
poDS = poDSIn;
poFeatureDefn = new OGRFeatureDefn( "ZeroCellID" );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
psRTTInfo = &rtT_info;
/* -------------------------------------------------------------------- */
/* Fields from type T record. */
/* -------------------------------------------------------------------- */
AddFieldDefns( psRTTInfo, poFeatureDefn );
}
TigerPolyChainLink::TigerPolyChainLink( OGRTigerDataSource * poDSIn,
CPL_UNUSED const char * pszPrototypeModule ) :
TigerFileBase(NULL, FILE_CODE)
{
OGRFieldDefn oField("",OFTInteger);
poDS = poDSIn;
poFeatureDefn = new OGRFeatureDefn( "PolyChainLink" );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
if (poDS->GetVersion() >= TIGER_2002) {
psRTInfo = &rtI_2002_info;
} else {
psRTInfo = &rtI_info;
}
/* -------------------------------------------------------------------- */
/* Fields from type I record. */
/* -------------------------------------------------------------------- */
AddFieldDefns( psRTInfo, poFeatureDefn );
}
void OGROSMLayer::AddField(const char* pszName, OGRFieldType eFieldType)
{
const char* pszLaunderedName = GetLaunderedFieldName(pszName);
OGRFieldDefn oField(pszLaunderedName, eFieldType);
poFeatureDefn->AddFieldDefn(&oField);
int nIndex = poFeatureDefn->GetFieldCount() - 1;
char* pszDupName = CPLStrdup(pszName);
apszNames.push_back(pszDupName);
oMapFieldNameToIndex[pszDupName] = nIndex;
if( strcmp(pszName, "osm_id") == 0 )
nIndexOSMId = nIndex;
else if( strcmp(pszName, "osm_way_id") == 0 )
nIndexOSMWayId = nIndex;
else if( strcmp(pszName, "other_tags") == 0 )
nIndexOtherTags = nIndex;
else if( strcmp(pszName, "all_tags") == 0 )
nIndexAllTags = nIndex;
}
void TigerFileBase::AddFieldDefns(TigerRecordInfo *psRTInfo,
OGRFeatureDefn *poFeatureDefn)
{
OGRFieldDefn oField("",OFTInteger);
int i, bLFieldHack;
bLFieldHack =
CSLTestBoolean( CPLGetConfigOption( "TIGER_LFIELD_AS_STRING", "NO" ) );
for (i=0; i<psRTInfo->nFieldCount; ++i) {
if (psRTInfo->pasFields[i].bDefine) {
OGRFieldType eFT = psRTInfo->pasFields[i].OGRtype;
if( bLFieldHack
&& psRTInfo->pasFields[i].cFmt == 'L'
&& psRTInfo->pasFields[i].cType == 'N' )
eFT = OFTString;
oField.Set( psRTInfo->pasFields[i].pszFieldName, eFT,
psRTInfo->pasFields[i].nLen );
poFeatureDefn->AddFieldDefn( &oField );
}
}
}
CPLErr OGROCIStatement::Execute( const char *pszSQLStatement,
int nMode )
{
/* -------------------------------------------------------------------- */
/* Prepare the statement if it is being passed in. */
/* -------------------------------------------------------------------- */
if( pszSQLStatement != NULL )
{
CPLErr eErr = Prepare( pszSQLStatement );
if( eErr != CE_None )
return eErr;
}
if( hStatement == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No prepared statement in call to OGROCIStatement::Execute(NULL)" );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Determine if this is a SELECT statement. */
/* -------------------------------------------------------------------- */
ub2 nStmtType;
if( poSession->Failed(
OCIAttrGet( hStatement, OCI_HTYPE_STMT,
&nStmtType, 0, OCI_ATTR_STMT_TYPE, poSession->hError ),
"OCIAttrGet(ATTR_STMT_TYPE)") )
return CE_Failure;
int bSelect = (nStmtType == OCI_STMT_SELECT);
/* -------------------------------------------------------------------- */
/* Work out some details about execution mode. */
/* -------------------------------------------------------------------- */
if( nMode == -1 )
{
if( bSelect )
nMode = OCI_DEFAULT;
else
nMode = OCI_COMMIT_ON_SUCCESS;
}
/* -------------------------------------------------------------------- */
/* Execute the statement. */
/* -------------------------------------------------------------------- */
if( poSession->Failed(
OCIStmtExecute( poSession->hSvcCtx, hStatement,
poSession->hError, (ub4)bSelect ? 0 : 1, (ub4)0,
(OCISnapshot *)NULL, (OCISnapshot *)NULL, nMode ),
pszCommandText ) )
return CE_Failure;
if( !bSelect )
return CE_None;
/* -------------------------------------------------------------------- */
/* Count the columns. */
/* -------------------------------------------------------------------- */
for( nRawColumnCount = 0; TRUE; nRawColumnCount++ )
{
OCIParam *hParmDesc;
if( OCIParamGet( hStatement, OCI_HTYPE_STMT, poSession->hError,
(dvoid**)&hParmDesc,
(ub4) nRawColumnCount+1 ) != OCI_SUCCESS )
break;
}
panFieldMap = (int *) CPLCalloc(sizeof(int),nRawColumnCount);
papszCurColumn = (char **) CPLCalloc(sizeof(char*),nRawColumnCount+1);
panCurColumnInd = (sb2 *) CPLCalloc(sizeof(sb2),nRawColumnCount+1);
/* ==================================================================== */
/* Establish result column definitions, and setup parameter */
/* defines. */
/* ==================================================================== */
poDefn = new OGRFeatureDefn( pszCommandText );
poDefn->Reference();
for( int iParm = 0; iParm < nRawColumnCount; iParm++ )
{
OGRFieldDefn oField( "", OFTString );
OCIParam *hParmDesc;
ub2 nOCIType;
ub4 nOCILen;
/* -------------------------------------------------------------------- */
/* Get parameter definition. */
/* -------------------------------------------------------------------- */
if( poSession->Failed(
OCIParamGet( hStatement, OCI_HTYPE_STMT, poSession->hError,
(dvoid**)&hParmDesc, (ub4) iParm+1 ),
"OCIParamGet") )
return CE_Failure;
if( poSession->GetParmInfo( hParmDesc, &oField, &nOCIType, &nOCILen )
!= CE_None )
return CE_Failure;
if( oField.GetType() == OFTBinary )
{
panFieldMap[iParm] = -1;
continue;
}
poDefn->AddFieldDefn( &oField );
panFieldMap[iParm] = poDefn->GetFieldCount() - 1;
/* -------------------------------------------------------------------- */
/* Prepare a binding. */
/* -------------------------------------------------------------------- */
int nBufWidth = 256, nOGRField = panFieldMap[iParm];
OCIDefine *hDefn = NULL;
if( oField.GetWidth() > 0 )
/* extra space needed for the decimal separator the string
terminator and the negative sign (Tamas Szekeres)*/
nBufWidth = oField.GetWidth() + 3;
else if( oField.GetType() == OFTInteger )
nBufWidth = 22;
else if( oField.GetType() == OFTReal )
nBufWidth = 36;
else if ( oField.GetType() == OFTDateTime )
nBufWidth = 40;
else if ( oField.GetType() == OFTDate )
nBufWidth = 20;
papszCurColumn[nOGRField] = (char *) CPLMalloc(nBufWidth+2);
CPLAssert( ((long) papszCurColumn[nOGRField]) % 2 == 0 );
if( poSession->Failed(
OCIDefineByPos( hStatement, &hDefn, poSession->hError,
iParm+1,
(ub1 *) papszCurColumn[nOGRField], nBufWidth,
SQLT_STR, panCurColumnInd + nOGRField,
NULL, NULL, OCI_DEFAULT ),
"OCIDefineByPos" ) )
return CE_Failure;
}
return CE_None;
}
