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