public static AutoCloseableIterator<NodeRef> toFeatureRefs( final AutoCloseableIterator<DiffEntry> diffs, final ChangeType changeType) { Function<DiffEntry, NodeRef> fn = new Function<DiffEntry, NodeRef>() { @Override public NodeRef apply(DiffEntry e) { if (e.isAdd()) { return e.getNewObject(); } if (e.isDelete()) { return e.getOldObject(); } return ChangeType.CHANGED_OLD.equals(changeType) ? e.getOldObject() : e.getNewObject(); }}; return AutoCloseableIterator.transform(diffs,fn); }
/** * @param names * @param values * @param filter * @return * @throws IOException */ private AutoCloseableIterator<SimpleFeature> modifyingFeatureIterator(final Name[] names, final Object[] values, final Filter filter) throws IOException { AutoCloseableIterator<SimpleFeature> iterator = featureIterator(filter); Function<SimpleFeature, SimpleFeature> modifyingFunction = new ModifyingFunction(names, values); AutoCloseableIterator<SimpleFeature> modifyingIterator = AutoCloseableIterator .transform(iterator, modifyingFunction); return modifyingIterator; }
/** * Given a bunch of NodeRefs, create SimpleFeatures from the results. The result might be mixed * FeatureTypes * * This retrieves FeatureType info from the ObjectDatabase as needed. * * @see BulkFeatureRetriever#getGeoGIGFeatures * * @param refs * @return */ public AutoCloseableIterator<SimpleFeature> getGeoToolsFeatures(Iterator<NodeRef> refs) { AutoCloseableIterator<ObjectInfo<RevFeature>> fis = getGeoGIGFeatures(refs); MultiFeatureTypeBuilder builder = new MultiFeatureTypeBuilder(odb); return AutoCloseableIterator.transform(fis, builder); }
/** * Given a bunch of NodeRefs, create SimpleFeatures from the results. The result might be mixed * FeatureTypes * * This retrieves FeatureType info from the ObjectDatabase as needed. * * @see BulkFeatureRetriever#getGeoGIGFeatures * * @param refs * @return */ public AutoCloseableIterator<SimpleFeature> getGeoToolsFeatures(Iterator<NodeRef> refs) { AutoCloseableIterator<ObjectInfo<RevFeature>> fis = getGeoGIGFeatures(refs); MultiFeatureTypeBuilder builder = new MultiFeatureTypeBuilder(odb); AutoCloseableIterator<SimpleFeature> result = AutoCloseableIterator.transform(fis, builder); return result; }
/** * Given a bunch of NodeRefs, create SimpleFeatures from the results. This builds a particular * FeatureType from the ObjectDatabase. * * This DOES NOT retrieves FeatureType info from the ObjectDatabase. * * @param refs list of node refs to fetch {@link RevFeature}s for * @param nativeType the feature type the features adhere to * @param typeNameOverride in case the resulting feature type needs to be renamed (e.g. to * change the namespace URI, and/or the local name) * @param geometryFactory the geometry factory to create geometry attributes with * @return */ public AutoCloseableIterator<SimpleFeature> getGeoToolsFeatures( AutoCloseableIterator<NodeRef> refs, RevFeatureType nativeType, @Nullable Name typeNameOverride, GeometryFactory geometryFactory) { // builder for this particular schema FeatureBuilder featureBuilder = new FeatureBuilder(nativeType, typeNameOverride); // function that converts the FeatureInfo a feature of the given schema Function<ObjectInfo<RevFeature>, SimpleFeature> funcBuildFeature = (input -> MultiFeatureTypeBuilder .build(featureBuilder, input, geometryFactory)); AutoCloseableIterator<ObjectInfo<RevFeature>> fis = getGeoGIGFeatures(refs); return AutoCloseableIterator.transform(fis, funcBuildFeature); }
AutoCloseableIterator<SimpleFeature> result = AutoCloseableIterator.transform(fis, funcBuildFeature);
public AutoCloseableIterator<SimpleFeature> getGeoToolsDiffFeatures(//@formatter:off AutoCloseableIterator<DiffEntry> refs, RevFeatureType nativeType, SimpleFeatureType diffType, @Nullable GeometryFactory geometryFactory) {//@formatter:on boolean flattenedType = !isDiffFeatureType(diffType); Function<DiffObjectInfo<RevFeature>, SimpleFeature> builder; if (flattenedType) { builder = new DiffFeatureFlattenedBuilder(diffType, nativeType); } else { // builder for the "old" and "new" versions of each feature FeatureBuilder featureBuilder = new FeatureBuilder(nativeType, null); builder = new DiffFeatureBuilder(diffType, featureBuilder, geometryFactory); } AutoCloseableIterator<DiffObjectInfo<RevFeature>> fis = getDiffFeatures(refs); return AutoCloseableIterator.transform(fis, builder); }
}; AutoCloseableIterator<SimpleFeature> asFeatures = AutoCloseableIterator.transform(diffs, asFeature);
}; AutoCloseableIterator<SimpleFeature> asFeatures = AutoCloseableIterator.transform(diffs, asFeature);
@Test public void testConcat2() { AtomicBoolean closed = new AtomicBoolean(false); TestAutoCloseableIterator testIter1 = new TestAutoCloseableIterator(closed); AutoCloseableIterator<List<String>> partition = AutoCloseableIterator.partition(testIter1, 1); AutoCloseableIterator<Iterator<String>> main = AutoCloseableIterator.transform(partition, item -> item.iterator()); AutoCloseableIterator<String> result = AutoCloseableIterator.concat(main); assertEquals("item1", result.next()); assertEquals("item2", result.next()); assertEquals("item11", result.next()); assertTrue(!closed.get()); result.close(); assertTrue(closed.get()); }
@Test public void testTransform() { AtomicBoolean closed = new AtomicBoolean(false); TestAutoCloseableIterator testIter = new TestAutoCloseableIterator(closed); try (AutoCloseableIterator<String> transformed = AutoCloseableIterator.transform(testIter, (str) -> str.toUpperCase());) { assertTrue(transformed.hasNext()); assertEquals("ITEM1", transformed.next()); assertTrue(transformed.hasNext()); assertEquals("ITEM2", transformed.next()); assertTrue(transformed.hasNext()); assertEquals("ITEM11", transformed.next()); assertFalse(transformed.hasNext()); } assertTrue(closed.get()); }