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(); 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())//
@Override public boolean feature(NodeRef left, NodeRef right) { if (!finished && reportFeatures) { try { entries.put(new DiffEntry(left, right)); } catch (InterruptedException e) { // throw Throwables.propagate(e); } } return true; }
/** * @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(); }
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)); }
@Override public boolean apply(@Nullable DiffEntry input) { // HACK: avoid reporting changed trees if (input.isChange() && input.getOldObject().getType().equals(TYPE.TREE)) { return false; } return input.getOldObject() != 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); } }
String crsCode = null; GeometryChange change = null; if (input.changeType() == ChangeType.ADDED || input.changeType() == ChangeType.MODIFIED) { feature = geogig.command(RevObjectParse.class) .setObjectId(input.newObjectId()).call(); type = geogig.command(RevObjectParse.class) .setObjectId(input.getNewObject().getMetadataId()).call(); path = input.getNewObject().path(); } else if (input.changeType() == ChangeType.REMOVED) { feature = geogig.command(RevObjectParse.class) .setObjectId(input.oldObjectId()).call(); type = geogig.command(RevObjectParse.class) .setObjectId(input.getOldObject().getMetadataId()).call(); path = input.getOldObject().path(); SimpleFeature simpleFeature = (SimpleFeature) builder .build(revFeature.getId().toString(), revFeature); change = new GeometryChange(simpleFeature, input.changeType(), path, crsCode);
NodeRef nodeRef = old ? de.getOldObject() : de.getNewObject(); if (nodeRef == null) { return null; featureBuilder.set(name, value); featureBuilder.set(CHANGE_TYPE_NAME, de.changeType().name().charAt(0)); Feature feature = featureBuilder.buildFeature(nodeRef.name()); feature.getUserData().put(Hints.USE_PROVIDED_FID, true);
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');
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());
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)) { String oldName = diff.getOldObject().getNode().getName(); parentTree.remove(oldName); if (TYPE.TREE.equals(type)) {
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);
@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 = RevFeatureTypeBuilder.build(pointsType); 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()); }
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();
/** * @return {@code true} if the objects in this entry represent a deleted feature */ public boolean isDelete() { return ChangeType.REMOVED.equals(changeType()); }
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;
if (diff.changeType().equals(DiffEntry.ChangeType.REMOVED)) { ObjectId featureId = diff.getOldObject().getNode().getObjectId(); RevFeature revFeature = command(RevObjectParse.class).setObjectId(featureId) .call(RevFeature.class).get(); RevFeatureType revFeatureType = command(RevObjectParse.class) .setObjectId(diff.getOldObject().getMetadataId()) .call(RevFeatureType.class).get(); List<PropertyDescriptor> descriptors = revFeatureType.descriptors();
assertEquals(1, diffs.size()); diff = diffs.get(0); assertEquals(ChangeType.MODIFIED, diff.changeType()); assertEquals(initialOid, diff.oldObjectId()); assertEquals(modifiedOid, diff.newObjectId()); assertEquals(1, diffs.size()); diff = diffs.get(0); assertEquals(ChangeType.REMOVED, diff.changeType()); assertEquals(initialOid, diff.oldObjectId()); assertEquals(ObjectId.NULL, diff.newObjectId()); assertEquals(1, diffs.size()); diff = diffs.get(0); assertEquals(ChangeType.ADDED, diff.changeType()); assertEquals(ObjectId.NULL, diff.oldObjectId()); assertEquals(initialOid, diff.newObjectId()); assertEquals(1, diffs.size()); diff = diffs.get(0); assertEquals(ChangeType.ADDED, diff.changeType()); assertEquals(ObjectId.NULL, diff.oldObjectId()); assertEquals(modifiedOid, diff.newObjectId());
if (diff.isDelete()) { builder.remove(diff.oldName()); } else { NodeRef newObject = diff.getNewObject(); Node node = newObject.getNode(); builder.put(node);
/** * @return the metadata {@link ObjectId} of the old object, or {@link ObjectId#NULL} if there * isn't one */ public ObjectId oldMetadataId() { NodeRef oldObject = getOldObject(); return oldObject != null ? oldObject.getMetadataId() : ObjectId.NULL; } }