@Override public boolean childNodeChanged( String name, NodeState before, NodeState after) { return after.compareAgainstBaseState(before, this); }
@NotNull @Override public NodeState processCommit(NodeState before, NodeState after, CommitInfo info) { this.enter(before, after); after.compareAgainstBaseState(before, this); this.leave(before, after); return after; }
@Override public boolean childNodeChanged(String name, NodeState before, NodeState after) { String p = concat(path, name); pw.println("^ " + p); return after.compareAgainstBaseState(before, new PrintingDiff(pw, p)); }
public void collect(final Filter filter) { DiffCollectorNodeStateDiff diff = new DiffCollectorNodeStateDiff(this, filter); after.compareAgainstBaseState(before, diff); this.results = new HashSet<String>(diff.getResults()); this.resultFilter = filter; this.init = true; }
@NotNull @Override public NodeState processCommit(NodeState before, NodeState after, CommitInfo info) { NodeBuilder builder = after.builder(); after.compareAgainstBaseState(before, new Diff(before, builder)); deletedCUGs.clear(); return builder.getNodeState(); }
@Override public boolean childNodeChanged(String name, NodeState before, NodeState after) { //TODO [bundling] Handle change of primaryType. Current approach would work //but if bundling was enabled for previous nodetype its "side effect" //would still impact even though new nodetype does not have bundling enabled BundlingHandler child = bundlingHandler.childChanged(name, before, after); return after.compareAgainstBaseState(before, new CommitDiff(store, commit, child, builder, blobs)); }
@Override public boolean childNodeChanged( String name, NodeState before, NodeState after) { return after.compareAgainstBaseState( before, new ApplyDiff(builder.getChildNode(name))); }
@Override public boolean childNodeChanged(String name, NodeState before, NodeState after) { if (builder.hasChildNode(name)) { after.compareAgainstBaseState(before, createDiff(builder, name)); } else if (after.equals(before)) { return false; } else { changeDeletedNode(builder, name, after, before); } return true; }
@Override public boolean childNodeChanged(String name, NodeState before, NodeState after) { if (builder.hasChildNode(name)) { after.compareAgainstBaseState(before, createDiff(builder, name)); } else if (after.equals(before)) { return false; } else { changeDeletedNode(builder, name, after, before); } return true; }
@Override public boolean childNodeChanged(String name, NodeState before, NodeState after) { if (ROOT_PATH.equals(path) || Text.isDescendant(path, PRIVILEGES_PATH)) { after.compareAgainstBaseState(before, new PrivilegeDiff(this, name, nodeBuilder.child(name))); } return true; } }
private void verify() { final NodeState sourceRoot = source.getRoot(); final NodeState targetRoot = target.getRoot(); final NodeState reportingSource = ReportingNodeState.wrap(sourceRoot, new LoggingReporter(LOG, "Verifying", LOG_NODE_COPY, -1)); LOG.info("Verifying whether repositories are identical"); if (targetRoot.compareAgainstBaseState(reportingSource, new LoggingEqualsDiff(LOG, "/"))) { LOG.info("Verification result: both repositories are identical"); } else { LOG.warn("Verification result: repositories are not identical"); } }
@Override public boolean childNodeAdded(String name, NodeState after) { if (builder.hasChildNode(name)) { after.compareAgainstBaseState(EMPTY_NODE, createDiff(builder, name)); } else { builder.setChildNode(name, after); } return true; }
/** * Diffs the given node states and returns {@code true} if there are no * differences. * * @param before before state * @param after after state * @return {@code true} if the states are equal, {@code false} otherwise */ public static boolean equals(NodeState before, NodeState after) { return before.exists() == after.exists() && after.compareAgainstBaseState(before, new EqualsDiff()); }
@Test public void testSameState() { NodeState node = builder.getNodeState(); replay(diff); node.compareAgainstBaseState(node, diff); verify(diff); }
@Override public boolean childNodeDeleted(String name, NodeState before) { String p = PathUtils.concat(path, name); ResetDiff diff = new ResetDiff(revision, p, operations); NodeDocument.removeDeleted(diff.getUpdateOp(), revision); return MISSING_NODE.compareAgainstBaseState(before, diff); }
@Override public boolean childNodeDeleted(String name, NodeState before) { BundlingHandler child = bundlingHandler.childDeleted(name, before); if (child.isBundlingRoot()) { commit.removeNode(child.getRootBundlePath(), before); } setOrTouchChildrenFlag(child); return MISSING_NODE.compareAgainstBaseState(before, new CommitDiff(store, commit, child, builder, blobs)); }
@Test public void testPropertyAdded() { NodeState before = builder.getNodeState(); builder = before.builder(); builder.setProperty("test", "test"); NodeState after = builder.getNodeState(); expect(diff.propertyAdded(after.getProperty("test"))).andReturn(true); replay(diff); after.compareAgainstBaseState(before, diff); verify(diff); }
@Test public void testChildNodeDeleted() { NodeState before = builder.getNodeState(); builder.getChildNode("baz").remove(); NodeState after = builder.getNodeState(); expect(diff.childNodeDeleted("baz", before.getChildNode("baz"))).andReturn(true); replay(diff); after.compareAgainstBaseState(before, diff); verify(diff); }
@Test public void testPropertyDeleted() { NodeState before = builder.getNodeState(); builder = before.builder(); builder.removeProperty("foo"); NodeState after = builder.getNodeState(); expect(diff.propertyDeleted(before.getProperty("foo"))).andReturn(true); replay(diff); after.compareAgainstBaseState(before, diff); verify(diff); }
@Override public String diffStoredIndexDefinition(@Name("indexPath") String indexPath) { NodeState stored = NodeStateUtils.getNode(indexTracker.getRoot(), indexPath + "/" + INDEX_DEFINITION_NODE); NodeState current = NodeStateUtils.getNode(indexTracker.getRoot(), indexPath); if (stored.exists()){ current = NodeStateCloner.cloneVisibleState(current); JsopDiff diff = new JsopDiff(); current.compareAgainstBaseState(stored, diff); return JsopBuilder.prettyPrint(diff.toString()); } return "No stored index definition found at given path"; }