@Override public <T extends RevObject> Iterator<T> getAll(Iterable<ObjectId> ids, BulkOpListener listener, Class<T> type) { return subject.get().getAll(ids, listener, type); }
@Override public <T extends RevObject> Iterator<T> getAll(Iterable<ObjectId> ids, BulkOpListener listener, Class<T> type) { return subject.get().getAll(ids, listener, type); }
@Override public Iterator<RevObject> getAll(Iterable<ObjectId> ids) { return subject.get().getAll(ids); }
@Override public Iterator<RevObject> getAll(Iterable<ObjectId> ids) { return subject.get().getAll(ids); }
@Override public Iterator<RevObject> getAll(Iterable<ObjectId> ids, BulkOpListener listener) { return subject.get().getAll(ids, listener); }
@Override public Iterator<RevObject> getAll(Iterable<ObjectId> ids, BulkOpListener listener) { return subject.get().getAll(ids, listener); }
private PostOrderIteratorInternal(List<ObjectId> start, ObjectStore database, Successors successors) { this.database = database; this.enqueue = true; this.successors = successors; toVisit = new ArrayList<List<Object>>(); Iterator<RevObject> startobjs = database.getAll(start); ArrayList<Object> startList = Lists.newArrayList(startobjs); toVisit.add(startList); }
public void preload(Iterable<ObjectId> trees) { Iterator<RevTree> preloaded = store.getAll(trees, BulkOpListener.NOOP_LISTENER, RevTree.class); while (preloaded.hasNext()) { getTreeId(preloaded.next()); } } }
public void preload(Iterable<ObjectId> trees) { Iterator<RevTree> preloaded = store.getAll(trees, BulkOpListener.NOOP_LISTENER, RevTree.class); while (preloaded.hasNext()) { getTreeId(preloaded.next()); } } }
public @Override void findSuccessors(final Object object, final List<Object> successors, ObjectStore database) { if (object instanceof RevCommit) { final RevCommit commit = (RevCommit) object; Iterator<RevCommit> parents = database.getAll(commit.getParentIds(), NOOP_LISTENER, RevCommit.class); parents.forEachRemaining((o) -> successors.add(o)); } }
private void copy(Set<ObjectId> ids, ObjectStore from, ObjectStore to, final ProgressListener progress) { if (ids.isEmpty()) { return; } BulkOpListener countingListener = new BulkOpListener() { @Override public void inserted(ObjectId object, @Nullable Integer storageSizeBytes) { progress.setProgress(progress.getProgress() + 1); } }; to.putAll(from.getAll(ids), countingListener); }
private void copy(Set<ObjectId> ids, ObjectStore from, ObjectStore to, final ProgressListener progress) { if (ids.isEmpty()) { return; } BulkOpListener countingListener = new BulkOpListener() { @Override public void inserted(ObjectId object, @Nullable Integer storageSizeBytes) { progress.setProgress(progress.getProgress() + 1); } }; to.putAll(from.getAll(ids), countingListener); }
private Map<ObjectId, RevTree> loadBucketTrees(final ObjectStore source, final SortedMap<Integer, Bucket> buckets) { final Map<ObjectId, RevTree> bucketTrees; { Iterable<ObjectId> ids = transform(buckets.values(), (b) -> b.getObjectId()); bucketTrees = uniqueIndex(source.getAll(ids, NOOP_LISTENER, RevTree.class), (t) -> t.getId()); } return bucketTrees; }
private Map<ObjectId, RevTree> loadBucketTrees(final ObjectStore source, final SortedMap<Integer, Bucket> buckets) { final Map<ObjectId, RevTree> bucketTrees; { //Bucket::getObjectId, but friendly for Fortify Function<Bucket, ObjectId> fn_bucket_getObjectId = new Function<Bucket, ObjectId>() { @Override public ObjectId apply(Bucket bucket) { return bucket.getObjectId(); }}; Iterable<ObjectId> ids = transform(buckets.values(), fn_bucket_getObjectId); bucketTrees = Streams.stream(source.getAll(ids, NOOP_LISTENER, RevTree.class)) .collect(Collectors.toMap(t -> t.getId(), t -> t)); } return bucketTrees; }
public Iterator<FeatureInfo> apply(List<NodeRef> refs) { Map<ObjectId, RevFeature> correlationIndex = new HashMap<>(refs.size()); ArrayList<ObjectId> ids = new ArrayList<>(refs.size()); refs.forEach(ref->ids.add(ref.getObjectId())); Iterator<RevFeature> all = odb.getAll(ids, NOOP_LISTENER, RevFeature.class); all.forEachRemaining(revFeature -> correlationIndex.put(revFeature.getId(),revFeature)); ArrayList<FeatureInfo> result = new ArrayList<>(refs.size()); refs.forEach( ref-> result.add(FeatureInfo.insert(correlationIndex.get(ref.getObjectId()), ref.getMetadataId(), ref.path() ))); return (result.iterator() ); } }
public @Override void findSuccessors(final Object object, final List<Object> successors, ObjectStore database) { if (object instanceof RevTree) { final RevTree tree = (RevTree) object; if (!tree.buckets().isEmpty()) { Iterable<ObjectId> bucketIds = Iterables.transform(tree.buckets().values(), (b) -> b.getObjectId()); Iterator<RevTree> buckets = database.getAll(bucketIds, NOOP_LISTENER, RevTree.class); buckets.forEachRemaining((b) -> successors.add(b)); } } }
public void found(ObjectId object, @Nullable Integer storageSizeBytes) { Iterator<RevObject> subQueryObjects = db.getAll(Lists.newArrayList(object)); assertTrue(subQueryObjects.hasNext()); assertEquals(originalObject, subQueryObjects.next()); } });
public static Set<RevTree> getAllTrees(ObjectStore source, RevTree tree) { Set<RevTree> trees = new HashSet<>(); trees.add(tree); if (tree.bucketsSize() > 0) { Iterable<ObjectId> ids = Iterables.transform(tree.getBuckets(), Bucket::getObjectId); List<RevTree> buckets = Lists .newArrayList(source.getAll(ids, BulkOpListener.NOOP_LISTENER, RevTree.class)); trees.addAll(buckets); for (RevTree bucket : buckets) { trees.addAll(getAllTrees(source, bucket)); } } return trees; }
private void testGetAll(final Iterable<ObjectId> ids, final int expectedSize) { CountingListener getAllListener = BulkOpListener.newCountingListener(); Stopwatch sw = Stopwatch.createStarted(); final int returnedObjectCount = Iterators .size(db.getAll(ids, getAllListener, RevFeature.class)); sw.stop(); System.err.printf( "----- %,d random objects queried (%,d not found) with getAll() in %,dms\n", getAllListener.found(), getAllListener.notFound(), sw.elapsed(TimeUnit.MILLISECONDS)); System.err.printf("----- %s\n", sharedCache); Assert.assertEquals(getAllListener.toString(), expectedSize, getAllListener.found()); assertEquals(expectedSize, returnedObjectCount); }
@Test public void testGetAll() { ImmutableList<RevObject> expected = ImmutableList.of(feature(0, null, "some value"), feature(1, "value", new Integer(111)), feature(2, (Object) null), RevTree.EMPTY); for (RevObject o : expected) { assertTrue(db.put(o)); } assertTrue(db.put(feature(5, "not queried 1"))); assertTrue(db.put(feature(6, "not queried 2"))); Function<RevObject, ObjectId> toId = p -> p.getId(); Iterable<ObjectId> ids = Iterables.transform(expected, toId); Iterator<RevObject> iterator = db.getAll(ids); List<RevObject> actual = ImmutableList.copyOf(iterator); assertEquals(Sets.newHashSet(ids), Sets.newHashSet(Iterables.transform(actual, toId))); }