static void ReportOnLayer( OGRLayer * poLayer ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); printf( "\n" ); printf( "Layer name: %s\n", poDefn->GetName() ); printf( "Feature Count: %d\n", poLayer->GetFeatureCount() ); if( bVerbose ) { char *pszWKT; if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(NULL)" ); else poLayer->GetSpatialRef()->exportToWkt( &pszWKT ); printf( "Layer SRS WKT: %s\n", pszWKT ); CPLFree( pszWKT ); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); printf( "%s: %s (%d.%d)\n", poField->GetNameRef(), poField->GetFieldTypeName( poField->GetType() ), poField->GetWidth(), poField->GetPrecision() ); } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( stdout ); delete poFeature; } }
OGRErr OGRLayerWithTransaction::AlterFieldDefn( int iField, OGRFieldDefn* poNewFieldDefn, int nFlags ) { if( !m_poDecoratedLayer ) return OGRERR_FAILURE; OGRErr eErr = m_poDecoratedLayer->AlterFieldDefn(iField, poNewFieldDefn, nFlags); if( m_poFeatureDefn && eErr == OGRERR_NONE ) { OGRFieldDefn* poSrcFieldDefn = m_poDecoratedLayer->GetLayerDefn()->GetFieldDefn(iField); OGRFieldDefn* poDstFieldDefn = m_poFeatureDefn->GetFieldDefn(iField); poDstFieldDefn->SetName(poSrcFieldDefn->GetNameRef()); poDstFieldDefn->SetType(poSrcFieldDefn->GetType()); poDstFieldDefn->SetSubType(poSrcFieldDefn->GetSubType()); poDstFieldDefn->SetWidth(poSrcFieldDefn->GetWidth()); poDstFieldDefn->SetPrecision(poSrcFieldDefn->GetPrecision()); poDstFieldDefn->SetDefault(poSrcFieldDefn->GetDefault()); poDstFieldDefn->SetNullable(poSrcFieldDefn->IsNullable()); } return eErr; }
int main( int nArgc, char ** papszArgv ) { int nFirstSourceDataset = -1, bLayersWildcarded = TRUE, iArg; const char *pszFormat = "ESRI Shapefile"; const char *pszTileIndexField = "LOCATION"; const char *pszOutputName = NULL; int write_absolute_path = FALSE; int skip_different_projection = FALSE; char* current_path = NULL; int accept_different_schemas = FALSE; int bFirstWarningForNonMatchingAttributes = TRUE; /* Check strict compilation and runtime library version as we use C++ API */ if (! GDAL_CHECK_VERSION(papszArgv[0])) exit(1); /* -------------------------------------------------------------------- */ /* Register format(s). */ /* -------------------------------------------------------------------- */ OGRRegisterAll(); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ for( iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } else if( EQUAL(papszArgv[iArg],"-f") && iArg < nArgc-1 ) { pszFormat = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-write_absolute_path")) { write_absolute_path = TRUE; } else if( EQUAL(papszArgv[iArg],"-skip_different_projection")) { skip_different_projection = TRUE; } else if( EQUAL(papszArgv[iArg],"-accept_different_schemas")) { accept_different_schemas = TRUE; } else if( EQUAL(papszArgv[iArg],"-tileindex") && iArg < nArgc-1 ) { pszTileIndexField = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-lnum") || EQUAL(papszArgv[iArg],"-lname") ) { iArg++; bLayersWildcarded = FALSE; } else if( papszArgv[iArg][0] == '-' ) Usage(); else if( pszOutputName == NULL ) pszOutputName = papszArgv[iArg]; else if( nFirstSourceDataset == -1 ) nFirstSourceDataset = iArg; } if( pszOutputName == NULL || nFirstSourceDataset == -1 ) Usage(); /* -------------------------------------------------------------------- */ /* Try to open as an existing dataset for update access. */ /* -------------------------------------------------------------------- */ OGRDataSource *poDstDS; OGRLayer *poDstLayer = NULL; poDstDS = OGRSFDriverRegistrar::Open( pszOutputName, TRUE ); /* -------------------------------------------------------------------- */ /* If that failed, find the driver so we can create the tile index.*/ /* -------------------------------------------------------------------- */ if( poDstDS == NULL ) { OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar(); OGRSFDriver *poDriver = NULL; int iDriver; for( iDriver = 0; iDriver < poR->GetDriverCount() && poDriver == NULL; iDriver++ ) { if( EQUAL(poR->GetDriver(iDriver)->GetName(),pszFormat) ) { poDriver = poR->GetDriver(iDriver); } } if( poDriver == NULL ) { fprintf( stderr, "Unable to find driver `%s'.\n", pszFormat ); fprintf( stderr, "The following drivers are available:\n" ); for( iDriver = 0; iDriver < poR->GetDriverCount(); iDriver++ ) { fprintf( stderr, " -> `%s'\n", poR->GetDriver(iDriver)->GetName() ); } exit( 1 ); } if( !poDriver->TestCapability( ODrCCreateDataSource ) ) { fprintf( stderr, "%s driver does not support data source creation.\n", pszFormat ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Now create it. */ /* -------------------------------------------------------------------- */ poDstDS = poDriver->CreateDataSource( pszOutputName, NULL ); if( poDstDS == NULL ) { fprintf( stderr, "%s driver failed to create %s\n", pszFormat, pszOutputName ); exit( 1 ); } if( poDstDS->GetLayerCount() == 0 ) { OGRFieldDefn oLocation( pszTileIndexField, OFTString ); oLocation.SetWidth( 200 ); if( nFirstSourceDataset < nArgc && papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; } OGRSpatialReference* poSrcSpatialRef = NULL; /* Fetches the SRS of the first layer and use it when creating the tileindex layer */ if (nFirstSourceDataset < nArgc) { OGRDataSource* poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if (poDS) { int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; if ( poLayer->GetSpatialRef() ) poSrcSpatialRef = poLayer->GetSpatialRef()->Clone(); break; } } OGRDataSource::DestroyDataSource( poDS ); } poDstLayer = poDstDS->CreateLayer( "tileindex", poSrcSpatialRef ); poDstLayer->CreateField( &oLocation, OFTString ); OGRSpatialReference::DestroySpatialReference( poSrcSpatialRef ); } } /* -------------------------------------------------------------------- */ /* Identify target layer and field. */ /* -------------------------------------------------------------------- */ int iTileIndexField; poDstLayer = poDstDS->GetLayer(0); if( poDstLayer == NULL ) { fprintf( stderr, "Can't find any layer in output tileindex!\n" ); exit( 1 ); } iTileIndexField = poDstLayer->GetLayerDefn()->GetFieldIndex( pszTileIndexField ); if( iTileIndexField == -1 ) { fprintf( stderr, "Can't find %s field in tile index dataset.\n", pszTileIndexField ); exit( 1 ); } OGRFeatureDefn* poFeatureDefn = NULL; /* Load in memory existing file names in SHP */ int nExistingLayers = 0; char** existingLayersTab = NULL; OGRSpatialReference* alreadyExistingSpatialRef = NULL; int alreadyExistingSpatialRefValid = FALSE; nExistingLayers = poDstLayer->GetFeatureCount(); if (nExistingLayers) { int i; existingLayersTab = (char**)CPLMalloc(nExistingLayers * sizeof(char*)); for(i=0;i<nExistingLayers;i++) { OGRFeature* feature = poDstLayer->GetNextFeature(); existingLayersTab[i] = CPLStrdup(feature->GetFieldAsString( iTileIndexField)); if (i == 0) { OGRDataSource *poDS; char* filename = CPLStrdup(existingLayersTab[i]); int j; for(j=strlen(filename)-1;j>=0;j--) { if (filename[j] == ',') break; } if (j >= 0) { int iLayer = atoi(filename + j + 1); filename[j] = 0; poDS = OGRSFDriverRegistrar::Open(filename, FALSE ); if (poDS) { OGRLayer *poLayer = poDS->GetLayer(iLayer); if (poLayer) { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (poLayer->GetSpatialRef()) ? poLayer->GetSpatialRef()->Clone() : NULL; if (poFeatureDefn == NULL) poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } OGRDataSource::DestroyDataSource( poDS ); } } } } } if (write_absolute_path) { current_path = CPLGetCurrentDir(); if (current_path == NULL) { fprintf( stderr, "This system does not support the CPLGetCurrentDir call. " "The option -write_absolute_path will have no effect\n"); write_absolute_path = FALSE; } } /* ==================================================================== */ /* Process each input datasource in turn. */ /* ==================================================================== */ for(; nFirstSourceDataset < nArgc; nFirstSourceDataset++ ) { int i; OGRDataSource *poDS; if( papszArgv[nFirstSourceDataset][0] == '-' ) { nFirstSourceDataset++; continue; } char* fileNameToWrite; VSIStatBuf sStatBuf; if (write_absolute_path && CPLIsFilenameRelative( papszArgv[nFirstSourceDataset] ) && VSIStat( papszArgv[nFirstSourceDataset], &sStatBuf ) == 0) { fileNameToWrite = CPLStrdup(CPLProjectRelativeFilename(current_path,papszArgv[nFirstSourceDataset])); } else { fileNameToWrite = CPLStrdup(papszArgv[nFirstSourceDataset]); } poDS = OGRSFDriverRegistrar::Open( papszArgv[nFirstSourceDataset], FALSE ); if( poDS == NULL ) { fprintf( stderr, "Failed to open dataset %s, skipping.\n", papszArgv[nFirstSourceDataset] ); CPLFree(fileNameToWrite); continue; } /* -------------------------------------------------------------------- */ /* Check all layers, and see if they match requests. */ /* -------------------------------------------------------------------- */ int iLayer; for( iLayer = 0; iLayer < poDS->GetLayerCount(); iLayer++ ) { int bRequested = bLayersWildcarded; OGRLayer *poLayer = poDS->GetLayer(iLayer); for( iArg = 1; iArg < nArgc && !bRequested; iArg++ ) { if( EQUAL(papszArgv[iArg],"-lnum") && atoi(papszArgv[iArg+1]) == iLayer ) bRequested = TRUE; else if( EQUAL(papszArgv[iArg],"-lname") && EQUAL(papszArgv[iArg+1], poLayer->GetLayerDefn()->GetName()) ) bRequested = TRUE; } if( !bRequested ) continue; /* Checks that the layer is not already in tileindex */ for(i=0;i<nExistingLayers;i++) { char szLocation[5000]; sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); if (EQUAL(szLocation, existingLayersTab[i])) { fprintf(stderr, "Layer %d of %s is already in tileindex. Skipping it.\n", iLayer, papszArgv[nFirstSourceDataset]); break; } } if (i != nExistingLayers) { continue; } OGRSpatialReference* spatialRef = poLayer->GetSpatialRef(); if (alreadyExistingSpatialRefValid) { if ((spatialRef != NULL && alreadyExistingSpatialRef != NULL && spatialRef->IsSame(alreadyExistingSpatialRef) == FALSE) || ((spatialRef != NULL) != (alreadyExistingSpatialRef != NULL))) { fprintf(stderr, "Warning : layer %d of %s is not using the same projection system as " "other files in the tileindex. This may cause problems when " "using it in MapServer for example.%s\n", iLayer, papszArgv[nFirstSourceDataset], (skip_different_projection) ? " Skipping it" : ""); if (skip_different_projection) { continue; } } } else { alreadyExistingSpatialRefValid = TRUE; alreadyExistingSpatialRef = (spatialRef) ? spatialRef->Clone() : NULL; } /* -------------------------------------------------------------------- */ /* Check if all layers in dataset have the same attributes schema. */ /* -------------------------------------------------------------------- */ if( poFeatureDefn == NULL ) { poFeatureDefn = poLayer->GetLayerDefn()->Clone(); } else if ( !accept_different_schemas ) { OGRFeatureDefn* poFeatureDefnCur = poLayer->GetLayerDefn(); assert(NULL != poFeatureDefnCur); int fieldCount = poFeatureDefnCur->GetFieldCount(); if( fieldCount != poFeatureDefn->GetFieldCount()) { fprintf( stderr, "Number of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } continue; } int bSkip = FALSE; for( int fn = 0; fn < poFeatureDefnCur->GetFieldCount(); fn++ ) { OGRFieldDefn* poField = poFeatureDefn->GetFieldDefn(fn); OGRFieldDefn* poFieldCur = poFeatureDefnCur->GetFieldDefn(fn); /* XXX - Should those pointers be checked against NULL? */ assert(NULL != poField); assert(NULL != poFieldCur); if( poField->GetType() != poFieldCur->GetType() || poField->GetWidth() != poFieldCur->GetWidth() || poField->GetPrecision() != poFieldCur->GetPrecision() || !EQUAL( poField->GetNameRef(), poFieldCur->GetNameRef() ) ) { fprintf( stderr, "Schema of attributes of layer %s of %s does not match ... skipping it.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset]); if (bFirstWarningForNonMatchingAttributes) { fprintf( stderr, "Note : you can override this behaviour with -accept_different_schemas option\n" "but this may result in a tileindex incompatible with MapServer\n"); bFirstWarningForNonMatchingAttributes = FALSE; } bSkip = TRUE; break; } } if (bSkip) continue; } /* -------------------------------------------------------------------- */ /* Get layer extents, and create a corresponding polygon */ /* geometry. */ /* -------------------------------------------------------------------- */ OGREnvelope sExtents; OGRPolygon oRegion; OGRLinearRing oRing; if( poLayer->GetExtent( &sExtents, TRUE ) != OGRERR_NONE ) { fprintf( stderr, "GetExtent() failed on layer %s of %s, skipping.\n", poLayer->GetLayerDefn()->GetName(), papszArgv[nFirstSourceDataset] ); continue; } oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MaxY ); oRing.addPoint( sExtents.MaxX, sExtents.MinY ); oRing.addPoint( sExtents.MinX, sExtents.MinY ); oRegion.addRing( &oRing ); /* -------------------------------------------------------------------- */ /* Add layer to tileindex. */ /* -------------------------------------------------------------------- */ char szLocation[5000]; OGRFeature oTileFeat( poDstLayer->GetLayerDefn() ); sprintf( szLocation, "%s,%d", fileNameToWrite, iLayer ); oTileFeat.SetGeometry( &oRegion ); oTileFeat.SetField( iTileIndexField, szLocation ); if( poDstLayer->CreateFeature( &oTileFeat ) != OGRERR_NONE ) { fprintf( stderr, "Failed to create feature on tile index ... terminating." ); OGRDataSource::DestroyDataSource( poDstDS ); exit( 1 ); } } /* -------------------------------------------------------------------- */ /* Cleanup this data source. */ /* -------------------------------------------------------------------- */ CPLFree(fileNameToWrite); OGRDataSource::DestroyDataSource( poDS ); } /* -------------------------------------------------------------------- */ /* Close tile index and clear buffers. */ /* -------------------------------------------------------------------- */ OGRDataSource::DestroyDataSource( poDstDS ); OGRFeatureDefn::DestroyFeatureDefn( poFeatureDefn ); if (alreadyExistingSpatialRef != NULL) OGRSpatialReference::DestroySpatialReference( alreadyExistingSpatialRef ); CPLFree(current_path); if (nExistingLayers) { int i; for(i=0;i<nExistingLayers;i++) { CPLFree(existingLayersTab[i]); } CPLFree(existingLayersTab); } return 0; }
/********************************************************************** * Tab2Tab() * * Copy features from source dataset to a new dataset **********************************************************************/ static int Tab2Tab(const char *pszSrcFname, const char *pszDstFname, int nMaxFeatures, GBool bQuickSpatialIndexMode, GBool bOptSpatialIndexMode) { IMapInfoFile *poSrcFile = NULL, *poDstFile = NULL; int nFeatureId, iField, numFeatures=0; TABFeature *poFeature; double dXMin, dYMin, dXMax, dYMax; /*--------------------------------------------------------------------- * If there is a "micdsys.txt" in current directory then load it *--------------------------------------------------------------------*/ MITABLoadCoordSysTable("micdsys.txt"); /*--------------------------------------------------------------------- * Try to open source file *--------------------------------------------------------------------*/ if ((poSrcFile = IMapInfoFile::SmartOpen(pszSrcFname)) == NULL) { printf("Failed to open %s\n", pszSrcFname); return -1; } OGRFeatureDefn *poDefn = poSrcFile->GetLayerDefn(); /*--------------------------------------------------------------------- * The extension of the output filename tells us if we should create * a MIF or a TAB file for output. *--------------------------------------------------------------------*/ if (EQUAL(".mif", pszDstFname + strlen(pszDstFname)-4) || EQUAL(".mid", pszDstFname + strlen(pszDstFname)-4) ) { // Create a MIF file poDstFile = new MIFFile; } else { /*----------------------------------------------------------------- * Create a TAB dataset. * Find out if the file contains at least 1 unique field... if so we * will create a TABView instead of a TABFile *----------------------------------------------------------------*/ GBool bFoundUniqueField = FALSE; for(iField=0; iField< poDefn->GetFieldCount(); iField++) { if (poSrcFile->IsFieldUnique(iField)) bFoundUniqueField = TRUE; } if (bFoundUniqueField) poDstFile = new TABView; else poDstFile = new TABFile; } /*--------------------------------------------------------------------- * Try to open destination file *--------------------------------------------------------------------*/ if (poDstFile->Open(pszDstFname, "wb") != 0) { printf("Failed to open %s\n", pszDstFname); poSrcFile->Close(); delete poSrcFile; delete poDstFile; return -1; } if ( (bQuickSpatialIndexMode && poDstFile->SetQuickSpatialIndexMode(TRUE) != 0) || (bOptSpatialIndexMode && poDstFile->SetQuickSpatialIndexMode(FALSE) != 0) ) { printf("Failed setting Quick Spatial Index Mode (-q|-o) on %s\n", pszDstFname); poSrcFile->Close(); delete poSrcFile; poDstFile->Close(); delete poDstFile; return -1; } // Pass Proj. info directly // TABProjInfo sProjInfo; // if (poSrcFile->GetProjInfo(&sProjInfo) == 0) // poDstFile->SetProjInfo(&sProjInfo); OGRSpatialReference *poSR; poSR = poSrcFile->GetSpatialRef(); if( poSR != NULL ) { poDstFile->SetSpatialRef( poSR ); } // Set bounds (must be done after setting spatialref) if (poSrcFile->GetBounds(dXMin, dYMin, dXMax, dYMax) == 0) poDstFile->SetBounds(dXMin, dYMin, dXMax, dYMax); /*--------------------------------------------------------------------- * Pass compplete fields information *--------------------------------------------------------------------*/ for(iField=0; iField< poDefn->GetFieldCount(); iField++) { OGRFieldDefn *poFieldDefn = poDefn->GetFieldDefn(iField); poDstFile->AddFieldNative(poFieldDefn->GetNameRef(), poSrcFile->GetNativeFieldType(iField), poFieldDefn->GetWidth(), poFieldDefn->GetPrecision(), poSrcFile->IsFieldIndexed(iField), poSrcFile->IsFieldUnique(iField)); } /*--------------------------------------------------------------------- * Copy objects until EOF is reached *--------------------------------------------------------------------*/ nFeatureId = -1; while ( (nFeatureId = poSrcFile->GetNextFeatureId(nFeatureId)) != -1 && (nMaxFeatures < 1 || numFeatures++ < nMaxFeatures )) { poFeature = poSrcFile->GetFeatureRef(nFeatureId); if (poFeature) { // poFeature->DumpReadable(stdout); // poFeature->DumpMIF(); poDstFile->CreateFeature(poFeature); } else { printf( "Failed to read feature %d.\n", nFeatureId ); return -1; // GetFeatureRef() failed: Error } } /*--------------------------------------------------------------------- * Cleanup and exit. *--------------------------------------------------------------------*/ poDstFile->Close(); delete poDstFile; poSrcFile->Close(); delete poSrcFile; MITABFreeCoordSysTable(); return 0; }
static void ReportOnLayer( OGRLayer * poLayer, const char *pszWHERE, OGRGeometry *poSpatialFilter ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Set filters if provided. */ /* -------------------------------------------------------------------- */ if( pszWHERE != NULL ) poLayer->SetAttributeFilter( pszWHERE ); if( poSpatialFilter != NULL ) poLayer->SetSpatialFilter( poSpatialFilter ); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf( "\n" ); printf( "Layer name: %s\n", poDefn->GetName() ); if( bVerbose ) { printf( "Geometry: %s\n", OGRGeometryTypeToName( poDefn->GetGeomType() ) ); printf( "Feature Count: %d\n", poLayer->GetFeatureCount() ); OGREnvelope oExt; if (poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { printf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } char *pszWKT; if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poLayer->GetSpatialRef()->exportToPrettyWkt( &pszWKT ); } printf( "Layer SRS WKT:\n%s\n", pszWKT ); CPLFree( pszWKT ); if( strlen(poLayer->GetFIDColumn()) > 0 ) printf( "FID Column = %s\n", poLayer->GetFIDColumn() ); if( strlen(poLayer->GetGeometryColumn()) > 0 ) printf( "Geometry Column = %s\n", poLayer->GetGeometryColumn() ); for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); printf( "%s: %s (%d.%d)\n", poField->GetNameRef(), poField->GetFieldTypeName( poField->GetType() ), poField->GetWidth(), poField->GetPrecision() ); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = NULL; if( nFetchFID == OGRNullFID && !bSummaryOnly ) { while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( NULL, papszOptions ); OGRFeature::DestroyFeature( poFeature ); } } else if( nFetchFID != OGRNullFID ) { poFeature = poLayer->GetFeature( nFetchFID ); if( poFeature == NULL ) { printf( "Unable to locate feature id %d on this layer.\n", nFetchFID ); } else { poFeature->DumpReadable( NULL, papszOptions ); OGRFeature::DestroyFeature( poFeature ); } } }
static void ReportOnLayer( OGRLayer * poLayer, int bVerbose ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf( "\n" ); printf( "Layer name: %s\n", poLayer->GetName() ); if( bVerbose ) { int nGeomFieldCount = poLayer->GetLayerDefn()->GetGeomFieldCount(); if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); printf( "Geometry (%s): %s\n", poGFldDefn->GetNameRef(), OGRGeometryTypeToName( poGFldDefn->GetType() ) ); } } else { printf( "Geometry: %s\n", OGRGeometryTypeToName( poLayer->GetGeomType() ) ); } printf( "Feature Count: " CPL_FRMT_GIB "\n", poLayer->GetFeatureCount() ); OGREnvelope oExt; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { if (poLayer->GetExtent(iGeom, &oExt, TRUE) == OGRERR_NONE) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); CPLprintf("Extent (%s): (%f, %f) - (%f, %f)\n", poGFldDefn->GetNameRef(), oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } } } else if ( poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { CPLprintf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } char *pszWKT; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); OGRSpatialReference* poSRS = poGFldDefn->GetSpatialRef(); if( poSRS == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poSRS->exportToPrettyWkt( &pszWKT ); } printf( "SRS WKT (%s):\n%s\n", poGFldDefn->GetNameRef(), pszWKT ); CPLFree( pszWKT ); } } else { if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(unknown)" ); else { poLayer->GetSpatialRef()->exportToPrettyWkt( &pszWKT ); } printf( "Layer SRS WKT:\n%s\n", pszWKT ); CPLFree( pszWKT ); } if( strlen(poLayer->GetFIDColumn()) > 0 ) printf( "FID Column = %s\n", poLayer->GetFIDColumn() ); for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); if( nGeomFieldCount == 1 && EQUAL(poGFldDefn->GetNameRef(), "") && poGFldDefn->IsNullable() ) break; printf( "Geometry Column "); if( nGeomFieldCount > 1 ) printf("%d ", iGeom + 1); if( !poGFldDefn->IsNullable() ) printf("NOT NULL "); printf("= %s\n", poGFldDefn->GetNameRef() ); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); const char* pszType = (poField->GetSubType() != OFSTNone) ? CPLSPrintf("%s(%s)", poField->GetFieldTypeName( poField->GetType() ), poField->GetFieldSubTypeName(poField->GetSubType())) : poField->GetFieldTypeName( poField->GetType() ); printf( "%s: %s (%d.%d)", poField->GetNameRef(), pszType, poField->GetWidth(), poField->GetPrecision() ); if( !poField->IsNullable() ) printf(" NOT NULL"); if( poField->GetDefault() != NULL ) printf(" DEFAULT %s", poField->GetDefault() ); printf( "\n" ); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = NULL; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( NULL ); OGRFeature::DestroyFeature( poFeature ); } }
static CPLString OGRPGTableLayerGetType(OGRFieldDefn& oField, int bPreservePrecision, int bApproxOK) { char szFieldType[256]; /* -------------------------------------------------------------------- */ /* Work out the PostgreSQL type. */ /* -------------------------------------------------------------------- */ if( oField.GetType() == OFTInteger ) { if( oField.GetWidth() > 0 && bPreservePrecision ) sprintf( szFieldType, "NUMERIC(%d,0)", oField.GetWidth() ); else strcpy( szFieldType, "INTEGER" ); } else if( oField.GetType() == OFTReal ) { if( oField.GetWidth() > 0 && oField.GetPrecision() > 0 && bPreservePrecision ) sprintf( szFieldType, "NUMERIC(%d,%d)", oField.GetWidth(), oField.GetPrecision() ); else strcpy( szFieldType, "FLOAT8" ); } else if( oField.GetType() == OFTString ) { if (oField.GetWidth() > 0 && bPreservePrecision ) sprintf( szFieldType, "VARCHAR(%d)", oField.GetWidth() ); else strcpy( szFieldType, "VARCHAR"); } else if( oField.GetType() == OFTIntegerList ) { strcpy( szFieldType, "INTEGER[]" ); } else if( oField.GetType() == OFTRealList ) { strcpy( szFieldType, "FLOAT8[]" ); } else if( oField.GetType() == OFTStringList ) { strcpy( szFieldType, "varchar[]" ); } else if( oField.GetType() == OFTDate ) { strcpy( szFieldType, "date" ); } else if( oField.GetType() == OFTTime ) { strcpy( szFieldType, "time" ); } else if( oField.GetType() == OFTDateTime ) { strcpy( szFieldType, "timestamp with time zone" ); } else if( oField.GetType() == OFTBinary ) { strcpy( szFieldType, "bytea" ); } else if( bApproxOK ) { CPLError( CE_Warning, CPLE_NotSupported, "Can't create field %s with type %s on PostgreSQL layers. Creating as VARCHAR.", oField.GetNameRef(), OGRFieldDefn::GetFieldTypeName(oField.GetType()) ); strcpy( szFieldType, "VARCHAR" ); } else { CPLError( CE_Failure, CPLE_NotSupported, "Can't create field %s with type %s on PostgreSQL layers.", oField.GetNameRef(), OGRFieldDefn::GetFieldTypeName(oField.GetType()) ); strcpy( szFieldType, ""); } return szFieldType; }
static void ReportOnLayer( OGRLayer * poLayer, const char *pszWHERE, OGRGeometry *poSpatialFilter ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Set filters if provided. */ /* -------------------------------------------------------------------- */ if( pszWHERE != NULL ) poLayer->SetAttributeFilter( pszWHERE ); if( poSpatialFilter != NULL ) poLayer->SetSpatialFilter( poSpatialFilter ); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf( "\n" ); printf( "Layer name: %s\n", poDefn->GetName() ); printf( "Geometry: %s\n", OGRGeometryTypeToName( poDefn->GetGeomType() ) ); printf( "Feature Count: %d\n", poLayer->GetFeatureCount() ); OGREnvelope oExt; if (poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { printf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } if( bVerbose ) { char *pszWKT; if( poLayer->GetSpatialRef() == NULL ) pszWKT = CPLStrdup( "(NULL)" ); else poLayer->GetSpatialRef()->exportToWkt( &pszWKT ); printf( "Layer SRS WKT: %s\n", pszWKT ); CPLFree( pszWKT ); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); printf( "%s: %s (%d.%d)\n", poField->GetNameRef(), poField->GetFieldTypeName( poField->GetType() ), poField->GetWidth(), poField->GetPrecision() ); } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; while( (poFeature = poLayer->GetNextFeature()) != NULL ) { poFeature->DumpReadable( stdout ); delete poFeature; } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ #ifdef notdef OGRFeature *poFeature; int nId = -1; while( (nId = poTF->GetNextFeatureId_Spatial(nId)) != -1 ) { poFeature = poTF->GetFeatureRef( nId ); } #endif }
static void ReportOnLayer( OGRLayer * poLayer, const char *pszWHERE, const char* pszGeomField, OGRGeometry *poSpatialFilter, bool bListMDD, bool bShowMetadata, char** papszExtraMDDomains, bool bFeatureCount, bool bExtent, const char* pszWKTFormat ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Set filters if provided. */ /* -------------------------------------------------------------------- */ if( pszWHERE != nullptr ) { if( poLayer->SetAttributeFilter(pszWHERE) != OGRERR_NONE ) { printf("FAILURE: SetAttributeFilter(%s) failed.\n", pszWHERE); exit(1); } } if( poSpatialFilter != nullptr ) { if( pszGeomField != nullptr ) { const int iGeomField = poDefn->GetGeomFieldIndex(pszGeomField); if( iGeomField >= 0 ) poLayer->SetSpatialFilter(iGeomField, poSpatialFilter); else printf("WARNING: Cannot find geometry field %s.\n", pszGeomField); } else { poLayer->SetSpatialFilter(poSpatialFilter); } } /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ if( !bSuperQuiet ) { printf("\n"); printf("Layer name: %s\n", poLayer->GetName()); } GDALInfoReportMetadata(static_cast<GDALMajorObjectH>(poLayer), bListMDD, bShowMetadata, papszExtraMDDomains); if( bVerbose ) { const int nGeomFieldCount = poLayer->GetLayerDefn()->GetGeomFieldCount(); if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); printf("Geometry (%s): %s\n", poGFldDefn->GetNameRef(), OGRGeometryTypeToName(poGFldDefn->GetType())); } } else { printf("Geometry: %s\n", OGRGeometryTypeToName(poLayer->GetGeomType())); } if( bFeatureCount ) printf("Feature Count: " CPL_FRMT_GIB "\n", poLayer->GetFeatureCount()); OGREnvelope oExt; if( bExtent && nGeomFieldCount > 1 ) { for( int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { if( poLayer->GetExtent(iGeom, &oExt, TRUE) == OGRERR_NONE ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); CPLprintf("Extent (%s): (%f, %f) - (%f, %f)\n", poGFldDefn->GetNameRef(), oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } } } else if( bExtent && poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE ) { CPLprintf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } const auto displayDataAxisMapping = [](const OGRSpatialReference* poSRS) { const auto mapping = poSRS->GetDataAxisToSRSAxisMapping(); printf("Data axis to CRS axis mapping: "); for( size_t i = 0; i < mapping.size(); i++ ) { if( i > 0 ) { printf(","); } printf("%d", mapping[i]); } printf("\n"); }; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); OGRSpatialReference* poSRS = poGFldDefn->GetSpatialRef(); char *pszWKT = nullptr; if( poSRS == nullptr ) { pszWKT = CPLStrdup("(unknown)"); } else { CPLString osWKTFormat("FORMAT="); osWKTFormat += pszWKTFormat; const char* const apszWKTOptions[] = { osWKTFormat.c_str(), "MULTILINE=YES", nullptr }; poSRS->exportToWkt(&pszWKT, apszWKTOptions); } printf("SRS WKT (%s):\n%s\n", poGFldDefn->GetNameRef(), pszWKT); CPLFree(pszWKT); if( poSRS ) { displayDataAxisMapping(poSRS); } } } else { char *pszWKT = nullptr; auto poSRS = poLayer->GetSpatialRef(); if( poSRS == nullptr ) { pszWKT = CPLStrdup("(unknown)"); } else { poSRS->exportToPrettyWkt(&pszWKT); } printf("Layer SRS WKT:\n%s\n", pszWKT); CPLFree(pszWKT); if( poSRS ) { displayDataAxisMapping(poSRS); } } if( strlen(poLayer->GetFIDColumn()) > 0 ) printf("FID Column = %s\n", poLayer->GetFIDColumn()); for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); if( nGeomFieldCount == 1 && EQUAL(poGFldDefn->GetNameRef(), "") && poGFldDefn->IsNullable() ) break; printf("Geometry Column "); if( nGeomFieldCount > 1 ) printf("%d ", iGeom + 1); if( !poGFldDefn->IsNullable() ) printf("NOT NULL "); printf("= %s\n", poGFldDefn->GetNameRef()); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn(iAttr); const char* pszType = (poField->GetSubType() != OFSTNone) ? CPLSPrintf( "%s(%s)", poField->GetFieldTypeName(poField->GetType()), poField->GetFieldSubTypeName(poField->GetSubType())) : poField->GetFieldTypeName(poField->GetType()); printf("%s: %s (%d.%d)", poField->GetNameRef(), pszType, poField->GetWidth(), poField->GetPrecision()); if( !poField->IsNullable() ) printf(" NOT NULL"); if( poField->GetDefault() != nullptr ) printf(" DEFAULT %s", poField->GetDefault()); printf("\n"); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ if( nFetchFID == OGRNullFID && !bSummaryOnly ) { OGRFeature *poFeature = nullptr; while( (poFeature = poLayer->GetNextFeature()) != nullptr ) { if( !bSuperQuiet ) poFeature->DumpReadable(nullptr, papszOptions); OGRFeature::DestroyFeature(poFeature); } } else if( nFetchFID != OGRNullFID ) { OGRFeature *poFeature = poLayer->GetFeature(nFetchFID); if( poFeature == nullptr ) { printf("Unable to locate feature id " CPL_FRMT_GIB " on this layer.\n", nFetchFID); } else { poFeature->DumpReadable(nullptr, papszOptions); OGRFeature::DestroyFeature(poFeature); } } }
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 ); }
CPLXMLNode *OGRFMELayerCached::SerializeToXML() { CPLXMLNode *psLayer; char szGeomType[64]; psLayer = CPLCreateXMLNode( NULL, CXT_Element, "OGRLayer" ); /* -------------------------------------------------------------------- */ /* Handle various layer values. */ /* -------------------------------------------------------------------- */ CPLCreateXMLElementAndValue( psLayer, "Name", poFeatureDefn->GetName()); sprintf( szGeomType, "%d", (int) poFeatureDefn->GetGeomType() ); CPLCreateXMLElementAndValue( psLayer, "GeomType", szGeomType ); CPLCreateXMLElementAndValue( psLayer, "SpatialCacheName", pszIndexBase ); /* -------------------------------------------------------------------- */ /* Handle spatial reference if available. */ /* -------------------------------------------------------------------- */ if( GetSpatialRef() != NULL ) { char *pszWKT = NULL; OGRSpatialReference *poSRS = GetSpatialRef(); poSRS->exportToWkt( &pszWKT ); if( pszWKT != NULL ) { CPLCreateXMLElementAndValue( psLayer, "SRS", pszWKT ); CPLFree( pszWKT ); } } /* -------------------------------------------------------------------- */ /* Handle extents if available. */ /* -------------------------------------------------------------------- */ OGREnvelope sEnvelope; if( GetExtent( &sEnvelope, FALSE ) == OGRERR_NONE ) { char szExtent[512]; sprintf( szExtent, "%24.15E,%24.15E,%24.15E,%24.15E", sEnvelope.MinX, sEnvelope.MinY, sEnvelope.MaxX, sEnvelope.MaxY ); CPLCreateXMLElementAndValue( psLayer, "Extent", szExtent ); } /* -------------------------------------------------------------------- */ /* Emit the field schemas. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psSchema = CPLCreateXMLNode( psLayer, CXT_Element, "Schema" ); for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { OGRFieldDefn *poFieldDef = poFeatureDefn->GetFieldDefn( iField ); const char *pszType; char szWidth[32], szPrecision[32]; CPLXMLNode *psXMLFD; sprintf( szWidth, "%d", poFieldDef->GetWidth() ); sprintf( szPrecision, "%d", poFieldDef->GetPrecision() ); if( poFieldDef->GetType() == OFTInteger ) pszType = "Integer"; else if( poFieldDef->GetType() == OFTIntegerList ) pszType = "IntegerList"; else if( poFieldDef->GetType() == OFTReal ) pszType = "Real"; else if( poFieldDef->GetType() == OFTRealList ) pszType = "RealList"; else if( poFieldDef->GetType() == OFTString ) pszType = "String"; else if( poFieldDef->GetType() == OFTStringList ) pszType = "StringList"; else if( poFieldDef->GetType() == OFTBinary ) pszType = "Binary"; else pszType = "Unsupported"; psXMLFD = CPLCreateXMLNode( psSchema, CXT_Element, "OGRFieldDefn" ); CPLCreateXMLElementAndValue( psXMLFD, "Name",poFieldDef->GetNameRef()); CPLCreateXMLElementAndValue( psXMLFD, "Type", pszType ); CPLCreateXMLElementAndValue( psXMLFD, "Width", szWidth ); CPLCreateXMLElementAndValue( psXMLFD, "Precision", szPrecision ); } return psLayer; }
const char *OGRFeature::GetFieldAsString( int iField ) { OGRFieldDefn *poFDefn = poDefn->GetFieldDefn( iField ); static char szTempBuffer[80]; CPLAssert( poFDefn != NULL || iField == -1 ); if( poFDefn == NULL ) return ""; if( !IsFieldSet(iField) ) return ""; if( poFDefn->GetType() == OFTString ) { if( pauFields[iField].String == NULL ) return ""; else return pauFields[iField].String; } else if( poFDefn->GetType() == OFTInteger ) { sprintf( szTempBuffer, "%d", pauFields[iField].Integer ); return szTempBuffer; } else if( poFDefn->GetType() == OFTReal ) { char szFormat[64]; if( poFDefn->GetWidth() != 0 ) { sprintf( szFormat, "%%%d.%df", poFDefn->GetWidth(), poFDefn->GetPrecision() ); } else strcpy( szFormat, "%.16g" ); sprintf( szTempBuffer, szFormat, pauFields[iField].Real ); return szTempBuffer; } else if( poFDefn->GetType() == OFTIntegerList ) { char szItem[32]; int i, nCount = pauFields[iField].IntegerList.nCount; sprintf( szTempBuffer, "(%d:", nCount ); for( i = 0; i < nCount; i++ ) { sprintf( szItem, "%d", pauFields[iField].IntegerList.paList[i] ); if( strlen(szTempBuffer) + strlen(szItem) + 6 > sizeof(szTempBuffer) ) { break; } if( i > 0 ) strcat( szTempBuffer, "," ); strcat( szTempBuffer, szItem ); } if( i < nCount ) strcat( szTempBuffer, ",...)" ); else strcat( szTempBuffer, ")" ); return szTempBuffer; } else if( poFDefn->GetType() == OFTRealList ) { char szItem[40]; char szFormat[64]; int i, nCount = pauFields[iField].RealList.nCount; if( poFDefn->GetWidth() != 0 ) { sprintf( szFormat, "%%%d.%df", poFDefn->GetWidth(), poFDefn->GetPrecision() ); } else strcpy( szFormat, "%.16g" ); sprintf( szTempBuffer, "(%d:", nCount ); for( i = 0; i < nCount; i++ ) { sprintf( szItem, szFormat, pauFields[iField].RealList.paList[i] ); if( strlen(szTempBuffer) + strlen(szItem) + 6 > sizeof(szTempBuffer) ) { break; } if( i > 0 ) strcat( szTempBuffer, "," ); strcat( szTempBuffer, szItem ); } if( i < nCount ) strcat( szTempBuffer, ",...)" ); else strcat( szTempBuffer, ")" ); return szTempBuffer; } else if( poFDefn->GetType() == OFTStringList ) { int i, nCount = pauFields[iField].StringList.nCount; sprintf( szTempBuffer, "(%d:", nCount ); for( i = 0; i < nCount; i++ ) { const char *pszItem = pauFields[iField].StringList.paList[i]; if( strlen(szTempBuffer) + strlen(pszItem) + 6 > sizeof(szTempBuffer) ) { break; } if( i > 0 ) strcat( szTempBuffer, "," ); strcat( szTempBuffer, pszItem ); } if( i < nCount ) strcat( szTempBuffer, ",...)" ); else strcat( szTempBuffer, ")" ); return szTempBuffer; } else return ""; }