Refine search
/** Counts the number of Features in the specified writer. This method will close the writer. */ protected int count(FeatureWriter<SimpleFeatureType, SimpleFeature> writer) throws NoSuchElementException, IOException { int count = 0; try { while (writer.hasNext()) { writer.next(); count++; } } finally { writer.close(); } return count; } }
public void write() throws IOException { try { SimpleFeatureType target = getFeatureType(); for (int i = 0; i < target.getAttributeCount(); i++) { AttributeDescriptor at = target.getDescriptor(i); Object value = retyped.getAttribute(i); current.setAttribute(at.getLocalName(), value); } delegate.write(); } catch (IllegalAttributeException e) { throw (IOException) new IOException("Error occurred while retyping feature").initCause(e); } } }
public void remove() throws IOException { writer.remove(); }
public void testModifyFeatures() throws Exception { try (FeatureWriter<SimpleFeatureType, SimpleFeature> w = dataStore.getFeatureWriter(tname("guid"), Transaction.AUTO_COMMIT)) { w.hasNext(); SimpleFeature f = w.next(); f.setAttribute(aname("uuidProperty"), uuid2); assertEquals(uuid2, f.getAttribute(aname("uuidProperty"))); w.write(); } }
public void testGetFeatureWriterAppend() throws IOException { try (FeatureWriter<SimpleFeatureType, SimpleFeature> writer = dataStore.getFeatureWriterAppend(tname("ft1"), Transaction.AUTO_COMMIT)) { for (int i = 3; i < 6; i++) { SimpleFeature feature = writer.next(); feature.setAttribute(aname("intProperty"), Integer.valueOf(i)); writer.write(); } } SimpleFeatureCollection features = dataStore.getFeatureSource(tname("ft1")).getFeatures(); assertEquals(6, features.size()); }
public void testGetFeaturesWriterModify() throws IOException { FeatureWriter<SimpleFeatureType, SimpleFeature> writer = data.getFeatureWriter("road", Transaction.AUTO_COMMIT); SimpleFeature feature; while (writer.hasNext()) { feature = writer.next(); if (feature.getID().equals("road.rd1")) { feature.setAttribute("name", "changed"); writer.write(); } } feature = data.entry("road").getMemory().get("road.rd1"); assertEquals("changed", feature.getAttribute("name")); }
private void writeToShapefile( SimpleFeature f, FeatureWriter<SimpleFeatureType, SimpleFeature> writer) throws IOException { SimpleFeature fw = writer.next(); // we cannot trust attribute order, shapefile changes the location and name of the geometry for (AttributeDescriptor d : fw.getFeatureType().getAttributeDescriptors()) { fw.setAttribute(d.getLocalName(), f.getAttribute(d.getLocalName())); } fw.setDefaultGeometry(f.getDefaultGeometry()); writer.write(); }
while (writer.hasNext()) { feature = (SimpleFeature) writer.next(); String fid = feature.getID(); writer.remove(); feature.setAttributes(update.getAttributes()); writer.write(); addedFeature = diff.getAdded().get(fid); nextFeature = (SimpleFeature) writer.next(); writer.write(); } finally { try { writer.close(); state.fireBatchFeatureEvent(true); diff.clear();
dataStore.getFeatureWriterAppend(tname("geopoint"), Transaction.AUTO_COMMIT)) { SimpleFeature f = (SimpleFeature) fw.next(); Point point = gf.createPoint(new Coordinate(-21.96, 64.15)); f.setAttribute("name", "Reykjavik"); f.setDefaultGeometry(point); fw.write(); DWithin filter = ff.dwithin(ff.property(aname("geo")), ff.literal(line), 130000d, "metre"); FeatureCollection features = dataStore.getFeatureSource(tname("geopoint")).getFeatures(filter); assertEquals(1, features.size()); try (FeatureIterator fi = features.features()) { assertTrue(fi.hasNext()); SimpleFeature feature = (SimpleFeature) fi.next(); assertEquals("Reykjavik", feature.getAttribute("name"));
dataStore.getFeatureWriter(tname("road"), td.rd1Filter, t1); FeatureWriter<SimpleFeatureType, SimpleFeature> writer2 = dataStore.getFeatureWriterAppend(tname("road"), t2)) { int i; int index; feature = ORIGINAL[i]; if (!feature.getID().equals(td.roadFeatures[0].getID())) { REMOVE[index++] = feature; dataStore.getFeatureReader( new Query(tname("road"), Filter.INCLUDE), Transaction.AUTO_COMMIT)) { while (writer1.hasNext()) { feature = (SimpleFeature) writer1.next(); assertEquals(td.roadFeatures[0].getID(), feature.getID()); writer1.remove(); writer1.close(); feature = (SimpleFeature) writer2.next(); feature.setAttributes(td.newRoad.getAttributes()); writer2.write();
public void testGetFeatureWriterRemove() throws IOException { FeatureWriter<SimpleFeatureType, SimpleFeature> writer = data.getFeatureWriter("road", Transaction.AUTO_COMMIT); SimpleFeature feature; while (writer.hasNext()) { feature = writer.next(); if (feature.getID().equals("road.rd1")) { writer.remove(); } } assertEquals(roadFeatures.length - 1, data.entry("road").getMemory().size()); }
public void testAppend() throws Exception { if (!isGeographySupportAvailable()) { return; } Point point = gf.createPoint(new Coordinate(10, 10)); try (FeatureWriter fw = dataStore.getFeatureWriterAppend(tname("geopoint"), Transaction.AUTO_COMMIT)) { assertFalse(fw.hasNext()); SimpleFeature f = (SimpleFeature) fw.next(); f.setAttribute("name", "append"); f.setDefaultGeometry(point); fw.write(); } Filter filter = ff.equals(ff.property("name"), ff.literal("append")); Query q = new Query(tname("geopoint"), filter); try (FeatureReader fr = dataStore.getFeatureReader(q, Transaction.AUTO_COMMIT)) { assertTrue(fr.hasNext()); SimpleFeature f = (SimpleFeature) fr.next(); assertEquals(point, f.getDefaultGeometry()); } }
dataStore.createSchema(poly3DType); SimpleFeatureType actualSchema = dataStore.getSchema(tname(getPoly3d())); assertFeatureTypesEqual(poly3DType, actualSchema); assertEquals( dataStore.getFeatureWriterAppend(tname(getPoly3d()), Transaction.AUTO_COMMIT)) { SimpleFeature f = fw.next(); f.setAttribute(aname(ID), 0); f.setAttribute(aname(GEOM), poly); f.setAttribute(aname(NAME), "3dpolygon!"); fw.write();
public void testUpdate() throws Exception { if (!isGeographySupportAvailable()) { return; } Point p = gf.createPoint(new Coordinate(1, 1)); try (FeatureWriter fw = dataStore.getFeatureWriter(tname("geopoint"), Transaction.AUTO_COMMIT)) { assertTrue(fw.hasNext()); while (fw.hasNext()) { SimpleFeature f = (SimpleFeature) fw.next(); f.setDefaultGeometry(p); fw.write(); } } try (FeatureReader fr = dataStore.getFeatureReader(new Query(tname("geopoint")), Transaction.AUTO_COMMIT)) { while (fr.hasNext()) { SimpleFeature f = (SimpleFeature) fr.next(); assertEquals(p, f.getDefaultGeometry()); } } }
dataStore.createSchema(featureType); SimpleFeatureType ft2 = dataStore.getSchema(tname("ft2")); dataStore.getFeatureWriter(tname("ft2"), Transaction.AUTO_COMMIT)) { w.hasNext(); SimpleFeature f = w.next(); f.setAttribute(1, Integer.valueOf(0)); f.setAttribute(2, "hello"); w.write(); w.hasNext(); f = w.next(); f.setAttribute(1, null); try { w.write(); fail("null value for intProperty should have failed"); } catch (Exception e) { f.setAttribute(2, "hello!"); try { w.write(); fail("string greather than 5 chars should have failed"); } catch (Exception e) {
public void testGetFeaturesWriterAdd() throws IOException { try (FeatureWriter<SimpleFeatureType, SimpleFeature> writer = dataStore.getFeatureWriter(tname("road"), Transaction.AUTO_COMMIT)) { SimpleFeature feature; while (writer.hasNext()) { feature = (SimpleFeature) writer.next(); } assertFalse(writer.hasNext()); feature = (SimpleFeature) writer.next(); feature.setAttributes(td.newRoad.getAttributes()); writer.write(); assertFalse(writer.hasNext()); assertEquals(td.roadFeatures.length + 1, count(tname("road"))); } }
/** @see FeatureStore#addFeatures(SimpleFeatureCollection) */ public List<FeatureId> addFeatures( final FeatureCollection<SimpleFeatureType, SimpleFeature> collection) throws IOException { // System.err.println(">>addFeatures called at " + // Thread.currentThread().getName()); final String typeName = typeInfo.getFeatureTypeName(); final FeatureWriter<SimpleFeatureType, SimpleFeature> writer; writer = dataStore.getFeatureWriterAppend(typeName, transaction); final FeatureIterator<SimpleFeature> iterator = collection.features(); List<FeatureId> featureIds = new LinkedList<FeatureId>(); try { SimpleFeature toAdd; SimpleFeature newFeature; while (iterator.hasNext()) { toAdd = iterator.next(); newFeature = writer.next(); newFeature.setAttributes(toAdd.getAttributes()); writer.write(); featureIds.add(newFeature.getIdentifier()); } } finally { iterator.close(); writer.close(); } return featureIds; }
public void testGetFeatureReaderFilterTransaction() throws NoSuchElementException, IOException, IllegalAttributeException { SimpleFeatureType type = dataStore.getSchema(tname("road")); dataStore.getFeatureReader(new Query(tname("road"), Filter.EXCLUDE), t)) { assertFalse(reader.hasNext()); assertEquals(type, reader.getFeatureType()); dataStore.getFeatureReader(new Query(tname("road"), Filter.INCLUDE), t)) { assertEquals(type, reader.getFeatureType()); assertEquals(td.roadFeatures.length, count(reader)); SimpleFeature feature; while (writer.hasNext()) { feature = (SimpleFeature) writer.next(); if (feature.getID().equals(td.roadFeatures[0].getID())) { writer.remove();
public void modifyFeatures(final Name[] attributes, final Object[] values, final Filter filter) throws IOException { final ISession session = getSession(); try { final String typeName = typeInfo.getFeatureTypeName(); final Transaction currTransaction = getTransaction(); final FeatureWriter<SimpleFeatureType, SimpleFeature> writer; writer = dataStore.getFeatureWriter(typeName, filter, currTransaction); try { SimpleFeature feature; while (writer.hasNext()) { feature = writer.next(); for (int i = 0; i < values.length; i++) { feature.setAttribute(attributes[i].getLocalPart(), values[i]); } writer.write(); } } finally { writer.close(); } } finally { session.dispose(); } }