@Test public void testFeatureReaderFidFilter() throws Exception { FeatureReader<SimpleFeatureType, SimpleFeature> fr; fr = rts.getFeatureReader(new Query(RENAMED, fidFilter), Transaction.AUTO_COMMIT); assertEquals(primitive, fr.getFeatureType()); assertTrue(fr.hasNext()); SimpleFeature sf = fr.next(); assertFalse(fr.hasNext()); fr.close(); assertEquals(fid, sf.getID()); }
@Test public void testGetFeaturesReader() throws Exception { FeatureReader<SimpleFeatureType, SimpleFeature> fr; fr = rts.getFeatureReader(new Query(RENAMED), Transaction.AUTO_COMMIT); SimpleFeature sf = fr.next(); fr.close(); assertEquals(primitive, sf.getFeatureType()); // check the feature ids have been renamed as well assertTrue( "Feature id has not been renamed, it's still " + sf.getID(), sf.getID().startsWith(RENAMED)); }
/** @see FeatureWriter#hasNext() */ public final boolean hasNext() throws IOException { // filteredContent may be null because we // took the precaution of closing it in a previous call // to this method final boolean hasNext = filteredContent != null && filteredContent.hasNext(); // be cautious of badly coded clients if (!hasNext && filteredContent != null) { filteredContent.close(); filteredContent = null; } return hasNext; }
public void testGetFeatures() throws Exception { try (FeatureReader r = dataStore.getFeatureReader(new Query(tname("b")), Transaction.AUTO_COMMIT)) { r.hasNext(); SimpleFeature f = (SimpleFeature) r.next(); assertEquals(Boolean.FALSE, f.getAttribute("boolProperty")); r.hasNext(); f = (SimpleFeature) r.next(); assertEquals(Boolean.TRUE, f.getAttribute("boolProperty")); } } }
public void testDifferentCRS() throws Exception { CoordinateReferenceSystem srcCRS = DefaultGeographicCRS.WGS84; GeometryFactory fac = new GeometryFactory(); Point p = fac.createPoint(new Coordinate(10, 10)); SimpleFeatureCollection features = createTestFeatureCollection(srcCRS, p); FeatureReader<SimpleFeatureType, SimpleFeature> original = DataUtilities.reader(features); CoordinateReferenceSystem destCRS = DefaultEngineeringCRS.CARTESIAN_2D; try (ForceCoordinateSystemFeatureReader modified = new ForceCoordinateSystemFeatureReader(DataUtilities.reader(features), destCRS); ) { SimpleFeature f1 = original.next(); SimpleFeature f2 = modified.next(); assertEquals( ((Geometry) f1.getDefaultGeometry()).getCoordinate(), ((Geometry) f2.getDefaultGeometry()).getCoordinate()); SimpleFeatureType f1Type = f1.getFeatureType(); SimpleFeatureType f2Type = f2.getFeatureType(); assertFalse( f1Type.getCoordinateReferenceSystem() .equals(f2Type.getCoordinateReferenceSystem())); assertEquals(srcCRS, f1Type.getCoordinateReferenceSystem()); assertEquals(srcCRS, f1Type.getGeometryDescriptor().getCoordinateReferenceSystem()); assertEquals(destCRS, f2Type.getCoordinateReferenceSystem()); assertEquals(destCRS, f2Type.getGeometryDescriptor().getCoordinateReferenceSystem()); assertFalse(original.hasNext()); assertFalse(modified.hasNext()); assertNotNull(modified.builder); } }
@Override public SimpleFeature next() throws IOException { SimpleFeature f = wrapped.next(); for (AttributeDescriptor ad : target.getAttributeDescriptors()) { Expression ex = transformer.getExpression(ad.getLocalName()); if (ex != null) { Object value = ex.evaluate(f, ad.getType().getBinding()); fb.add(value); } else { fb.add(null); } } return fb.buildFeature(transformer.transformFid(f)); }
if (query.getStartIndex() != null && (query.getSortBy() == null || query.getSortBy().length == 0)) { Query dq = new Query(query); dq.setSortBy(new SortBy[] {SortBy.NATURAL_ORDER}); reader.getFeatureType(), query.getPropertyNames()); if (!target.equals(reader.getFeatureType())) { reader = new ReTypeFeatureReader(reader, target, false); if (!canOffset() && offset > 0) { for (int i = 0; i < offset && reader.hasNext(); i++) { reader.next(); CoordinateReferenceSystem targetCRS = query.getCoordinateSystemReproject(); CoordinateReferenceSystem nativeCRS = reader.getFeatureType().getCoordinateReferenceSystem();
protected SimpleFeature feature(String typeName, String fid) throws NoSuchElementException, IOException, IllegalAttributeException { FeatureReader<SimpleFeatureType, SimpleFeature> reader = reader(typeName); SimpleFeature f; try { while (reader.hasNext()) { f = (SimpleFeature) reader.next(); if (fid.equals(f.getID())) { return f; } } } finally { reader.close(); } return null; }
public void handleFeatureReader(FeatureReader<SimpleFeatureType, SimpleFeature> reader) throws IOException { try { while (reader.hasNext() && running) { SimpleFeature f = reader.next(); handleFeature(f); SimpleFeatureType t = f.getFeatureType(); for (int i = 0, ii = f.getAttributeCount(); i < ii; i++) { AttributeDescriptor descriptor = t.getDescriptor(i); Object value = f.getAttribute(i); handleAttribute(descriptor, value); } endFeature(f); } } catch (Exception ioe) { throw new RuntimeException("Error reading Features", ioe); } finally { if (reader != null) { LOGGER.finer("closing reader " + reader); reader.close(); } } }
public void testNext() throws Exception { Query query = new Query(tname("ft1")); try (FeatureReader reader = dataStore.getFeatureReader(query, Transaction.AUTO_COMMIT)) { assertTrue(reader.hasNext()); SimpleFeature feature = (SimpleFeature) reader.next(); assertEquals(feature.getName(), reader.getFeatureType().getName()); for (PropertyDescriptor desc : reader.getFeatureType().getDescriptors()) { assertTrue(i < feature.getAttributeCount()); assertEquals(feature.getAttribute(desc.getName()), feature.getAttribute(i++));
/** @see org.geotools.data.FeatureReader#next() */ public SimpleFeature next() throws IOException, IllegalAttributeException, NoSuchElementException { if (reader == null) { throw new IOException("FeatureReader has been closed"); } SimpleFeature next = reader.next(); String id = next.getID(); String xpath; for (int i = 0; i < types.length; i++) { xpath = types[i].getLocalName(); if (clone) builder.add(DataUtilities.duplicate(next.getAttribute(xpath))); else builder.add(next.getAttribute(xpath)); } return builder.buildFeature(id); }
getWriter(Filter.INCLUDE, WRITER_ADD); try { while (reader.hasNext()) { SimpleFeature feature = reader.next(); for (int i = 0; i < toWrite.getType().getAttributeCount(); i++) { String name = toWrite.getType().getDescriptor(i).getLocalName(); toWrite.setAttribute(name, feature.getAttribute(name));
Query q = new Query(query); List<String> geometries = new ArrayList<String>(); for (AttributeDescriptor ad : getSchema().getAttributeDescriptors()) { if (ad instanceof GeometryDescriptor) { geometries.add(ad.getLocalName()); return new ReferencedEnvelope(); } else { q.setPropertyNames(geometries); while (reader.hasNext()) { SimpleFeature f = reader.next(); ReferencedEnvelope featureBounds = ReferencedEnvelope.reference(f.getBounds()); if (result == null) { result = featureBounds; return result; } else { return ReferencedEnvelope.create(getSchema().getCoordinateReferenceSystem()); if (reader != null) { try { reader.close(); } catch (IOException ex) {
public void testRendererBehaviour() throws Exception { ContentFeatureSource fs = dataStore.getFeatureSource(tname(getLine3d())); assertTrue(fs.getSupportedHints().contains(Hints.JTS_COORDINATE_SEQUENCE_FACTORY)); Query q = new Query(tname(getLine3d())); Hints hints = new Hints( Hints.JTS_COORDINATE_SEQUENCE_FACTORY, new LiteCoordinateSequenceFactory()); q.setHints(hints); dataStore.getFeatureReader(q, Transaction.AUTO_COMMIT)) { assertEquals(crs, fr.getFeatureType().getCoordinateReferenceSystem()); assertEquals( crs, fr.getFeatureType().getGeometryDescriptor().getCoordinateReferenceSystem()); assertTrue(fr.hasNext()); SimpleFeature f = fr.next(); assertTrue(expected.equalsExact((Geometry) f.getDefaultGeometry()));
@Override protected ReferencedEnvelope getBoundsInternal(Query query) throws IOException { if (query.getFilter() == Filter.INCLUDE) { // filtering not implemented FeatureReader<SimpleFeatureType, SimpleFeature> featureReader = getReaderInternal(query); CoordinateReferenceSystem crs = featureReader.getFeatureType().getCoordinateReferenceSystem(); ReferencedEnvelope bounds = ReferencedEnvelope.create(crs); try { while (featureReader.hasNext()) { SimpleFeature feature = featureReader.next(); bounds.include(feature.getBounds()); } } finally { featureReader.close(); } return bounds; } return null; // feature by feature scan required to count records }
public void testGetFeatureReaderFilterWithAttributesNotRequested() throws Exception { // this is here to avoid http://jira.codehaus.org/browse/GEOT-1069 // to come up again SimpleFeatureType type = dataStore.getSchema(tname("river")); FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); PropertyIsEqualTo f = ff.equals(ff.property(aname("flow")), ff.literal(4.5)); Query q = new Query(tname("river")); q.setPropertyNames(new String[] {aname("geom")}); q.setFilter(f); // with GEOT-1069 an exception is thrown here try (Transaction t = new DefaultTransaction(); FeatureReader<SimpleFeatureType, SimpleFeature> reader = dataStore.getFeatureReader(q, t)) { assertTrue(reader.hasNext()); assertEquals(1, reader.getFeatureType().getAttributeCount()); reader.next(); assertFalse(reader.hasNext()); } }
public void testReaderIsNotBrokenWhileWritingFeatureDirectly() throws IOException { // a write should not "destroy" readers int expectedFeatureCount = roadFeatures.length; int currentFeatureCount = 0; FeatureReader<SimpleFeatureType, SimpleFeature> featureReader = memoryDataStore.getFeatureReader( new Query(roadType.getTypeName(), Filter.INCLUDE), transaction); // start iterating through content if (featureReader.hasNext()) { featureReader.next(); currentFeatureCount++; } SimpleFeature newFeature = SimpleFeatureBuilder.template(roadType, null); memoryDataStore.addFeature(newFeature); assertReaderHasFeatureCount(expectedFeatureCount, currentFeatureCount, featureReader); }
Filter[] split = splitFilter(query.getFilter()); Filter preFilter = split[0]; Filter postFilter = split[1]; || (query.getMaxFeatures() < Integer.MAX_VALUE && !canLimit()) || (query.getStartIndex() != null && query.getStartIndex() > 0 && !canOffset())) { getDataStore().getLogger().fine("Calculating bounds manually"); CRS.getHorizontalCRS(getSchema().getCoordinateReferenceSystem()); ReferencedEnvelope bounds = new ReferencedEnvelope(flatCRS); FeatureReader<SimpleFeatureType, SimpleFeature> i = getReader(q); try { if (i.hasNext()) { SimpleFeature f = i.next(); bounds.init(f.getBounds()); while (i.hasNext()) { f = i.next(); bounds.include(f.getBounds()); i.close();
dataStore.createSchema(poly3DType); SimpleFeatureType actualSchema = dataStore.getSchema(tname(getPoly3d())); assertFeatureTypesEqual(poly3DType, actualSchema); assertEquals( getNativeSRID(), actualSchema .getGeometryDescriptor() .getUserData() .get(JDBCDataStore.JDBC_NATIVE_SRID)); 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(); Query query = new Query(tname(getPoly3d())); query.setHints(hints); dataStore.getFeatureReader(query, Transaction.AUTO_COMMIT)) { assertTrue(fr.hasNext()); SimpleFeature f = fr.next();
private void assertReaderOrderSame(SimpleFeature[] features, DataStore store) throws IOException { FeatureReader<SimpleFeatureType, SimpleFeature> r1 = store.getFeatureReader( new Query(features[0].getFeatureType().getTypeName()), Transaction.AUTO_COMMIT); FeatureReader<SimpleFeatureType, SimpleFeature> r2 = DataUtilities.reader(features); while (r1.hasNext() && r2.hasNext()) { SimpleFeature f1 = r1.next(); SimpleFeature f2 = r2.next(); assertEquals(f1, f2); } assertEquals(r1.hasNext(), r2.hasNext()); r1.close(); r2.close(); }