@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, BulkOpListener listener) { return subject.get().getAll(ids, listener); }
@Override public Iterator<RevObject> getAll(Iterable<ObjectId> ids, BulkOpListener listener) { return subject.get().getAll(ids, listener); }
@Override public Iterator<RevObject> getAll(Iterable<ObjectId> ids) { return subject.get().getAll(ids); }
private Set<RevTag> resolveWantTags(List<RefRequest> tagRequests) { //(r) -> r.want Function<RefRequest, ObjectId> fn = new Function<RefRequest, ObjectId>() { @Override public ObjectId apply(RefRequest r) { return r.want; }}; Iterable<ObjectId> ids = transform(tagRequests, fn); Iterator<RevTag> tags = objectDatabase().getAll(ids, NOOP_LISTENER, RevTag.class); return Sets.newHashSet(tags); }
private Set<RevTag> resolveWantTags(List<RefRequest> tagRequests) { Iterable<ObjectId> ids = transform(tagRequests, (r) -> r.want); Iterator<RevTag> tags = objectDatabase().getAll(ids, NOOP_LISTENER, RevTag.class); return Sets.newHashSet(tags); }
private Set<ObjectId> resolveHeadCommits(List<RefRequest> refs, boolean isTags, Predicate<? super RefRequest> filter, Function<? super RefRequest, ? extends ObjectId> function) { Iterable<ObjectId> ids = transform(filter(refs, filter), function); if (isTags) { Iterator<RevTag> tags = objectDatabase().getAll(ids, NOOP_LISTENER, RevTag.class); ids = newArrayList(Iterators.transform(tags, (t) -> t.getCommitId())); } return Sets.newHashSet(ids); }
private Set<ObjectId> resolveHeadCommits(List<RefRequest> refs, boolean isTags, Predicate<? super RefRequest> filter, Function<? super RefRequest, ? extends ObjectId> function) { Iterable<ObjectId> ids = transform(filter(refs, filter), function); if (isTags) { Iterator<RevTag> tags = objectDatabase().getAll(ids, NOOP_LISTENER, RevTag.class); //(t) -> t.getCommitId() Function<RevTag, ObjectId> fn = new Function<RevTag, ObjectId>() { @Override public ObjectId apply(RevTag t) { return t.getCommitId(); }}; ids = newArrayList(Iterators.transform(tags, fn)); } return Sets.newHashSet(ids); }
private Map<ObjectId, RevObject> getObjects(NodeRef ancestorRef, NodeRef nodeRefA, NodeRef nodeRefB) { final ObjectId metadataId = ancestorRef.getMetadataId(); final ObjectId ancestorFeatureId = ancestorRef.getObjectId(); final ObjectId featureAId = nodeRefA.getObjectId(); final ObjectId featureBId = nodeRefB.getObjectId(); Iterable<ObjectId> ids = ImmutableList.of(metadataId, ancestorFeatureId, featureAId, featureBId); Iterator<RevObject> objsit = objectDatabase().getAll(ids, BulkOpListener.NOOP_LISTENER); ImmutableMap<ObjectId, RevObject> map = Maps.uniqueIndex(objsit, (o) -> o.getId()); checkState(map.containsKey(metadataId), "Invalid reference: %s", metadataId); checkState(map.containsKey(ancestorFeatureId), "Invalid reference: %s", ancestorFeatureId); checkState(map.containsKey(featureAId), "Invalid reference: %s", featureAId); checkState(map.containsKey(featureBId), "Invalid reference: %s", featureBId); return map; }
private Map<ObjectId, RevObject> getObjects(NodeRef ancestorRef, NodeRef nodeRefA, NodeRef nodeRefB) { final ObjectId metadataId = ancestorRef.getMetadataId(); final ObjectId ancestorFeatureId = ancestorRef.getObjectId(); final ObjectId featureAId = nodeRefA.getObjectId(); final ObjectId featureBId = nodeRefB.getObjectId(); Iterable<ObjectId> ids = ImmutableList.of(metadataId, ancestorFeatureId, featureAId, featureBId); Iterator<RevObject> objsit = objectDatabase().getAll(ids, BulkOpListener.NOOP_LISTENER); //RevObject::getId, but friendly for Fortify Function<RevObject, ObjectId> fn_getId = new Function<RevObject, ObjectId>() { @Override public ObjectId apply(RevObject revobj) { return revobj.getId(); }}; ImmutableMap<ObjectId, RevObject> map = Maps.uniqueIndex(objsit, fn_getId); checkState(map.containsKey(metadataId), "Invalid reference: %s", metadataId); checkState(map.containsKey(ancestorFeatureId), "Invalid reference: %s", ancestorFeatureId); checkState(map.containsKey(featureAId), "Invalid reference: %s", featureAId); checkState(map.containsKey(featureBId), "Invalid reference: %s", featureBId); return map; }
@Override protected ImmutableList<RevTag> _call() { List<Ref> refs = newArrayList( command(ForEachRef.class).setPrefixFilter(Ref.TAGS_PREFIX).call()); List<ObjectId> tagIds = transform(refs, (r) -> r.getObjectId()); Iterator<RevTag> alltags; alltags = objectDatabase().getAll(tagIds, BulkOpListener.NOOP_LISTENER, RevTag.class); ImmutableList<RevTag> res = ImmutableList.copyOf(alltags); return res; }
@Override protected ImmutableList<RevTag> _call() { List<Ref> refs = newArrayList( command(ForEachRef.class).setPrefixFilter(Ref.TAGS_PREFIX).call()); // (r) -> r.getObjectId() Function<Ref, ObjectId> fn = new Function<Ref, ObjectId>() { @Override public ObjectId apply(Ref ref) { return ref.getObjectId(); }}; List<ObjectId> tagIds = transform(refs, fn); Iterator<RevTag> alltags; alltags = objectDatabase().getAll(tagIds, BulkOpListener.NOOP_LISTENER, RevTag.class); ImmutableList<RevTag> res = ImmutableList.copyOf(alltags); return res; }
private Map<ObjectId, RevObject> getObjects() { final ObjectId ancestorMetadataId = commonAncestor.getMetadataId(); final ObjectId mergetIntoMetadataId = mergeInto.getMetadataId(); final ObjectId toMergeMetadataId = toMerge.getMetadataId(); final ObjectId ancestorFeatureId = commonAncestor.getObjectId(); final ObjectId featureAId = mergeInto.getObjectId(); final ObjectId featureBId = toMerge.getObjectId(); Set<ObjectId> ids = Sets.newHashSet(ancestorMetadataId, mergetIntoMetadataId, toMergeMetadataId, ancestorFeatureId, featureAId, featureBId); Iterator<RevObject> objsit = objectDatabase().getAll(ids, BulkOpListener.NOOP_LISTENER); //RevObject::getId, but friendly for Fortify Function<RevObject, ObjectId> fn_getId = new Function<RevObject, ObjectId>() { @Override public ObjectId apply(RevObject revobj) { return revobj.getId(); }}; ImmutableMap<ObjectId, RevObject> map = Maps.uniqueIndex(objsit, fn_getId); if (ids.size() != map.size()) { ids.forEach((id) -> checkState(map.containsKey(id), "Invalid reference: %s", id)); } return map; }
private Map<ObjectId, RevObject> getObjects() { final ObjectId ancestorMetadataId = commonAncestor.getMetadataId(); final ObjectId mergetIntoMetadataId = mergeInto.getMetadataId(); final ObjectId toMergeMetadataId = toMerge.getMetadataId(); final ObjectId ancestorFeatureId = commonAncestor.getObjectId(); final ObjectId featureAId = mergeInto.getObjectId(); final ObjectId featureBId = toMerge.getObjectId(); Set<ObjectId> ids = Sets.newHashSet(ancestorMetadataId, mergetIntoMetadataId, toMergeMetadataId, ancestorFeatureId, featureAId, featureBId); Iterator<RevObject> objsit = objectDatabase().getAll(ids, BulkOpListener.NOOP_LISTENER); ImmutableMap<ObjectId, RevObject> map = Maps.uniqueIndex(objsit, (o) -> o.getId()); if (ids.size() != map.size()) { ids.forEach((id) -> checkState(map.containsKey(id), "Invalid reference: %s", id)); } return map; }
/** * Finds differences between the two specified trees. * * @return a FeatureDiff object with the differences between the specified features * @see FeatureDiff */ @Override protected FeatureDiff _call() throws IllegalArgumentException { checkNotNull(oldNodeRef, "old version not specified"); checkNotNull(newNodeRef, "new version not specified"); String oldPath = removeRef(oldNodeRef.path()); String newPath = removeRef(newNodeRef.path()); checkArgument(oldPath.equals(newPath), "old and new versions do not corespond to the same feature"); Set<ObjectId> ids = Sets.newHashSet(oldNodeRef.getObjectId(), newNodeRef.getObjectId(), oldNodeRef.getMetadataId(), newNodeRef.getMetadataId()); Map<ObjectId, RevObject> objects = Maps.uniqueIndex(objectDatabase().getAll(ids), (o) -> o.getId()); RevFeature oldFeature = (RevFeature) objects.get(oldNodeRef.getObjectId()); checkArgument(oldFeature != null, "Invalid reference: %s", oldNodeRef); RevFeature newFeature = (RevFeature) objects.get(newNodeRef.getObjectId()); checkArgument(newFeature != null, "Invalid reference: %s", newNodeRef); RevFeatureType oldFeatureType = (RevFeatureType) objects.get(oldNodeRef.getMetadataId()); checkArgument(oldFeatureType != null, "Invalid reference: %s", oldNodeRef); RevFeatureType newFeatureType = (RevFeatureType) objects.get(newNodeRef.getMetadataId()); checkArgument(newFeatureType != null, "Invalid reference: %s", newNodeRef); return compare(oldFeature, newFeature, oldFeatureType, newFeatureType); }
/** * Finds differences between the two specified trees. * * @return a FeatureDiff object with the differences between the specified features * @see FeatureDiff */ @Override protected FeatureDiff _call() throws IllegalArgumentException { checkNotNull(oldNodeRef, "old version not specified"); checkNotNull(newNodeRef, "new version not specified"); String oldPath = removeRef(oldNodeRef.path()); String newPath = removeRef(newNodeRef.path()); checkArgument(oldPath.equals(newPath), "old and new versions do not corespond to the same feature"); Set<ObjectId> ids = Sets.newHashSet(oldNodeRef.getObjectId(), newNodeRef.getObjectId(), oldNodeRef.getMetadataId(), newNodeRef.getMetadataId()); Map<ObjectId, RevObject> objects = Streams.stream(objectDatabase().getAll(ids)) .collect(Collectors.toMap(RevObject::getId, revobj -> revobj)); RevFeature oldFeature = (RevFeature) objects.get(oldNodeRef.getObjectId()); checkArgument(oldFeature != null, "Invalid reference: %s", oldNodeRef); RevFeature newFeature = (RevFeature) objects.get(newNodeRef.getObjectId()); checkArgument(newFeature != null, "Invalid reference: %s", newNodeRef); RevFeatureType oldFeatureType = (RevFeatureType) objects.get(oldNodeRef.getMetadataId()); checkArgument(oldFeatureType != null, "Invalid reference: %s", oldNodeRef); RevFeatureType newFeatureType = (RevFeatureType) objects.get(newNodeRef.getMetadataId()); checkArgument(newFeatureType != null, "Invalid reference: %s", newNodeRef); return compare(oldNodeRef.path(), oldFeature, newFeature, oldFeatureType, newFeatureType); }
public Map<String, RevFeatureType> getFeatureTypes(@NonNull String rootTreeIsh) { Context context = getContext(); List<NodeRef> treeNodes = context.command(FindFeatureTypeTrees.class) .setRootTreeRef(rootTreeIsh).call(); Iterator<RevFeatureType> types = context.objectDatabase().getAll( Iterables.transform(treeNodes, n -> n.getMetadataId()), BulkOpListener.NOOP_LISTENER, RevFeatureType.class); return Maps.uniqueIndex(types, t -> t.getName().getLocalPart()); }
@Test public void testIdenticalFeatureData() { ObjectDatabase odb = mock(ObjectDatabase.class); RevFeature f1 = mock(RevFeature.class); when(f1.getId()).thenReturn(getOID(1)); when(odb.getAll(anyObject(), anyObject(), anyObject())) .thenReturn((Arrays.asList((RevObject) f1 )).iterator()); BulkObjectDatabaseFeatureRetriever bulk = new BulkObjectDatabaseFeatureRetriever(odb); ObjectId metadataid = getOID(4); Node n1 = Node.create("name1", getOID(1), metadataid, TYPE.FEATURE, new Envelope()); NodeRef nr1 = new NodeRef(n1, "testcase", metadataid); Node n2 = Node.create("name2", getOID(1), metadataid, TYPE.FEATURE, new Envelope()); NodeRef nr2 = new NodeRef(n2, "testcase", metadataid); Iterator<FeatureInfo> it = bulk.apply(Arrays.asList(nr1, nr2)); List<FeatureInfo> feats = Lists.newArrayList(it); Assert.isTrue(feats.size() == 2); Assert.isTrue(feats.get(0).getFeatureTypeId() == metadataid); Assert.isTrue(feats.get(0).getName() .equals("name1")); Assert.equals(feats.get(0).getFeature().getId(), getOID(1)); Assert.isTrue(feats.get(1).getFeatureTypeId() == metadataid); Assert.isTrue(feats.get(1).getName() .equals( "name2")); Assert.equals(feats.get(1).getFeature().getId(), getOID(1)); }