public static void writeDiff(DiffEntry diff, DataOutput data) throws IOException { if (diff.getOldObject() == null) { data.writeBoolean(false); } else { data.writeBoolean(true); writeNodeRef(diff.getOldObject(), data); } if (diff.getNewObject() == null) { data.writeBoolean(false); } else { data.writeBoolean(true); writeNodeRef(diff.getNewObject(), data); } }
private boolean hasConflicts(DiffEntry diff1, DiffEntry diff2) { if (!diff1.changeType().equals(diff2.changeType())) { return true; switch (diff1.changeType()) { case ADDED: { TYPE type = diff1.getNewObject().getType(); if (TYPE.TREE.equals(type)) { isConflict = !diff1.getNewObject().getMetadataId() .equals(diff2.getNewObject().getMetadataId()); } else { isConflict = !diff1.getNewObject().getObjectId() .equals(diff2.getNewObject().getObjectId()); TYPE type = diff1.getNewObject().getType(); if (TYPE.TREE.equals(type)) { isConflict = !diff1.getNewObject().getMetadataId() .equals(diff2.getNewObject().getMetadataId()); } else { isConflict = !diff1.newObjectId().equals(diff2.newObjectId());
private DiffObjectInfo<T> toDiffObject(DiffEntry e, Map<ObjectId, T> values) { T oldValue = values.get(e.oldObjectId()); T newValue = values.get(e.newObjectId()); return new DiffObjectInfo<>(e, oldValue, newValue); } }
@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(); }};
public void addAlteredTree(DiffEntry diff) { ObjectId oldFeatureType = diff.getOldObject() == null ? null : diff.getOldObject().getMetadataId(); ObjectId newFeatureType = diff.getNewObject() == null ? null : diff.getNewObject().getMetadataId(); String path = diff.oldPath() == null ? diff.newPath() : diff.oldPath(); alteredTrees.add(new FeatureTypeDiff(path, oldFeatureType, newFeatureType)); }
public void addUnconflicted(DiffEntry diff) { TreeReport treeReport = parentReport(diff.path()); TYPE type = (diff.isAdd() ? diff.getNewObject() : diff.getOldObject()).getType(); if (TYPE.FEATURE == type) { treeReport.unconflictedFeatures.incrementAndGet(); } else { treeReport.unconflictedTrees.incrementAndGet(); } }
diffEntry = diffEntries.next(); StringBuilder sb = new StringBuilder(); String path = diffEntry.newPath() != null ? diffEntry.newPath() : diffEntry.oldPath(); sb.append(diffEntry.changeType().toString().charAt(0)).append(' ').append(path) .append(LINE_BREAK); if (diffEntry.changeType() == ChangeType.MODIFIED) { FeatureDiff featureDiff = geogig.command(DiffFeature.class) .setNewVersion(Suppliers.ofInstance(diffEntry.getNewObject())) .setOldVersion(Suppliers.ofInstance(diffEntry.getOldObject())) .call(); Map<PropertyDescriptor, AttributeDiff> diffs = featureDiff.getDiffs(); HashSet<PropertyDescriptor> diffDescriptors = Sets .newHashSet(diffs.keySet()); NodeRef noderef = diffEntry.changeType() != ChangeType.REMOVED ? diffEntry.getNewObject() : diffEntry.getOldObject(); RevFeatureType featureType = geogig.command(RevObjectParse.class) .setObjectId(noderef.getMetadataId()).call(RevFeatureType.class) NodeRef noderef = diffEntry.changeType() == ChangeType.ADDED ? diffEntry.getNewObject() : diffEntry.getOldObject(); RevFeatureType featureType = geogig.command(RevObjectParse.class) .setObjectId(noderef.getMetadataId()).call(RevFeatureType.class) for (int i = 0; i < feature.size(); i++) { Optional<Object> value = feature.get(i); sb.append(diffEntry.changeType().toString().charAt(0));
new DiffEntry(null, null); fail(); } catch (IllegalArgumentException e) { new DiffEntry(nodeRef, nodeRef); fail(); } catch (IllegalArgumentException e) { new DiffEntry(nodeRef, nodeRef3); fail(); } catch (IllegalArgumentException e) { DiffEntry entry = new DiffEntry(nodeRef, null); assertEquals(nodeRef, entry.getOldObject()); assertEquals(nodeRef, entry.oldObject().get()); assertEquals(node.getObjectId(), entry.oldObjectId()); assertEquals(node.getMetadataId().get(), entry.oldMetadataId()); assertEquals(node.getName(), entry.oldName()); assertEquals(node.getType(), entry.oldObjectType()); assertEquals(nodeRef.path(), entry.oldPath()); assertEquals(null, entry.getNewObject()); assertFalse(entry.newObject().isPresent()); assertEquals(ObjectId.NULL, entry.newObjectId()); assertEquals(ObjectId.NULL, entry.newMetadataId()); assertEquals(null, entry.newName()); assertEquals(null, entry.newObjectType()); assertEquals(null, entry.newPath()); assertEquals(ChangeType.REMOVED, entry.changeType()); assertTrue(entry.isDelete());
@Test public void testTreeModifiedByAddingExtraFeature() throws Exception { insertAndAdd(points1, points2); insert(points3); List<DiffEntry> difflist = toList(diffOp.setReportTrees(true).call()); assertNotNull(difflist); assertEquals(2, difflist.size()); assertEquals(ChangeType.MODIFIED, difflist.get(0).changeType()); assertEquals(TYPE.TREE, difflist.get(0).getOldObject().getType()); assertEquals(ChangeType.ADDED, difflist.get(1).changeType()); assertEquals(TYPE.FEATURE, difflist.get(1).getNewObject().getType()); }
while (diff.hasNext()) { diffEntry = diff.next(); String path = diffEntry.newPath() != null ? diffEntry.newPath() : diffEntry.oldPath(); sb.append('\t').append(path).append(' ') .append(diffEntry.oldObjectId().toString()).append(' ') .append(diffEntry.newObjectId().toString()).append('\n');
Preconditions.checkArgument(oursDiff.oldObject().equals(theirsDiff.oldObject())); final String path = oursDiff.path(); final Optional<NodeRef> ancestorVersion = oursDiff.oldObject(); final ObjectId ancestorVersionId = theirsDiff.oldObjectId(); final ObjectId ours = oursDiff.newObjectId(); final ObjectId theirs = theirsDiff.newObjectId(); if (!oursDiff.changeType().equals(theirsDiff.changeType())) { consumer.conflicted(new Conflict(path, ancestorVersionId, ours, theirs)); report.addConflict(path); return; switch (theirsDiff.changeType()) { case ADDED: if (theirsDiff.getNewObject().equals(oursDiff.getNewObject())) { if (TYPE.TREE == theirsDiff.newObjectType()) { checkForFeatureTypeConflict(ancestorVersion, oursDiff, theirsDiff, report); } else { if (TYPE.TREE == theirsDiff.newObjectType()) { checkForFeatureTypeConflict(ancestorVersion, oursDiff, theirsDiff, report); break; .setCommonAncestor(theirsDiff.getOldObject())// .setMergeInto(oursDiff.getNewObject())//
final java.util.Optional<RevObject> oldObject = diffEntry.oldValue(); final java.util.Optional<RevObject> newObject = diffEntry.newValue(); final String path = diff.path(); switch (diff.changeType()) { case ADDED: if (headObj.isPresent()) { .setParent(repository.getOrCreateHeadTree()).call().get(); if (!headVersion.getMetadataId() .equals(diff.getNewObject().getMetadataId())) { consumer.conflicted(new Conflict(path, ObjectId.NULL, diff.getNewObject().getMetadataId(), headVersion.getMetadataId())); report.addConflict(path); if (!headObj.get().getId().equals(diff.newObjectId())) { consumer.conflicted(new Conflict(path, ObjectId.NULL, diff.newObjectId(), headObj.get().getId())); report.addConflict(path); case REMOVED: if (headObj.isPresent()) { if (headObj.get().getId().equals(diff.oldObjectId())) { consumer.unconflicted(diff); report.addUnconflicted(diff); } else { consumer.conflicted(new Conflict(path, diff.oldObjectId(), ObjectId.NULL, headObj.get().getId()));
if (NodeRef.ROOT.equals(diff.newName()) || NodeRef.ROOT.equals(diff.oldName())) { continue; ref = diff.getNewObject(); ref = diff.getOldObject(); final boolean isDelete = ChangeType.REMOVED.equals(diff.changeType()); final TYPE type = ref.getType(); if (isDelete && deletedTrees.contains(parentPath)) { Node oldNode = diff.getOldObject().getNode(); parentTree.remove(oldNode); if (TYPE.TREE.equals(type)) {
@Test public void testAddNewPathUsingPathFilter() throws Exception { insert(points1); insert(points2); geogig.command(AddOp.class).addPattern("Points/Points.1").call(); List<DiffEntry> unstaged = toList(repo.index().getStaged(null)); assertEquals(unstaged.toString(), 2, unstaged.size()); assertEquals(ChangeType.ADDED, unstaged.get(0).changeType()); assertEquals(RevObject.TYPE.TREE, unstaged.get(0).getNewObject().getType()); assertEquals("Points", unstaged.get(0).newName()); RevFeatureType ft = RevFeatureType.builder().type(pointsType).build(); ObjectId expectedTreeMdId = ft.getId(); assertEquals(expectedTreeMdId, unstaged.get(0).getNewObject().getMetadataId()); assertEquals(ChangeType.ADDED, unstaged.get(1).changeType()); assertEquals(RevObject.TYPE.FEATURE, unstaged.get(1).getNewObject().getType()); assertEquals("Points.1", unstaged.get(1).newName()); assertFalse("feature node's metadata id should not be set, as it uses the parent tree one", unstaged.get(1).getNewObject().getNode().getMetadataId().isPresent()); }
if (input.isChange() && input.getOldObject().getType().equals(TYPE.TREE)) { continue; NodeRef oldObject = filter(input.getOldObject()); NodeRef newObject; if (oldObject != null) { newObject = input.getNewObject(); if (newObject != null) { newObject = filter(input.getNewObject()); return new DiffEntry(oldObject, newObject);
while (diffs.hasNext()) { DiffEntry diff = diffs.next(); if (path.equals(diff.newPath())) { if (diff.isAdd()) { String refSpec = commit.getId().toString() + ":" + path; RevFeature feature = revObjectParse.setRefSpec(refSpec) .setNewVersion(Suppliers.ofInstance(diff.getNewObject())) .setOldVersion(Suppliers.ofInstance(diff.getOldObject())).call(); Map<PropertyDescriptor, AttributeDiff> attribDiffs = featureDiff.getDiffs(); Iterator<PropertyDescriptor> iter = attribDiffs.keySet().iterator();
private void assertDiffObjects(List<DiffObjectInfo<RevFeature>> objects) { for (DiffObjectInfo<RevFeature> o : objects) { DiffEntry entry = o.entry(); switch (entry.changeType()) { case ADDED: assertFalse(o.oldValue().isPresent()); assertTrue(o.newValue().isPresent()); assertEquals(entry.newObjectId(), o.newValue().get().getId()); break; case MODIFIED: assertTrue(o.oldValue().isPresent()); assertTrue(o.newValue().isPresent()); assertEquals(entry.oldObjectId(), o.oldValue().get().getId()); assertEquals(entry.newObjectId(), o.newValue().get().getId()); break; case REMOVED: assertTrue(o.oldValue().isPresent()); assertFalse(o.newValue().isPresent()); assertEquals(entry.oldObjectId(), o.oldValue().get().getId()); break; default: throw new IllegalStateException(); } } }
/** * @return the {@code DiffEntry} in the form of a readable {@code String} */ @Override public String toString() { StringBuilder sb = new StringBuilder(changeType().toString()); if (!isAdd()) { sb.append(" [").append(oldObject).append("] "); } if (isChange()) { sb.append("->"); } if (!isDelete()) { sb.append(" [").append(newObject).append("]"); } return sb.toString(); }
while (unstaged.hasNext()) { DiffEntry entry = unstaged.next(); ChangeType type = entry.changeType(); switch (type) { case ADDED: cli.getConsole().println("A\t" + entry.newPath()); break; case MODIFIED: cli.getConsole().println("M\t" + entry.newPath()); break; case REMOVED: cli.getConsole().println("D\t" + entry.oldPath()); break;
@Override public DiffEntry apply(NodeRef treeRef) { return new DiffEntry(treeRef, null); }};