public void setNamespaceURI(URI namespaceURI) { if (namespaceURI != null) { setNamespaceURI(namespaceURI.toString()); } else { setNamespaceURI((String) null); } } /** The namespace uri of the built type. */
tb.setNamespaceURI(info.getNamespace().getURI());
private static SimpleFeatureType createSchema( final String typeName, final String namespace, final List<AttributeDescriptor> properties) throws IOException { // TODO: use factory lookup mechanism once its in place SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(typeName); builder.setNamespaceURI(namespace); for (Iterator<AttributeDescriptor> it = properties.iterator(); it.hasNext(); ) { AttributeDescriptor attType = it.next(); builder.add(attType); } return builder.buildFeatureType(); }
/** Sets the local name and namespace uri of the built type. */ public void setName(Name name) { setName(name.getLocalPart()); setNamespaceURI(name.getNamespaceURI()); }
SimpleFeatureBuilder createBuilder() { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName("feature"); typeBuilder.setNamespaceURI("http://geotools.org"); typeBuilder.setCRS(crs); if (properties != null) { for (int i = 0; i < properties.size(); i++) { String prop = properties.get(i); Object valu = values.get(i); typeBuilder.add(prop, valu != null ? valu.getClass() : Object.class); } } if (geometry != null) { addGeometryType(typeBuilder, geometry); } return new SimpleFeatureBuilder(typeBuilder.buildFeatureType()); }
private void buildType() { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName("feature"); typeBuilder.setNamespaceURI("http://geotools.org"); if (geom != null) { typeBuilder.add(geom.getLocalName(), geom.getType().getBinding(), crs); } if (propertyTypes != null) { Set<Entry<String, Class<?>>> entrySet = propertyTypes.entrySet(); for (Entry<String, Class<?>> entry : entrySet) { Class<?> binding = entry.getValue(); if (binding.equals(Object.class)) { binding = String.class; } typeBuilder.add(entry.getKey(), binding); } } if (crs != null) { typeBuilder.setCRS(crs); } featureType = typeBuilder.buildFeatureType(); }
SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(name); builder.setNamespaceURI(namespace);
public void testEquals() throws Exception { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName("Thing"); tb.setNamespaceURI("http://www.nowhereinparticular.net"); tb.add("X", String.class); final SimpleFeatureType ft = tb.buildFeatureType(); tb = new SimpleFeatureTypeBuilder(); tb.setName("Thing"); tb.setNamespaceURI("http://www.nowhereinparticular.net"); tb.add("X", String.class); SimpleFeatureType ft2 = tb.buildFeatureType(); assertEquals(ft, ft2); tb.setName("Thingee"); assertTrue(!ft.equals(tb.buildFeatureType())); tb.init(ft); tb.setNamespaceURI("http://www.somewhereelse.net"); assertTrue(!ft.equals(tb.buildFeatureType())); assertTrue(!ft.equals(null)); }
protected void setUp() throws Exception { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName("test"); typeBuilder.setNamespaceURI("http://www.geotools.org/test"); typeBuilder.add("foo", Integer.class); typeBuilder.add("bar", Double.class); typeBuilder.add(COMPLEX_PROPERTY, Double.class); type = (SimpleFeatureType) typeBuilder.buildFeatureType(); SimpleFeatureBuilder builder = new SimpleFeatureBuilder(type); builder.add(Integer.valueOf(1)); builder.add(new Double(2.0)); builder.add(new Double(3.0)); feature = (SimpleFeature) builder.buildFeature("fid"); accessor = SimpleFeaturePropertyAccessorFactory.ATTRIBUTE_ACCESS; }
/** * Create the modified feature type. * * @param sourceFeatureType the source feature type * @return the modified feature type * @throws ProcessException errror */ private SimpleFeatureType createTargetFeatureType(FeatureType sourceFeatureType) throws ProcessException { try { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(sourceFeatureType.getName().getLocalPart()); typeBuilder.setNamespaceURI(sourceFeatureType.getName().getNamespaceURI()); for (PropertyDescriptor attbType : sourceFeatureType.getDescriptors()) { typeBuilder.add((AttributeDescriptor) attbType); } typeBuilder.minOccurs(1).maxOccurs(1).nillable(false).add("lrs_measure", Double.class); typeBuilder.setDefaultGeometry( sourceFeatureType.getGeometryDescriptor().getLocalName()); return typeBuilder.buildFeatureType(); } catch (Exception e) { LOGGER.warning("Error creating type: " + e); throw new ProcessException("Error creating type: " + e, e); } }
public static SimpleFeature feature() throws Exception { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(TEST.TestFeature.getLocalPart()); typeBuilder.setNamespaceURI(TEST.TestFeature.getNamespaceURI()); typeBuilder.add("name", String.class); typeBuilder.add("description", String.class); typeBuilder.add("geom", Point.class); typeBuilder.add("count", Integer.class); typeBuilder.add("date", Date.class); SimpleFeatureType type = typeBuilder.buildFeatureType(); SimpleFeatureBuilder builder = new SimpleFeatureBuilder(type); builder.add("theName"); builder.add("theDescription"); builder.add(point()); builder.add(Integer.valueOf(1)); builder.add(new Date()); return builder.buildFeature("fid.1"); }
private SimpleFeatureType buildTestFeatureType() { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(TEST.TestFeature.getLocalPart()); typeBuilder.setNamespaceURI(TEST.TestFeature.getNamespaceURI()); typeBuilder.add("name", String.class); typeBuilder.add("description", String.class); typeBuilder.add("geom", Point.class); typeBuilder.nillable(true); typeBuilder.add("count", Integer.class); typeBuilder.nillable(true); typeBuilder.add("date", Date.class); typeBuilder.add("data", String.class); typeBuilder.add("decimal", BigDecimal.class); SimpleFeatureType type = typeBuilder.buildFeatureType(); return type; }
public void testFeature() { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName("test"); typeBuilder.setNamespaceURI("http://www.geotools.org/test"); typeBuilder.add("foo", Integer.class); typeBuilder.add("bar", Double.class); SimpleFeatureType type = typeBuilder.buildFeatureType(); SimpleFeatureBuilder builder = new SimpleFeatureBuilder(type); builder.add(Integer.valueOf(1)); builder.add(new Double(2.0)); SimpleFeature feature = builder.buildFeature("fid"); AttributeExpressionImpl ex = new AttributeExpressionImpl("foo"); assertEquals(Integer.valueOf(1), ex.evaluate(feature)); ex = new AttributeExpressionImpl("@id"); assertEquals("fid", ex.evaluate(feature)); } }
public void testCreateSchema() throws Exception { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(tname("ft2")); builder.setNamespaceURI(dataStore.getNamespaceURI()); builder.setCRS(CRS.decode("EPSG:4326")); builder.add(aname("geometry"), Geometry.class);
@Override protected SimpleFeatureType buildFeatureType() throws IOException { final WFSDataStore dataStore = getDataStore(); final Name localTypeName = getEntry().getName(); final QName remoteTypeName = dataStore.getRemoteTypeName(localTypeName); final SimpleFeatureType remoteSimpleFeatureType; remoteSimpleFeatureType = dataStore.getRemoteSimpleFeatureType(remoteTypeName); // adapt the feature type name SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.init(remoteSimpleFeatureType); builder.setName(localTypeName); String namespaceOverride = entry.getName().getNamespaceURI(); if (namespaceOverride != null) { builder.setNamespaceURI(namespaceOverride); } GeometryDescriptor defaultGeometry = remoteSimpleFeatureType.getGeometryDescriptor(); if (defaultGeometry != null) { builder.setDefaultGeometry(defaultGeometry.getLocalName()); builder.setCRS(defaultGeometry.getCoordinateReferenceSystem()); } final SimpleFeatureType adaptedFeatureType = builder.buildFeatureType(); return adaptedFeatureType; }
public void testCRS() { builder.setName("testName"); builder.setNamespaceURI("testNamespaceURI"); builder.setCRS(DefaultGeographicCRS.WGS84); builder.crs(null).add("point", Point.class); builder.add("point2", Point.class, DefaultGeographicCRS.WGS84); builder.setDefaultGeometry("point"); SimpleFeatureType type = builder.buildFeatureType(); assertEquals(DefaultGeographicCRS.WGS84, type.getCoordinateReferenceSystem()); assertNull(type.getGeometryDescriptor().getType().getCoordinateReferenceSystem()); assertEquals( DefaultGeographicCRS.WGS84, ((GeometryType) type.getType("point2")).getCoordinateReferenceSystem()); }
public void testCreateSchemaFidColumn() throws Exception { // test a case where the feature type we are creating contains a column named "fid" SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(tname("ft2")); builder.setNamespaceURI(dataStore.getNamespaceURI()); builder.setCRS(getUTMCRS()); builder.add(aname("geometry"), Point.class); builder.add(aname("intProperty"), Integer.class); builder.add(aname("stringProperty"), String.class); builder.add(aname("fid"), String.class); SimpleFeatureType featureType = builder.buildFeatureType(); dataStore.createSchema(featureType); SimpleFeatureType ft2 = dataStore.getSchema(tname("ft2")); assertNotNull(ft2.getDescriptor(aname("fid"))); }
public void testSanity() { builder.setName("testName"); builder.setNamespaceURI("testNamespaceURI"); builder.add("point", Point.class, (CoordinateReferenceSystem) null); builder.add("integer", Integer.class); SimpleFeatureType type = builder.buildFeatureType(); assertNotNull(type); assertEquals(2, type.getAttributeCount()); AttributeType t = type.getType("point"); assertNotNull(t); assertEquals(Point.class, t.getBinding()); t = type.getType("integer"); assertNotNull(t); assertEquals(Integer.class, t.getBinding()); t = type.getGeometryDescriptor().getType(); assertNotNull(t); assertEquals(Point.class, t.getBinding()); }
@Override protected void connect() throws Exception { super.connect(); // we need to use the type builder because the pk has min occurs = 1 on Oracle AttributeTypeBuilder atb = new AttributeTypeBuilder(); atb.setMinOccurs(isPkNillable() ? 0 : 1); atb.setMaxOccurs(1); atb.setNillable(isPkNillable()); atb.setName(FID); atb.setBinding(Integer.class); AttributeDescriptor fidDescriptor = atb.buildDescriptor(FID); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setNamespaceURI(dataStore.getNamespaceURI()); tb.setName(LAKESVIEW); tb.add(fidDescriptor); tb.add(ID, Integer.class); tb.add(GEOM, Polygon.class, (CoordinateReferenceSystem) null); tb.add(NAME, String.class); lakeViewSchema = tb.buildFeatureType(); lakeViewPkSchema = tb.retype(lakeViewSchema, new String[] {ID, GEOM, NAME}); }
public void testCreateSchemaUTMCRS() throws Exception { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(tname("ft2")); builder.setNamespaceURI(dataStore.getNamespaceURI()); builder.setCRS(getUTMCRS()); builder.add(aname("geometry"), Point.class); builder.add(aname("intProperty"), Integer.class); builder.add(aname("stringProperty"), String.class); SimpleFeatureType featureType = builder.buildFeatureType(); dataStore.createSchema(featureType); SimpleFeatureType ft2 = dataStore.getSchema(tname("ft2")); assertNotNull(ft2); try (FeatureWriter w = dataStore.getFeatureWriter(tname("ft2"), Transaction.AUTO_COMMIT)) { w.hasNext(); // write out a feature with a geomety in teh srs, basically accomodate databases that // have // to query the first feature in order to get the srs for the feature type SimpleFeature f = (SimpleFeature) w.next(); Geometry g = new WKTReader().read("POINT(593493 4914730)"); g.setSRID(26713); f.setAttribute(0, g); f.setAttribute(1, Integer.valueOf(0)); f.setAttribute(2, "hello"); w.write(); } // clear out the feature type cache dataStore.getEntry(new NameImpl(dataStore.getNamespaceURI(), tname("ft2"))).dispose(); ft2 = dataStore.getSchema(tname("ft2")); assertTrue(CRS.equalsIgnoreMetadata(getUTMCRS(), ft2.getCoordinateReferenceSystem())); }