static SimpleFeatureType makeContourSchema() { /* Create the output feature schema. */ SimpleFeatureTypeBuilder tbuilder = new SimpleFeatureTypeBuilder(); tbuilder.setName("contours"); tbuilder.setCRS(DefaultGeographicCRS.WGS84); // Do not use "geom" or "geometry" below, it seems to broke shapefile generation tbuilder.add("the_geom", MultiPolygon.class); tbuilder.add("time", Integer.class); // TODO change to something more descriptive and lowercase return tbuilder.buildFeatureType(); }
/** * Transforms the original feature type into a destination one according to the renaming rules. * For the moment, it's just a feature type name replacement * * @param original * @throws IOException */ protected SimpleFeatureType transformFeatureType(SimpleFeatureType original) throws IOException { String transfomedName = transformFeatureTypeName(original.getTypeName()); if (transfomedName.equals(original.getTypeName())) return original; try { SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); b.init(original); b.setName(transfomedName); return b.buildFeatureType(); } catch (Exception e) { throw new DataSourceException("Could not build the renamed feature type.", e); } }
/** * * Takes into account eventual joins * * @param query * @return */ public SimpleFeatureType getFeatureType(Query query) { SimpleFeatureType result; if (query.getPropertyNames() != Query.ALL_NAMES) { result = SimpleFeatureTypeBuilder.retype(featureType, query.getPropertyNames()); } else { result = featureType; } // add back the joined features in case of join if (!query.getJoins().isEmpty()) { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(result); for (Join join : query.getJoins()) { String joinedFeatureAttribute = join.getAlias(); if (joinedFeatureAttribute == null) { joinedFeatureAttribute = join.getTypeName(); } tb.add(joinedFeatureAttribute, SimpleFeature.class); } result = tb.buildFeatureType(); } return result; }
public void testMaintainDefaultGeometryOnRetype() { builder.setName("testGeometries"); builder.add("geo1", Point.class, DefaultGeographicCRS.WGS84); builder.add("geo2", Polygon.class, DefaultGeographicCRS.WGS84); builder.setDefaultGeometry("geo1"); SimpleFeatureType type = builder.buildFeatureType(); // performing an attribute selection, even changing order, should not change // the default geometry, that had a special meaning in the original source SimpleFeatureType retyped = SimpleFeatureTypeBuilder.retype(type, new String[] {"geo2", "geo1"}); assertEquals("geo1", retyped.getGeometryDescriptor().getLocalName()); }
Set<String> properties = new HashSet<String>(Arrays.asList(query.getPropertyNames())); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(sft); for (AttributeDescriptor at : sft.getAttributeDescriptors()) { return tb.buildFeatureType(); } else {
/** @return a simple feature type with location before count */ private SimpleFeatureType buildLocationCountType() { SimpleFeatureTypeBuilder builder = buildPartialBuilder(); builder.add("location", Point.class, (CoordinateReferenceSystem) null); builder.add("count", Integer.class); return builder.buildFeatureType(); }
static SimpleFeatureType makePointSchema() { SimpleFeatureTypeBuilder tbuilder = new SimpleFeatureTypeBuilder(); tbuilder.setName("points"); tbuilder.setCRS(DefaultGeographicCRS.WGS84); tbuilder.add("Geometry", Point.class); tbuilder.add("Time", Integer.class); return tbuilder.buildFeatureType(); }
@Before public void setup() throws SchemaException { SimpleFeatureType originalSchema = DataUtilities.createType( "BasicPolygons", "the_geom:MultiPolygon:srid=4326,ID:String,value:int"); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(originalSchema); tb.setName("BasicPolygons2"); renamedSchema = tb.buildFeatureType(); collection = new ListFeatureCollection(originalSchema) { public void accepts(FeatureVisitor visitor, ProgressListener progress) throws java.io.IOException { lastVisitor = visitor; }; }; }
SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.init(schema); typeBuilder.add(attName, SimpleFeature.class); schema = typeBuilder.buildFeatureType();
public void testRetypeGeometryless() { builder.setName("testGeometryless"); builder.add("geo1", Point.class, DefaultGeographicCRS.WGS84); builder.add("integer", Integer.class); builder.setDefaultGeometry("geo1"); SimpleFeatureType type = builder.buildFeatureType(); // performing an attribute selection, even changing order, should not change // the default geometry, that had a special meaning in the original source SimpleFeatureType retyped = SimpleFeatureTypeBuilder.retype(type, new String[] {"integer"}); assertNotNull(retyped); assertNull(retyped.getGeometryDescriptor()); assertEquals(1, retyped.getAttributeCount()); assertEquals("integer", retyped.getAttributeDescriptors().get(0).getLocalName()); }
/** @return a simple feature type with count before location */ private SimpleFeatureType buildCountLocationType() { SimpleFeatureTypeBuilder builder = buildPartialBuilder(); builder.add("count", Integer.class); builder.add("location", Point.class, (CoordinateReferenceSystem) null); return builder.buildFeatureType(); }
static SimpleFeatureType makeContourSchema() { /* Create the output feature schema. */ SimpleFeatureTypeBuilder tbuilder = new SimpleFeatureTypeBuilder(); tbuilder.setName("contours"); tbuilder.setCRS(DefaultGeographicCRS.WGS84); tbuilder.add("Geometry", MultiPolygon.class); tbuilder.add("Time", Integer.class); return tbuilder.buildFeatureType(); }
result = new CompositeFeatureCollection(collections, schema); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(schema); tb.setName(coverageView.getName()); return new RetypingFeatureCollection(result, tb.buildFeatureType()) { @Override public SimpleFeatureIterator features() {
protected SimpleFeatureType createSchema() throws SchemaException { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); for (int i = 0, ii = attributeReader.getAttributeCount(); i < ii; i++) { builder.add(attributeReader.getAttributeType(i)); } return builder.buildFeatureType(); }
/** * Flattens a SimpleFeatureCollection that may contain SimpleFeatures as attributes of other * features. * * @param collection The input SimpleFeatureCollection * @return A SimpleFeatureCollection whose features have no SimpleFeature attributes, or the * original one, if no SimpleFeature attributes were found */ public static SimpleFeatureCollection flatten(SimpleFeatureCollection collection) { SimpleFeatureType schema = collection.getSchema(); // collect the attributes List<AttributeDescriptor> attributeDescriptors = new ArrayList<AttributeDescriptor>(); scanAttributeDescriptors(attributeDescriptors, schema, null); // build the flattened feature type SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(schema.getName()); for (AttributeDescriptor desc : attributeDescriptors) builder.add(desc); SimpleFeatureType flattenedType = builder.buildFeatureType(); // if the number of attributes is the same, we did not encounter a new attribute if (collection.getSchema().getAttributeCount() == flattenedType.getAttributeCount()) { return collection; } return new FlatteningFeatureCollection(collection, flattenedType); }
@Test public void testSimpleRename() throws IOException { SimpleFeatureSource fs = store.getFeatureSource(BUILDINGS.getLocalPart()); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(fs.getSchema()); tb.setName("houses"); SimpleFeatureType target = tb.buildFeatureType(); SimpleFeatureSource retyped = RetypingFeatureSource.getRetypingSource(fs, target); assertTrue(retyped instanceof SimpleFeatureLocking); assertEquals(target, retyped.getSchema()); assertEquals(target, ((DataStore) retyped.getDataStore()).getSchema("houses")); assertEquals(target, retyped.getFeatures().getSchema()); SimpleFeatureIterator it = retyped.getFeatures().features(); SimpleFeature f = it.next(); it.close(); assertEquals(target, f.getType()); }
private SimpleFeatureType buildTargetSchema(SimpleFeatureType sourceSchema) { if (sourceSchema.getDescriptor("location") != null) { return sourceSchema; } SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(sourceSchema); tb.add("location", String.class); return tb.buildFeatureType(); } }
SimpleFeatureTypeBuilder ftb = new SimpleFeatureTypeBuilder(); ftb.add("description", String.class); ftb.add("pointProperty", MultiPoint.class); // poly -> multi-poly ftb.add("intProperty", Long.class); // int -> long ftb.add("dateTimeProperty", Date.class); // timestamp -> date ftb.add("newProperty", String.class); // new property ftb.setName(RENAMED); // rename type primitive = ftb.buildFeatureType();
assertNotNull(store.getSchema(BRIDGES.getLocalPart())); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(fs.getSchema()); tb.setName(BRIDGES.getLocalPart()); SimpleFeatureType target = tb.buildFeatureType();
static SimpleFeatureType retype(SimpleFeatureType featureType, JoinInfo join) { SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); b.init(featureType); for (JoinPart part : join.getParts()) { b.add(part.getAttributeName(), SimpleFeature.class); } return b.buildFeatureType(); } }