/** * @return the metadata {@link ObjectId} of the new object, or {@link ObjectId#NULL} if there * isn't one */ public ObjectId newMetadataId() { NodeRef newObject = getNewObject(); return newObject != null ? newObject.getMetadataId() : ObjectId.NULL; }
/** * @return the {@link RevObject.TYPE} of the new object, or {@code null} if there isn't one */ public TYPE newObjectType() { NodeRef newObject = getNewObject(); return newObject != null ? newObject.getType() : null; }
public 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); } }
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); } }
@Override public void write(DataOutputStream out, DiffEntry e) throws IOException { @Nullable NodeRef left = e.getOldObject(); @Nullable NodeRef right = e.getNewObject(); write(out, left); write(out, right); }
@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(); }};
private void checkForFeatureTypeConflict(Optional<NodeRef> ancestorVersion, DiffEntry oursDiff, DiffEntry theirsDiff, MergeScenarioReport report) { final String path = oursDiff.path(); final boolean featureTypeConflict = !theirsDiff.getNewObject().getMetadataId() .equals(oursDiff.getNewObject().getMetadataId()); if (featureTypeConflict) { // In this case, we store the metadata id, not the element id ObjectId ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion.get().getMetadataId() : ObjectId.NULL; ObjectId ours = oursDiff.getNewObject().getMetadataId(); ObjectId theirs = theirsDiff.getNewObject().getMetadataId(); consumer.conflicted(new Conflict(path, ancestorVersionId, ours, theirs)); report.addConflict(path); } } }
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(); } }
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)); }
private static String formatPath(DiffEntry entry) { String path; NodeRef oldObject = entry.getOldObject(); NodeRef newObject = entry.getNewObject(); if (oldObject == null) { path = newObject.path(); } else if (newObject == null) { path = oldObject.path(); } else { if (oldObject.path().equals(newObject.path())) { path = oldObject.path(); } else { path = oldObject.path() + " -> " + newObject.path(); } } return path; }
private static String formatPath(DiffEntry entry) { String path; NodeRef oldObject = entry.getOldObject(); NodeRef newObject = entry.getNewObject(); if (oldObject == null) { path = newObject.path(); } else if (newObject == null) { path = oldObject.path(); } else { if (oldObject.path().equals(newObject.path())) { path = oldObject.path(); } else { path = oldObject.path() + " -> " + newObject.path(); } } return path; }
@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()); }
public @Test void testDiffLeafBucketRoot() { List<NodeRef> layers = createLayers(10); WorkingTree workingTree = repo.workingTree(); RevTree initialRoot = workingTree.getTree(); NodeRef layer = layers.get(0); NodeRef update = putFeatures(layer, 1000); RevTree finalRoot = workingTree.getTree(); List<DiffEntry> res = findWithFindChangedTreesCommand(initialRoot, finalRoot); assertEquals(1, res.size()); DiffEntry entry = res.get(0); assertEquals(layer, entry.getOldObject()); assertEquals(update, entry.getNewObject()); }
@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()); }
@Test public void testAddMultipleFeaturesWithPathFilter() throws Exception { insert(points1); insert(points2); insert(lines1); geogig.command(AddOp.class).addPattern("Points").call(); List<DiffEntry> unstaged = toList(repo.workingTree().getUnstaged(null)); assertEquals(2, unstaged.size()); assertEquals(linesName, unstaged.get(0).newName()); assertEquals(ChangeType.ADDED, unstaged.get(0).changeType()); assertEquals(TYPE.TREE, unstaged.get(0).getNewObject().getType()); }
public @Test void testDiffLeafRoot() { List<NodeRef> layers = createLayers(10); WorkingTree workingTree = repo.workingTree(); RevTree initialRoot = workingTree.getTree(); NodeRef layer = layers.get(0); NodeRef update = putFeatures(layer, 1); RevTree finalRoot = workingTree.getTree(); List<DiffEntry> res = command.setOldTreeIsh(initialRoot.getId()) .setNewTreeIsh(finalRoot.getId()).call(); assertEquals(1, res.size()); DiffEntry entry = res.get(0); assertEquals(layer, entry.getOldObject()); assertEquals(update, entry.getNewObject()); }
@Test public void testReportTreesEmptyTreeFromFeatureDeletion() throws Exception { insert(lines1); delete(lines1); List<DiffEntry> difflist = toList(diffOp.setReportTrees(true).setOldVersion(ObjectId.NULL) .setNewVersion(Ref.WORK_HEAD).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); assertEquals(linesName, difflist.get(0).newName()); DiffEntry de = difflist.get(0); assertNull(de.getOldObject()); assertNotNull(de.getNewObject()); assertEquals(linesName, de.newPath()); assertEquals(DiffEntry.ChangeType.ADDED, de.changeType()); assertEquals(ObjectId.NULL, de.oldObjectId()); assertFalse(de.getNewObject().getMetadataId().isNull()); }
@Test public void testReportTreesEmptyTree() throws Exception { WorkingTree workingTree = geogig.getRepository().workingTree(); workingTree.createTypeTree(linesName, linesType); List<DiffEntry> difflist = toList(diffOp.setReportTrees(true).setOldVersion(ObjectId.NULL) .setNewVersion(Ref.WORK_HEAD).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); DiffEntry de = difflist.get(0); assertNull(de.getOldObject()); assertNotNull(de.getNewObject()); assertEquals(linesName, de.newPath()); assertEquals(DiffEntry.ChangeType.ADDED, de.changeType()); assertEquals(ObjectId.NULL, de.oldObjectId()); assertFalse(de.getNewObject().getMetadataId().isNull()); }
@Test public void testSingleAddition() throws Exception { final ObjectId newOid = insertAndAdd(points1); geogig.command(CommitOp.class).setAll(true).call(); List<DiffEntry> difflist = toList( diffOp.setOldVersion(ObjectId.NULL).setNewVersion(Ref.HEAD).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); DiffEntry de = difflist.get(0); assertNull(de.getOldObject()); assertNotNull(de.getNewObject()); String expectedPath = NodeRef.appendChild(pointsName, points1.getIdentifier().getID()); assertEquals(expectedPath, de.newPath()); assertEquals(DiffEntry.ChangeType.ADDED, de.changeType()); assertEquals(ObjectId.NULL, de.oldObjectId()); assertEquals(newOid, de.newObjectId()); assertFalse(de.getNewObject().getMetadataId().isNull()); }
@Test public void testSingleAdditionReverseOrder() throws Exception { final ObjectId newOid = insertAndAdd(points1); final RevCommit commit = geogig.command(CommitOp.class).setAll(true).call(); List<DiffEntry> difflist = toList( diffOp.setOldVersion(commit.getId()).setNewVersion(ObjectId.NULL).call()); assertNotNull(difflist); assertEquals(1, difflist.size()); DiffEntry de = difflist.get(0); assertNull(de.getNewObject()); assertNotNull(de.getOldObject()); assertEquals(DiffEntry.ChangeType.REMOVED, de.changeType()); assertEquals(ObjectId.NULL, de.newObjectId()); assertEquals(newOid, de.oldObjectId()); assertFalse(de.getOldObject().getMetadataId().isNull()); }