@Override public void close() { if (source != null) { source.close(); } }
private AutoCloseableIterator<? extends SimpleFeature> applyPostFilter(Filter postFilter, AutoCloseableIterator<? extends SimpleFeature> features) { Predicate<SimpleFeature> filterPredicate = PostFilter.forFilter(postFilter); features = AutoCloseableIterator.filter(features, filterPredicate); if (screenMap != null) { Predicate<SimpleFeature> screenMapFilter = new FeatureScreenMapPredicate(screenMap); features = AutoCloseableIterator.filter(features, screenMapFilter); } return features; }
@Override protected void encode(OutputStream out) { PrintWriter writer = new PrintWriter(out); if (affectedFeatures != null) { while (affectedFeatures.hasNext()) { DiffEntry diffEntry = affectedFeatures.next(); NodeRef oldObject = diffEntry.getOldObject(); if (oldObject != null) { writer.print(oldObject.getNode().getObjectId().toString()); } } affectedFeatures.close(); } writer.flush(); }
progress.started(); try { AutoCloseableIterator<DiffEntry> unstaged = AutoCloseableIterator.emptyIterator(); if (mergedBuffer.size() > 0) { progress.setDescription( unstaged = workingTree.getUnstaged(null); if (unconflictedBuffer.size() > 0 || unstaged.hasNext()) { progress.setDescription( String.format("Staging %,d unconflicted and %,d merged differences...", unstaged = AutoCloseableIterator.concat(unstaged, AutoCloseableIterator.fromIterator(unconflictedBuffer.iterator()));
@Override public boolean hasNext() { return objects.hasNext(); }
@Test public void testPartition() { AtomicBoolean closed = new AtomicBoolean(false); AutoCloseableIterator<String> orig = new TestAutoCloseableIterator(closed); AutoCloseableIterator<List<String>> partition = AutoCloseableIterator.partition(orig, 2); assertTrue(partition.hasNext()); assertEquals(2, partition.next().size()); assertTrue(partition.hasNext()); assertEquals(1, partition.next().size()); assertFalse(partition.hasNext()); partition.close(); assertTrue(closed.get()); } }
@Test public void testEmptyIterator() { try (AutoCloseableIterator<Object> it = AutoCloseableIterator.emptyIterator()) { assertFalse(it.hasNext()); assertEquals(null, it.next()); } }
@Test public void testFromIterator() { Iterator<String> original = Lists.newArrayList("item1", "item2").iterator(); try (AutoCloseableIterator<String> it = AutoCloseableIterator.fromIterator(original)) { assertTrue(it.hasNext()); assertEquals("item1", it.next()); assertEquals("item2", it.next()); assertFalse(it.hasNext()); } }
private AutoCloseableIterator<DiffEntry> buildEntries(GeogigCLI cli, String oldVersion, String newVersion) { DiffOp diff = cli.getGeogig().command(DiffOp.class); diff.setOldVersion(oldVersion).setNewVersion(newVersion).setCompareIndex(cached); AutoCloseableIterator<DiffEntry> entries; if (paths.isEmpty()) { entries = diff.setProgressListener(cli.getProgressListener()).call(); } else { entries = AutoCloseableIterator.emptyIterator(); for (String path : paths) { AutoCloseableIterator<DiffEntry> moreEntries = diff.setFilter(path) .setProgressListener(cli.getProgressListener()).call(); entries = AutoCloseableIterator.concat(entries, moreEntries); } } return entries; }
@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()); }
@Test public void testFilter() { AtomicBoolean closed = new AtomicBoolean(false); TestAutoCloseableIterator testIter = new TestAutoCloseableIterator(closed); try (AutoCloseableIterator<String> filtered = AutoCloseableIterator.filter(testIter, new Predicate<String>() { @Override public boolean apply(String input) { return input.contains("1"); } })) { assertTrue(filtered.hasNext()); assertTrue(filtered.hasNext()); assertEquals("item1", filtered.next()); assertEquals("item11", filtered.next()); assertFalse(filtered.hasNext()); exception.expect(NoSuchElementException.class); filtered.next(); } assertTrue(closed.get()); }
@Test public void testConcat() { AtomicBoolean closed1 = new AtomicBoolean(false); TestAutoCloseableIterator testIter1 = new TestAutoCloseableIterator(closed1); AtomicBoolean closed2 = new AtomicBoolean(false); TestAutoCloseableIterator testIter2 = new TestAutoCloseableIterator(closed2); try (AutoCloseableIterator<String> concatenated = AutoCloseableIterator.concat(testIter1, testIter2)) { assertTrue(concatenated.hasNext()); assertEquals("item1", concatenated.next()); assertEquals("item2", concatenated.next()); assertEquals("item11", concatenated.next()); assertEquals("item1", concatenated.next()); assertEquals("item2", concatenated.next()); assertEquals("item11", concatenated.next()); assertFalse(concatenated.hasNext()); } assertTrue(closed1.get()); assertTrue(closed2.get()); }
@Override public ObjectInfo<RevFeature> next() { return objects.next(); } };
public AutoCloseableIterator<DiffObjectInfo<RevFeature>> getDiffFeatures( Iterator<DiffEntry> refs) { AutoCloseableIterator<DiffObjectInfo<RevFeature>> objects; final AutoCloseableIterator<DiffEntry> closeableRefs = AutoCloseableIterator .fromIterator(refs); objects = getDiffObjects(refs, RevFeature.class); return new AutoCloseableIterator<DiffObjectInfo<RevFeature>>() { public @Override void close() { objects.close(); closeableRefs.close(); } public @Override boolean hasNext() { return objects.hasNext(); } public @Override DiffObjectInfo<RevFeature> next() { return objects.next(); } }; }
DiffFeatureScreenMapPredicate screenMapPredicate; screenMapPredicate = new DiffFeatureScreenMapPredicate(screenMap, diffType); diffFeatures = AutoCloseableIterator.filter(diffFeatures, screenMapPredicate); diffFeatures = AutoCloseableIterator.fromIterator(diffFeatures, (orig) -> { orig.close(); log.info("Pre filter stats: {}", diffWalkInfo.screenMapFilter.stats()); }); entries.close(); Throwables.throwIfUnchecked(e); throw new IOException(e);
public @Override AutoCloseableIterator<IndexTreeMapping> resolveIndexedTrees(IndexInfo index) { Map<ObjectId, ObjectId> indexMappings = indexTreeMappings.get(index.getId()); if (indexMappings == null || indexMappings.isEmpty()) { return AutoCloseableIterator.emptyIterator(); } indexMappings = new HashMap<>(indexMappings); Iterator<IndexTreeMapping> iterator = indexMappings.entrySet().stream() .map(e -> new IndexTreeMapping(e.getKey(), e.getValue())).iterator(); return AutoCloseableIterator.fromIterator(iterator); } }
public AutoCloseableIterator<DiffEntry> getAffectedFeatures(RepositoryProvider provider, String repoName, ObjectId commitId) { Repository repository = getRepository(provider, repoName); if (repository != null) { final RevCommit revCommit = repository.getCommit(commitId); if (revCommit.getParentIds() != null && revCommit.getParentIds().size() > 0) { ObjectId parentId = revCommit.getParentIds().get(0); return repository.command(DiffOp.class) .setOldVersion(parentId).setNewVersion(commitId).call(); } } return AutoCloseableIterator.emptyIterator(); }