int OGRILI1DataSource::Create( const char *pszFilename,
char **papszOptions )
{
std::string osBasename, osModelFilename;
char **filenames = CSLTokenizeString2( pszFilename, ",", 0 );
osBasename = filenames[0];
if( CSLCount(filenames) > 1 )
osModelFilename = filenames[1];
CSLDestroy( filenames );
/* -------------------------------------------------------------------- */
/* Create the empty file. */
/* -------------------------------------------------------------------- */
fpTransfer = VSIFOpen( osBasename.c_str(), "w+b" );
if( fpTransfer == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
osBasename.c_str(), VSIStrerror( errno ) );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Parse model */
/* -------------------------------------------------------------------- */
if( osModelFilename.length() == 0 )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Creating Interlis transfer file without model definition." );
} else {
poImdReader->ReadModel(osModelFilename.c_str());
}
pszTopic = CPLStrdup(poImdReader->mainTopicName.c_str());
/* -------------------------------------------------------------------- */
/* Write headers */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpTransfer, "SCNT\n" );
VSIFPrintf( fpTransfer, "OGR/GDAL %s, INTERLIS Driver\n", GDAL_RELEASE_NAME );
VSIFPrintf( fpTransfer, "////\n" );
VSIFPrintf( fpTransfer, "MTID INTERLIS1\n" );
const char* modelname = poImdReader->mainModelName.c_str();
VSIFPrintf( fpTransfer, "MODL %s\n", modelname );
return TRUE;
}
static void AppendCoumpoundCurve( OGRCompoundCurve *poCC, OGRILI1DataSource *poDS)
{
for( int iMember = 0; iMember < poCC->getNumCurves(); iMember++)
{
OGRCurve *poGeometry = poCC->getCurve( iMember );
int b3D = wkbHasZ(poGeometry->getGeometryType());
int bIsArc = (poGeometry->getGeometryType() == wkbCircularString
|| poGeometry->getGeometryType() == wkbCircularStringZ );
OGRSimpleCurve *poLine = (OGRSimpleCurve *)poGeometry;
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
//Skip last point in curve member
if (iPoint == poLine->getNumPoints()-1 && iMember < poCC->getNumCurves()-1)
continue;
if (iMember == 0 && iPoint == 0) VSIFPrintf( poDS->GetTransferFile(), "STPT" );
else if (bIsArc && iPoint == 1) VSIFPrintf( poDS->GetTransferFile(), "ARCP" );
else VSIFPrintf( poDS->GetTransferFile(), "LIPT" );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getX(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getY(iPoint)) );
if (b3D) VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getZ(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), "\n" );
}
}
VSIFPrintf( poDS->GetTransferFile(), "ELIN\n" );
}
void HFAType::Dump( FILE * fp )
{
int i;
VSIFPrintf( fp, "HFAType %s/%d bytes\n", pszTypeName, nBytes );
for( i = 0; i < nFields; i++ )
{
papoFields[i]->Dump( fp );
}
VSIFPrintf( fp, "\n" );
}
OGRLayer *
OGRILI1DataSource::ICreateLayer( const char * pszLayerName,
CPL_UNUSED OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
CPL_UNUSED char ** papszOptions )
{
FeatureDefnInfo featureDefnInfo
= poImdReader->GetFeatureDefnInfo(pszLayerName);
const char *table = pszLayerName;
char * topic = ExtractTopic(pszLayerName);
if (nLayers) VSIFPrintf( fpTransfer, "ETAB\n" );
if (topic)
{
table = pszLayerName+strlen(topic)+2; //after "__"
if (pszTopic == NULL || !EQUAL(topic, pszTopic))
{
if (pszTopic)
{
VSIFPrintf( fpTransfer, "ETOP\n" );
CPLFree(pszTopic);
}
pszTopic = topic;
VSIFPrintf( fpTransfer, "TOPI %s\n", pszTopic );
}
else
{
CPLFree(topic);
}
}
else
{
if (pszTopic == NULL) pszTopic = CPLStrdup("Unknown");
VSIFPrintf( fpTransfer, "TOPI %s\n", pszTopic );
}
VSIFPrintf( fpTransfer, "TABL %s\n", table );
OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(table);
poFeatureDefn->SetGeomType( eType );
OGRILI1Layer *poLayer
= new OGRILI1Layer(poFeatureDefn, featureDefnInfo.poGeomFieldInfos,
this);
nLayers ++;
papoLayers = static_cast<OGRILI1Layer **>(
CPLRealloc(papoLayers, sizeof(OGRILI1Layer*) * nLayers) );
papoLayers[nLayers-1] = poLayer;
return poLayer;
}
void HFADictionary::Dump( FILE * fp )
{
CPL_IGNORE_RET_VAL(VSIFPrintf( fp, "\nHFADictionary:\n" ));
for( int i = 0; i < nTypes; i++ )
{
papoTypes[i]->Dump( fp );
}
}
OGRLayer *
OGRILI1DataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
const char *table = pszLayerName;
char * topic = ExtractTopic(pszLayerName);
if (pszTopic) VSIFPrintf( fpTransfer, "ETAB\n" );
if (topic)
{
table = pszLayerName+strlen(topic)+2; //after "__"
if (pszTopic == NULL || !EQUAL(topic, pszTopic))
{
if (pszTopic)
{
VSIFPrintf( fpTransfer, "ETOP\n" );
CPLFree(pszTopic);
}
pszTopic = topic;
VSIFPrintf( fpTransfer, "TOPI %s\n", pszTopic );
}
else
{
CPLFree(topic);
}
}
else if (pszTopic == NULL)
{
pszTopic = CPLStrdup("Topic"); //TODO: From model?
VSIFPrintf( fpTransfer, "TOPI %s\n", pszTopic );
}
VSIFPrintf( fpTransfer, "TABL %s\n", table );
OGRILI1Layer *poLayer = new OGRILI1Layer(table, poSRS, TRUE, eType, this);
nLayers ++;
papoLayers = (OGRILI1Layer**)CPLRealloc(papoLayers, sizeof(OGRILI1Layer*) * nLayers);
papoLayers[nLayers-1] = poLayer;
return poLayer;
}
OGRILI1DataSource::~OGRILI1DataSource()
{
for( int i=0; i<nLayers; i++)
{
delete papoLayers[i];
}
CPLFree( papoLayers );
CPLFree( pszName );
CPLFree( pszTopic );
DestroyILI1Reader( poReader );
delete poImdReader;
if( fpTransfer )
{
VSIFPrintf( fpTransfer, "ETAB\n" );
VSIFPrintf( fpTransfer, "ETOP\n" );
VSIFPrintf( fpTransfer, "EMOD\n" );
VSIFPrintf( fpTransfer, "ENDE\n" );
fclose(fpTransfer);
}
}
static void AppendCoordinateList( OGRLineString *poLine, OGRILI1DataSource *poDS)
{
int b3D = (poLine->getGeometryType() & wkb25DBit);
for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ )
{
if (iPoint == 0) VSIFPrintf( poDS->GetTransferFile(), "STPT" );
else VSIFPrintf( poDS->GetTransferFile(), "LIPT" );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getX(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getY(iPoint)) );
if (b3D) VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poLine->getZ(iPoint)) );
VSIFPrintf( poDS->GetTransferFile(), "\n" );
}
VSIFPrintf( poDS->GetTransferFile(), "ELIN\n" );
}
/**********************************************************************
* CSLPrint()
*
* Print a StringList to fpOut. If fpOut==NULL, then output is sent
* to stdout.
*
* Returns the number of lines printed.
**********************************************************************/
int CSLPrint(char **papszStrList, FILE *fpOut)
{
int nLines=0;
if (fpOut == NULL)
fpOut = stdout;
if (papszStrList)
{
while(*papszStrList != NULL)
{
VSIFPrintf(fpOut, "%s\n", *papszStrList);
nLines++;
papszStrList++;
}
}
return nLines;
}
OGRGMLDataSource::~OGRGMLDataSource()
{
if( fpOutput != NULL )
{
VSIFPrintf( fpOutput, "%s",
"</ogr:FeatureCollection>\n" );
InsertHeader();
if( nBoundedByLocation != -1
&& sBoundingRect.IsInit()
&& VSIFSeek( fpOutput, nBoundedByLocation, SEEK_SET ) == 0 )
{
VSIFPrintf( fpOutput, " <gml:boundedBy>\n" );
VSIFPrintf( fpOutput, " <gml:Box>\n" );
VSIFPrintf( fpOutput,
" <gml:coord><gml:X>%.16g</gml:X>"
"<gml:Y>%.16g</gml:Y></gml:coord>\n",
sBoundingRect.MinX, sBoundingRect.MinY );
VSIFPrintf( fpOutput,
" <gml:coord><gml:X>%.16g</gml:X>"
"<gml:Y>%.16g</gml:Y></gml:coord>\n",
sBoundingRect.MaxX, sBoundingRect.MaxY );
VSIFPrintf( fpOutput, " </gml:Box>\n" );
VSIFPrintf( fpOutput, " </gml:boundedBy>" );
}
if( fpOutput != stdout )
VSIFClose( fpOutput );
}
CSLDestroy( papszCreateOptions );
CPLFree( pszName );
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if( poReader )
delete poReader;
}
/**********************************************************************
* _PrintfNextLine()
*
* Cover function for fprintf() that will do error checking and
* reporting, and either call fprintf() directly or call the callback
* provided by the caller if E00WriteCallbackOpen() was used.
*
* A \n will be automatically appended to the string when it is
* written, so no \n should be included at the end of pszFmt.
*
* Returns 0 on success, or error 204 if it failed.
**********************************************************************/
static int _PrintfNextLine(E00WritePtr psInfo, const char *pszFmt, ...)
{
va_list args;
static char szBuf[E00_WRITE_BUF_SIZE];
int nStatus = 0;
/* Expand the string to print
*/
va_start(args, pszFmt);
vsprintf(szBuf, pszFmt, args);
va_end(args);
/* Write the line using the right method
*/
if (psInfo->pfnWriteNextLine == NULL)
{
/* Use fprintf() directly
*/
if ( VSIFPrintf(psInfo->fp, "%s\n", szBuf) < 0)
{
CPLError(CE_Failure, CPLE_FileIO,
"Error writing to file: %s",
strerror(errno));
nStatus = 204;
}
}
else
{
/* Use pfnWritenextLine() callback
*/
if ( psInfo->pfnWriteNextLine(psInfo->pRefData, szBuf) < 0)
{
CPLError(CE_Failure, CPLE_FileIO,
"Error writing to file.");
nStatus = 204;
}
}
return nStatus;
}
OGRErr OGRILI1Layer::CreateFeature( OGRFeature *poFeature ) {
static long tid = -1; //system generated TID (must be unique within table)
VSIFPrintf( poDS->GetTransferFile(), "OBJE" );
if ( !EQUAL(poFeatureDefn->GetFieldDefn(0)->GetNameRef(), "TID") )
{
//Input is not generated from an Interlis 1 source
if (poFeature->GetFID() != OGRNullFID)
tid = poFeature->GetFID();
else
++tid;
VSIFPrintf( poDS->GetTransferFile(), " %ld", tid );
//Embedded geometry
if( poFeature->GetGeometryRef() != NULL )
{
OGRGeometry *poGeometry = poFeature->GetGeometryRef();
// 2D Point
if( poGeometry->getGeometryType() == wkbPoint )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) );
}
// 3D Point
else if( poGeometry->getGeometryType() == wkbPoint25D )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getZ()) );
}
}
}
// Write all fields.
for(int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
if ( !EQUAL(poFeatureDefn->GetFieldDefn(iField)->GetNameRef(), "ILI_Geometry") )
{
if ( poFeature->IsFieldSet( iField ) )
{
const char *pszRaw = poFeature->GetFieldAsString( iField );
VSIFPrintf( poDS->GetTransferFile(), " %s", pszRaw );
}
else
{
VSIFPrintf( poDS->GetTransferFile(), " @" );
}
}
}
VSIFPrintf( poDS->GetTransferFile(), "\n" );
// Write out Geometry
if( poFeature->GetGeometryRef() != NULL )
{
if (EQUAL(poFeatureDefn->GetFieldDefn(poFeatureDefn->GetFieldCount()-1)->GetNameRef(), "ILI_Geometry"))
{
//Write original ILI geometry
VSIFPrintf( poDS->GetTransferFile(), "%s", poFeature->GetFieldAsString( poFeatureDefn->GetFieldCount()-1 ) );
}
else
{
//Convert to ILI geometry
GeometryAppend(poFeature->GetGeometryRef());
}
}
return OGRERR_NONE;
}
OGRErr OGRILI1Layer::ICreateFeature( OGRFeature *poFeature ) {
static long tid = -1; //system generated TID (must be unique within table)
VSIFPrintf( poDS->GetTransferFile(), "OBJE" );
if ( poFeatureDefn->GetFieldCount() && !EQUAL(poFeatureDefn->GetFieldDefn(0)->GetNameRef(), "TID") )
{
//Input is not generated from an Interlis 1 source
if (poFeature->GetFID() != OGRNullFID)
tid = (int)poFeature->GetFID();
else
++tid;
VSIFPrintf( poDS->GetTransferFile(), " %ld", tid );
//Embedded geometry
if( poFeature->GetGeometryRef() != NULL )
{
OGRGeometry *poGeometry = poFeature->GetGeometryRef();
// 2D Point
if( poGeometry->getGeometryType() == wkbPoint )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) );
}
// 3D Point
else if( poGeometry->getGeometryType() == wkbPoint25D )
{
OGRPoint *poPoint = (OGRPoint *) poGeometry;
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getX()) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getY()) );
VSIFPrintf( poDS->GetTransferFile(), " %s", d2str(poPoint->getZ()) );
}
}
}
// Write all fields.
for(int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
if ( poFeature->IsFieldSet( iField ) )
{
const char *pszRaw = poFeature->GetFieldAsString( iField );
if (poFeatureDefn->GetFieldDefn( iField )->GetType() == OFTString) {
//Interlis 1 encoding is ISO 8859-1 (Latin1) -> Recode from UTF-8
char* pszString = CPLRecode(pszRaw, CPL_ENC_UTF8, CPL_ENC_ISO8859_1);
//Replace spaces
for(size_t i=0; i<strlen(pszString); i++ ) {
if (pszString[i] == ' ') pszString[i] = '_';
}
VSIFPrintf( poDS->GetTransferFile(), " %s", pszString );
CPLFree( pszString );
} else {
VSIFPrintf( poDS->GetTransferFile(), " %s", pszRaw );
}
}
else
{
VSIFPrintf( poDS->GetTransferFile(), " @" );
}
}
VSIFPrintf( poDS->GetTransferFile(), "\n" );
// Write out Geometry
if( poFeature->GetGeometryRef() != NULL )
{
GeometryAppend(poFeature->GetGeometryRef());
}
return OGRERR_NONE;
}
int OGRILI1DataSource::Create( const char *pszFilename,
char **papszOptions )
{
std::string osBasename, osModelFilename;
char **filenames = CSLTokenizeString2( pszFilename, ",", 0 );
osBasename = filenames[0];
if( CSLCount(filenames) > 1 )
osModelFilename = filenames[1];
CSLDestroy( filenames );
if( osModelFilename.length() == 0 )
{
//TODO: create automatic model
}
/* -------------------------------------------------------------------- */
/* Create the empty file. */
/* -------------------------------------------------------------------- */
fpTransfer = VSIFOpen( osBasename.c_str(), "w+b" );
if( fpTransfer == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
osBasename.c_str(), VSIStrerror( errno ) );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Parse model */
/* -------------------------------------------------------------------- */
iom_init();
// set error listener to a iom provided one, that just
// dumps all errors to stderr
iom_seterrlistener(iom_stderrlistener);
IOM_BASKET model = 0;
if( osModelFilename.length() != 0 ) {
// compile ili model
char *iliFiles[1] = {(char *)osModelFilename.c_str()};
model=iom_compileIli(1,iliFiles);
if(!model){
CPLError( CE_Warning, CPLE_OpenFailed,
"iom_compileIli %s, %s.",
pszName, VSIStrerror( errno ) );
iom_end();
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* Write headers */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpTransfer, "SCNT\n" );
VSIFPrintf( fpTransfer, "OGR/GDAL %s, INTERLIS Driver\n", GDAL_RELEASE_NAME );
VSIFPrintf( fpTransfer, "////\n" );
VSIFPrintf( fpTransfer, "MTID INTERLIS1\n" );
const char* modelname = model ? GetAttrObjName(model, "iom04.metamodel.DataModel") : osBasename.c_str(); //TODO: remove file extension (= table name)
VSIFPrintf( fpTransfer, "MODL %s\n", modelname );
return TRUE;
}
void HFAField::DumpInstValue( FILE *fpOut,
GByte *pabyData, int nDataOffset, int nDataSize,
const char *pszPrefix )
{
int iEntry, nEntries;
void *pReturn;
char szLongFieldName[256];
nEntries = GetInstCount( pabyData );
/* -------------------------------------------------------------------- */
/* Special case for arrays of chars or uchars which are printed */
/* as a string. */
/* -------------------------------------------------------------------- */
if( (chItemType == 'c' || chItemType == 'C') && nEntries > 0 )
{
pReturn = ExtractInstValue( NULL, 0,
pabyData, nDataOffset, nDataSize,
's' );
if( pReturn != NULL )
VSIFPrintf( fpOut, "%s%s = `%s'\n",
pszPrefix, pszFieldName,
(char *) pReturn );
else
VSIFPrintf( fpOut, "%s%s = (access failed)\n",
pszPrefix, pszFieldName );
return;
}
/* -------------------------------------------------------------------- */
/* Dump each entry in the field array. */
/* -------------------------------------------------------------------- */
for( iEntry = 0; iEntry < MIN(8,nEntries); iEntry++ )
{
if( nEntries == 1 )
VSIFPrintf( fpOut, "%s%s = ", pszPrefix, pszFieldName );
else
VSIFPrintf( fpOut, "%s%s[%d] = ",
pszPrefix, pszFieldName, iEntry );
switch( chItemType )
{
case 'f':
case 'd':
pReturn = ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
'd' );
if( pReturn != NULL )
VSIFPrintf( fpOut, "%f\n",
*((double *) pReturn) );
else
VSIFPrintf( fpOut, "(access failed)\n" );
break;
case 'b':
VSIFPrintf( fpOut, "(basedata)\n" );
break;
case 'e':
pReturn = ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
's' );
if( pReturn != NULL )
VSIFPrintf( fpOut, "%s\n",
(char *) pReturn );
else
VSIFPrintf( fpOut, "(access failed)\n" );
break;
case 'o':
pReturn = ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
'p' );
if( pReturn == NULL )
{
VSIFPrintf( fpOut, "(access failed)\n" );
}
else
{
int nByteOffset;
VSIFPrintf( fpOut, "\n" );
nByteOffset = ((GByte *) pReturn) - pabyData;
sprintf( szLongFieldName, "%s ", pszPrefix );
poItemObjectType->DumpInstValue( fpOut,
pabyData + nByteOffset,
nDataOffset + nByteOffset,
nDataSize - nByteOffset,
szLongFieldName );
}
break;
default:
pReturn = ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
'i' );
if( pReturn != NULL )
VSIFPrintf( fpOut, "%d\n",
*((int *) pReturn) );
else
VSIFPrintf( fpOut, "(access failed)\n" );
break;
}
}
if( nEntries > 8 )
printf( "%s ... remaining instances omitted ...\n", pszPrefix );
if( nEntries == 0 )
VSIFPrintf( fpOut, "%s%s = (no values)\n", pszPrefix, pszFieldName );
}
void OGRGMLDataSource::InsertHeader()
{
FILE *fpSchema;
int nSchemaStart = 0;
if( fpOutput == NULL || fpOutput == stdout )
return;
/* -------------------------------------------------------------------- */
/* Do we want to write the schema within the GML instance doc */
/* or to a separate file? For now we only support external. */
/* -------------------------------------------------------------------- */
const char *pszSchemaURI = CSLFetchNameValue(papszCreateOptions,
"XSISCHEMAURI");
const char *pszSchemaOpt = CSLFetchNameValue( papszCreateOptions,
"XSISCHEMA" );
if( pszSchemaURI != NULL )
return;
if( pszSchemaOpt == NULL || EQUAL(pszSchemaOpt,"EXTERNAL") )
{
const char *pszXSDFilename = CPLResetExtension( pszName, "xsd" );
fpSchema = VSIFOpen( pszXSDFilename, "wt" );
if( fpSchema == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open file %.500s for schema output.",
pszXSDFilename );
return;
}
fprintf( fpSchema, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
}
else if( EQUAL(pszSchemaOpt,"INTERNAL") )
{
nSchemaStart = VSIFTell( fpOutput );
fpSchema = fpOutput;
}
else
return;
/* ==================================================================== */
/* Write the schema section at the end of the file. Once */
/* complete, we will read it back in, and then move the whole */
/* file "down" enough to insert the schema at the beginning. */
/* ==================================================================== */
/* -------------------------------------------------------------------- */
/* Emit the start of the schema section. */
/* -------------------------------------------------------------------- */
const char *pszTargetNameSpace = "http://ogr.maptools.org/";
const char *pszPrefix = "ogr";
VSIFPrintf( fpSchema,
"<xs:schema targetNamespace=\"%s\" xmlns:%s=\"%s\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:gml=\"http://www.opengis.net/gml\" elementFormDefault=\"qualified\" version=\"1.0\">\n",
pszTargetNameSpace, pszPrefix, pszTargetNameSpace );
VSIFPrintf( fpSchema,
"<xs:import namespace=\"http://www.opengis.net/gml\" schemaLocation=\"http://schemas.opengeospatial.net/gml/2.1.2/feature.xsd\"/>" );
/* -------------------------------------------------------------------- */
/* Define the FeatureCollection */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpSchema,
"<xs:element name=\"FeatureCollection\" type=\"%s:FeatureCollectionType\" substitutionGroup=\"gml:_FeatureCollection\"/>\n",
pszPrefix );
VSIFPrintf(
fpSchema,
"<xs:complexType name=\"FeatureCollectionType\">\n"
" <xs:complexContent>\n"
" <xs:extension base=\"gml:AbstractFeatureCollectionType\">\n"
" <xs:attribute name=\"lockId\" type=\"xs:string\" use=\"optional\"/>\n"
" <xs:attribute name=\"scope\" type=\"xs:string\" use=\"optional\"/>\n"
" </xs:extension>\n"
" </xs:complexContent>\n"
"</xs:complexType>\n" );
/* ==================================================================== */
/* Define the schema for each layer. */
/* ==================================================================== */
int iLayer;
for( iLayer = 0; iLayer < GetLayerCount(); iLayer++ )
{
OGRFeatureDefn *poFDefn = GetLayer(iLayer)->GetLayerDefn();
/* -------------------------------------------------------------------- */
/* Emit initial stuff for a feature type. */
/* -------------------------------------------------------------------- */
VSIFPrintf(
fpSchema,
"<xs:element name=\"%s\" type=\"%s:%s_Type\" substitutionGroup=\"gml:_Feature\"/>\n",
poFDefn->GetName(), pszPrefix, poFDefn->GetName() );
VSIFPrintf(
fpSchema,
"<xs:complexType name=\"%s_Type\">\n"
" <xs:complexContent>\n"
" <xs:extension base=\"gml:AbstractFeatureType\">\n"
" <xs:sequence>\n",
poFDefn->GetName() );
/* -------------------------------------------------------------------- */
/* Define the geometry attribute. For now I always use the */
/* generic geometry type, but eventually we should express */
/* particulars if available. */
/* -------------------------------------------------------------------- */
VSIFPrintf(
fpSchema,
"<xs:element name=\"geometryProperty\" type=\"gml:GeometryPropertyType\" nillable=\"true\" minOccurs=\"1\" maxOccurs=\"1\"/>\n" );
/* -------------------------------------------------------------------- */
/* Emit each of the attributes. */
/* -------------------------------------------------------------------- */
for( int iField = 0; iField < poFDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDefn = poFDefn->GetFieldDefn(iField);
if( poFieldDefn->GetType() == OFTInteger )
{
int nWidth;
if( poFieldDefn->GetWidth() > 0 )
nWidth = poFieldDefn->GetWidth();
else
nWidth = 16;
VSIFPrintf( fpSchema,
" <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n"
" <xs:simpleType>\n"
" <xs:restriction base=\"xs:integer\">\n"
" <xs:totalDigits value=\"%d\"/>\n"
" </xs:restriction>\n"
" </xs:simpleType>\n"
" </xs:element>\n",
poFieldDefn->GetNameRef(), nWidth );
}
else if( poFieldDefn->GetType() == OFTReal )
{
int nWidth, nDecimals;
if( poFieldDefn->GetPrecision() == 0 )
nDecimals = 0;
else
nDecimals = poFieldDefn->GetPrecision();
if( poFieldDefn->GetWidth() > 0 )
nWidth = poFieldDefn->GetWidth();
else
nWidth = 33;
VSIFPrintf( fpSchema,
" <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n"
" <xs:simpleType>\n"
" <xs:restriction base=\"xs:decimal\">\n"
" <xs:totalDigits value=\"%d\"/>\n"
" <xs:fractionDigits value=\"%d\"/>\n"
" </xs:restriction>\n"
" </xs:simpleType>\n"
" </xs:element>\n",
poFieldDefn->GetNameRef(), nWidth, nDecimals );
}
else if( poFieldDefn->GetType() == OFTString )
{
char szMaxLength[48];
if( poFieldDefn->GetWidth() == 0 )
sprintf( szMaxLength, "unbounded" );
else
sprintf( szMaxLength, "%d", poFieldDefn->GetWidth() );
VSIFPrintf( fpSchema,
" <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n"
" <xs:simpleType>\n"
" <xs:restriction base=\"xs:string\">\n"
" <xs:maxLength value=\"%s\"/>\n"
" </xs:restriction>\n"
" </xs:simpleType>\n"
" </xs:element>\n",
poFieldDefn->GetNameRef(), szMaxLength );
}
else if( poFieldDefn->GetType() == OFTDate || poFieldDefn->GetType() == OFTDateTime )
{
VSIFPrintf( fpSchema,
" <xs:element name=\"%s\" nillable=\"true\" minOccurs=\"0\" maxOccurs=\"1\">\n"
" <xs:simpleType>\n"
" <xs:restriction base=\"xs:string\">\n"
" <xs:maxLength value=\"unbounded\"/>\n"
" </xs:restriction>\n"
" </xs:simpleType>\n"
" </xs:element>\n",
poFieldDefn->GetNameRef() );
}
else
{
/* TODO */
}
} /* next field */
/* -------------------------------------------------------------------- */
/* Finish off feature type. */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpSchema,
" </xs:sequence>\n"
" </xs:extension>\n"
" </xs:complexContent>\n"
"</xs:complexType>\n" );
} /* next layer */
VSIFPrintf( fpSchema, "</xs:schema>\n" );
/* ==================================================================== */
/* Move schema to the start of the file. */
/* ==================================================================== */
if( fpSchema == fpOutput )
{
/* -------------------------------------------------------------------- */
/* Read the schema into memory. */
/* -------------------------------------------------------------------- */
int nSchemaSize = VSIFTell( fpOutput ) - nSchemaStart;
char *pszSchema = (char *) CPLMalloc(nSchemaSize+1);
VSIFSeek( fpOutput, nSchemaStart, SEEK_SET );
VSIFRead( pszSchema, 1, nSchemaSize, fpOutput );
pszSchema[nSchemaSize] = '\0';
/* -------------------------------------------------------------------- */
/* Move file data down by "schema size" bytes from after <?xml> */
/* header so we have room insert the schema. Move in pretty */
/* big chunks. */
/* -------------------------------------------------------------------- */
int nChunkSize = MIN(nSchemaStart-nSchemaInsertLocation,250000);
char *pszChunk = (char *) CPLMalloc(nChunkSize);
int nEndOfUnmovedData = nSchemaStart;
for( nEndOfUnmovedData = nSchemaStart;
nEndOfUnmovedData > nSchemaInsertLocation; )
{
int nBytesToMove =
MIN(nChunkSize, nEndOfUnmovedData - nSchemaInsertLocation );
VSIFSeek( fpOutput, nEndOfUnmovedData - nBytesToMove, SEEK_SET );
VSIFRead( pszChunk, 1, nBytesToMove, fpOutput );
VSIFSeek( fpOutput, nEndOfUnmovedData - nBytesToMove + nSchemaSize,
SEEK_SET );
VSIFWrite( pszChunk, 1, nBytesToMove, fpOutput );
nEndOfUnmovedData -= nBytesToMove;
}
CPLFree( pszChunk );
/* -------------------------------------------------------------------- */
/* Write the schema in the opened slot. */
/* -------------------------------------------------------------------- */
VSIFSeek( fpOutput, nSchemaInsertLocation, SEEK_SET );
VSIFWrite( pszSchema, 1, nSchemaSize, fpOutput );
VSIFSeek( fpOutput, 0, SEEK_END );
nBoundedByLocation += nSchemaSize;
}
/* -------------------------------------------------------------------- */
/* Close external schema files. */
/* -------------------------------------------------------------------- */
else
VSIFClose( fpSchema );
}
/**********************************************************************
* DumpMapFileIndexTree2MIF()
*
* Open a .MAP file and dump the index tree to a .MIF file
**********************************************************************/
static int DumpMapFileIndexTree2MIF(const char *pszFname, int nMaxDepth)
{
TABMAPFile oMAPFile;
FILE *fpMIF, *fpMID;
/*---------------------------------------------------------------------
* Try to open source file
*--------------------------------------------------------------------*/
if (oMAPFile.Open(pszFname, "rb") != 0)
{
printf("Failed to open %s\n", pszFname);
return -1;
}
/*---------------------------------------------------------------------
* Create MIF/MID dataset
*--------------------------------------------------------------------*/
if ((fpMIF=VSIFOpen(CPLSPrintf("%s.spindex.mif",pszFname),"wt"))==NULL)
{
printf("Unable to create %s\n", CPLSPrintf("%s.spindex.mif",pszFname));
return -1;
}
if ((fpMID=VSIFOpen(CPLSPrintf("%s.spindex.mid",pszFname),"wt"))==NULL)
{
printf("Unable to create %s\n", CPLSPrintf("%s.spindex.mid",pszFname));
return -1;
}
printf("Dumping spatial index from %s to %s.spindex.mif/.mid\n",
pszFname, pszFname);
VSIFPrintf(fpMIF,
"VERSION 300\n"
"CHARSET \"Neutral\"\n"
"DELIMITER \",\"\n"
"COLUMNS 9\n"
" ID integer\n"
" PARENT_ID integer\n"
" ID_IN_NODE integer\n"
" DEPTH integer\n"
" AREA integer\n"
" XMIN integer\n"
" YMIN integer\n"
" XMAX integer\n"
" YMAX integer\n"
"DATA\n");
/*---------------------------------------------------------------------
* Dump spatial Index Tree
*--------------------------------------------------------------------*/
oMAPFile.DumpSpatialIndexToMIF(NULL, fpMIF, fpMID, -1, -1, 0, nMaxDepth);
/*---------------------------------------------------------------------
* Cleanup and exit.
*--------------------------------------------------------------------*/
oMAPFile.Close();
VSIFClose(fpMIF);
VSIFClose(fpMID);
return 0;
}
void HFAField::DumpInstValue( FILE *fpOut,
GByte *pabyData, GUInt32 nDataOffset, int nDataSize,
const char *pszPrefix )
{
int iEntry, nEntries;
void *pReturn;
char szLongFieldName[256];
nEntries = GetInstCount( pabyData, nDataSize );
/* -------------------------------------------------------------------- */
/* Special case for arrays of chars or uchars which are printed */
/* as a string. */
/* -------------------------------------------------------------------- */
if( (chItemType == 'c' || chItemType == 'C') && nEntries > 0 )
{
if( ExtractInstValue( NULL, 0,
pabyData, nDataOffset, nDataSize,
's', &pReturn ) )
VSIFPrintf( fpOut, "%s%s = `%s'\n",
pszPrefix, pszFieldName,
(char *) pReturn );
else
VSIFPrintf( fpOut, "%s%s = (access failed)\n",
pszPrefix, pszFieldName );
return;
}
/* -------------------------------------------------------------------- */
/* For BASEDATA objects, we want to first dump their dimension */
/* and type. */
/* -------------------------------------------------------------------- */
if( chItemType == 'b' )
{
int nDataType, nRows, nColumns;
int bSuccess = ExtractInstValue( NULL, -3, pabyData, nDataOffset,
nDataSize, 'i', &nDataType );
if (bSuccess)
{
ExtractInstValue( NULL, -2, pabyData, nDataOffset,
nDataSize, 'i', &nColumns );
ExtractInstValue( NULL, -1, pabyData, nDataOffset,
nDataSize, 'i', &nRows );
VSIFPrintf( fpOut, "%sBASEDATA(%s): %dx%d of %s\n",
pszPrefix, pszFieldName,
nColumns, nRows, HFAGetDataTypeName( nDataType ) );
}
else
{
VSIFPrintf( fpOut, "%sBASEDATA(%s): empty\n",
pszPrefix, pszFieldName );
}
}
/* -------------------------------------------------------------------- */
/* Dump each entry in the field array. */
/* -------------------------------------------------------------------- */
for( iEntry = 0; iEntry < MIN(MAX_ENTRY_REPORT,nEntries); iEntry++ )
{
if( nEntries == 1 )
VSIFPrintf( fpOut, "%s%s = ", pszPrefix, pszFieldName );
else
VSIFPrintf( fpOut, "%s%s[%d] = ",
pszPrefix, pszFieldName, iEntry );
switch( chItemType )
{
case 'f':
case 'd':
{
double dfValue;
if( ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
'd', &dfValue ) )
VSIFPrintf( fpOut, "%f\n", dfValue );
else
VSIFPrintf( fpOut, "(access failed)\n" );
}
break;
case 'b':
{
double dfValue;
if( ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
'd', &dfValue ) )
VSIFPrintf( fpOut, "%s%.15g\n", pszPrefix, dfValue );
else
VSIFPrintf( fpOut, "%s(access failed)\n", pszPrefix );
}
break;
case 'e':
if( ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
's', &pReturn ) )
VSIFPrintf( fpOut, "%s\n", (char *) pReturn );
else
VSIFPrintf( fpOut, "(access failed)\n" );
break;
case 'o':
if( !ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
'p', &pReturn ) )
{
VSIFPrintf( fpOut, "(access failed)\n" );
}
else
{
int nByteOffset;
VSIFPrintf( fpOut, "\n" );
nByteOffset = ((GByte *) pReturn) - pabyData;
sprintf( szLongFieldName, "%s ", pszPrefix );
if( poItemObjectType )
poItemObjectType->DumpInstValue( fpOut,
pabyData + nByteOffset,
nDataOffset + nByteOffset,
nDataSize - nByteOffset,
szLongFieldName );
}
break;
default:
{
GInt32 nIntValue;
if( ExtractInstValue( NULL, iEntry,
pabyData, nDataOffset, nDataSize,
'i', &nIntValue ) )
VSIFPrintf( fpOut, "%d\n", nIntValue );
else
VSIFPrintf( fpOut, "(access failed)\n" );
}
break;
}
}
if( nEntries > MAX_ENTRY_REPORT )
printf( "%s ... remaining instances omitted ...\n", pszPrefix );
if( nEntries == 0 )
VSIFPrintf( fpOut, "%s%s = (no values)\n", pszPrefix, pszFieldName );
}
void HFAField::Dump( FILE * fp )
{
const char *pszTypeName;
switch( chItemType )
{
case '1':
pszTypeName = "U1";
break;
case '2':
pszTypeName = "U2";
break;
case '4':
pszTypeName = "U4";
break;
case 'c':
pszTypeName = "UCHAR";
break;
case 'C':
pszTypeName = "CHAR";
break;
case 'e':
pszTypeName = "ENUM";
break;
case 's':
pszTypeName = "USHORT";
break;
case 'S':
pszTypeName = "SHORT";
break;
case 't':
pszTypeName = "TIME";
break;
case 'l':
pszTypeName = "ULONG";
break;
case 'L':
pszTypeName = "LONG";
break;
case 'f':
pszTypeName = "FLOAT";
break;
case 'd':
pszTypeName = "DOUBLE";
break;
case 'm':
pszTypeName = "COMPLEX";
break;
case 'M':
pszTypeName = "DCOMPLEX";
break;
case 'b':
pszTypeName = "BASEDATA";
break;
case 'o':
pszTypeName = pszItemObjectType;
break;
case 'x':
pszTypeName = "InlineType";
break;
default:
CPLAssert( FALSE );
pszTypeName = "Unknown";
}
VSIFPrintf( fp, " %-19s %c %s[%d];\n",
pszTypeName,
chPointer ? chPointer : ' ',
pszFieldName, nItemCount );
if( papszEnumNames != NULL )
{
int i;
for( i = 0; papszEnumNames[i] != NULL; i++ )
{
VSIFPrintf( fp, " %s=%d\n",
papszEnumNames[i], i );
}
}
}
void OGROCILoaderLayer::WriteLoaderHeader()
{
if( bHeaderWritten )
return;
/* -------------------------------------------------------------------- */
/* Determine name of geometry column to use. */
/* -------------------------------------------------------------------- */
const char *pszGeometryName =
CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if( pszGeometryName == NULL )
pszGeometryName = "ORA_GEOMETRY";
/* -------------------------------------------------------------------- */
/* Dermine our operation mode. */
/* -------------------------------------------------------------------- */
const char *pszLDRMode = CSLFetchNameValue( papszOptions, "LOADER_MODE" );
if( pszLDRMode != NULL && EQUAL(pszLDRMode,"VARIABLE") )
nLDRMode = LDRM_VARIABLE;
else if( pszLDRMode != NULL && EQUAL(pszLDRMode,"BINARY") )
nLDRMode = LDRM_BINARY;
else
nLDRMode = LDRM_STREAM;
/* -------------------------------------------------------------------- */
/* Write loader header info. */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpLoader, "LOAD DATA\n" );
if( nLDRMode == LDRM_STREAM )
{
VSIFPrintf( fpLoader, "INFILE *\n" );
VSIFPrintf( fpLoader, "CONTINUEIF NEXT(1:1) = '#'\n" );
}
else if( nLDRMode == LDRM_VARIABLE )
{
const char *pszDataFilename = CPLResetExtension( pszLoaderFilename,
"dat" );
fpData = VSIFOpen( pszDataFilename, "wb" );
if( fpData == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open data output file `%s'.",
pszDataFilename );
return;
}
VSIFPrintf( fpLoader, "INFILE %s \"var 8\"\n", pszDataFilename );
}
const char *pszExpectedFIDName =
CPLGetConfigOption( "OCI_FID", "OGR_FID" );
VSIFPrintf( fpLoader, "INTO TABLE \"%s\" REPLACE\n",
poFeatureDefn->GetName() );
VSIFPrintf( fpLoader, "FIELDS TERMINATED BY '|'\n" );
VSIFPrintf( fpLoader, "TRAILING NULLCOLS (\n" );
VSIFPrintf( fpLoader, " %s INTEGER EXTERNAL,\n", pszExpectedFIDName );
VSIFPrintf( fpLoader, " %s COLUMN OBJECT (\n",
pszGeometryName );
VSIFPrintf( fpLoader, " SDO_GTYPE INTEGER EXTERNAL,\n" );
VSIFPrintf( fpLoader, " SDO_ELEM_INFO VARRAY TERMINATED BY '|/'\n" );
VSIFPrintf( fpLoader, " (elements INTEGER EXTERNAL),\n" );
VSIFPrintf( fpLoader, " SDO_ORDINATES VARRAY TERMINATED BY '|/'\n" );
VSIFPrintf( fpLoader, " (ordinates FLOAT EXTERNAL)\n" );
VSIFPrintf( fpLoader, " ),\n" );
/* -------------------------------------------------------------------- */
/* Write user field schema. */
/* -------------------------------------------------------------------- */
int iField;
for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFldDefn = poFeatureDefn->GetFieldDefn(iField);
if( poFldDefn->GetType() == OFTInteger )
{
VSIFPrintf( fpLoader, " \"%s\" INTEGER EXTERNAL",
poFldDefn->GetNameRef() );
}
else if( poFldDefn->GetType() == OFTReal )
{
VSIFPrintf( fpLoader, " \"%s\" FLOAT EXTERNAL",
poFldDefn->GetNameRef() );
}
else if( poFldDefn->GetType() == OFTString )
{
VSIFPrintf( fpLoader, " \"%s\" VARCHARC(4)",
poFldDefn->GetNameRef() );
}
else
{
VSIFPrintf( fpLoader, " \"%s\" VARCHARC(4)",
poFldDefn->GetNameRef() );
}
if( iField < poFeatureDefn->GetFieldCount() - 1 )
VSIFPrintf( fpLoader, "," );
VSIFPrintf( fpLoader, "\n" );
}
VSIFPrintf( fpLoader, ")\n" );
if( nLDRMode == LDRM_STREAM )
VSIFPrintf( fpLoader, "begindata\n" );
bHeaderWritten = TRUE;
}
OGRErr OGROCILoaderLayer::WriteFeatureStreamMode( OGRFeature *poFeature )
{
/* -------------------------------------------------------------------- */
/* Write the FID. */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpLoader, " %ld|", poFeature->GetFID() );
/* -------------------------------------------------------------------- */
/* Set the geometry */
/* -------------------------------------------------------------------- */
int nLineLen = 0;
if( poFeature->GetGeometryRef() != NULL)
{
char szSRID[128];
int nGType;
int i;
if( nSRID == -1 )
strcpy( szSRID, "NULL" );
else
sprintf( szSRID, "%d", nSRID );
if( TranslateToSDOGeometry( poFeature->GetGeometryRef(), &nGType )
== OGRERR_NONE )
{
VSIFPrintf( fpLoader, "%d|", nGType );
for( i = 0; i < nElemInfoCount; i++ )
{
VSIFPrintf( fpLoader, "%d|", panElemInfo[i] );
if( ++nLineLen > 18 && i < nElemInfoCount-1 )
{
VSIFPrintf( fpLoader, "\n#" );
nLineLen = 0;
}
}
VSIFPrintf( fpLoader, "/" );
for( i = 0; i < nOrdinalCount; i++ )
{
VSIFPrintf( fpLoader, "%.16g|", padfOrdinals[i] );
if( ++nLineLen > 6 && i < nOrdinalCount-1 )
{
VSIFPrintf( fpLoader, "\n#" );
nLineLen = 0;
}
}
VSIFPrintf( fpLoader, "/" );
}
else
{
VSIFPrintf( fpLoader, "0|/|/" );
}
}
else
{
VSIFPrintf( fpLoader, "0|/|/" );
}
/* -------------------------------------------------------------------- */
/* Set the other fields. */
/* -------------------------------------------------------------------- */
int i;
nLineLen = 0;
VSIFPrintf( fpLoader, "\n#" );
for( i = 0; i < poFeatureDefn->GetFieldCount(); i++ )
{
OGRFieldDefn *poFldDefn = poFeatureDefn->GetFieldDefn(i);
if( !poFeature->IsFieldSet( i ) )
{
if( poFldDefn->GetType() != OFTInteger
&& poFldDefn->GetType() != OFTReal )
VSIFPrintf( fpLoader, "%04d", 0 );
continue;
}
const char *pszStrValue = poFeature->GetFieldAsString(i);
if( nLineLen > 70 )
{
VSIFPrintf( fpLoader, "\n#" );
nLineLen = 0;
}
nLineLen += strlen(pszStrValue);
if( poFldDefn->GetType() == OFTInteger
|| poFldDefn->GetType() == OFTReal )
{
if( poFldDefn->GetWidth() > 0 && bPreservePrecision
&& (int) strlen(pszStrValue) > poFldDefn->GetWidth() )
{
ReportTruncation( poFldDefn );
VSIFPrintf( fpLoader, "|" );
}
else
VSIFPrintf( fpLoader, "%s|", pszStrValue );
}
else
{
int nLength = strlen(pszStrValue);
if( poFldDefn->GetWidth() > 0 && nLength > poFldDefn->GetWidth() )
{
ReportTruncation( poFldDefn );
nLength = poFldDefn->GetWidth();
}
VSIFPrintf( fpLoader, "%04d", nLength );
VSIFWrite( (void *) pszStrValue, 1, nLength, fpLoader );
}
}
if( VSIFPrintf( fpLoader, "\n" ) == 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Write to loader file failed, likely out of disk space." );
return OGRERR_FAILURE;
}
else
return OGRERR_NONE;
}
int OGRGMLDataSource::Create( const char *pszFilename,
char **papszOptions )
{
if( fpOutput != NULL || poReader != NULL )
{
CPLAssert( FALSE );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Create the output file. */
/* -------------------------------------------------------------------- */
pszName = CPLStrdup( pszFilename );
if( EQUAL(pszFilename,"stdout") )
fpOutput = stdout;
else
fpOutput = VSIFOpen( pszFilename, "wt+" );
if( fpOutput == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create GML file %s.",
pszFilename );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Write out "standard" header. */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpOutput, "%s",
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" );
nSchemaInsertLocation = VSIFTell( fpOutput );
VSIFPrintf( fpOutput, "%s",
"<ogr:FeatureCollection\n" );
/* -------------------------------------------------------------------- */
/* Write out schema info if provided in creation options. */
/* -------------------------------------------------------------------- */
const char *pszSchemaURI = CSLFetchNameValue(papszOptions,"XSISCHEMAURI");
const char *pszSchemaOpt = CSLFetchNameValue( papszOptions, "XSISCHEMA" );
if( pszSchemaURI != NULL )
{
VSIFPrintf( fpOutput,
" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
" xsi:schemaLocation=\"%s\"\n",
CSLFetchNameValue( papszOptions, "XSISCHEMAURI" ) );
}
else if( pszSchemaOpt == NULL || EQUAL(pszSchemaOpt,"EXTERNAL") )
{
char *pszBasename = CPLStrdup(CPLGetBasename( pszName ));
VSIFPrintf( fpOutput,
" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
" xsi:schemaLocation=\"http://ogr.maptools.org/ %s\"\n",
CPLResetExtension( pszBasename, "xsd" ) );
CPLFree( pszBasename );
}
VSIFPrintf( fpOutput, "%s",
" xmlns:ogr=\"http://ogr.maptools.org/\"\n" );
VSIFPrintf( fpOutput, "%s",
" xmlns:gml=\"http://www.opengis.net/gml\">\n" );
/* -------------------------------------------------------------------- */
/* Should we initialize an area to place the boundedBy element? */
/* We will need to seek back to fill it in. */
/* -------------------------------------------------------------------- */
if( CSLFetchBoolean( papszOptions, "BOUNDEDBY", TRUE ) )
{
nBoundedByLocation = VSIFTell( fpOutput );
if( nBoundedByLocation != -1 )
VSIFPrintf( fpOutput, "%280s\n", "" );
}
else
nBoundedByLocation = -1;
return TRUE;
}