import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
abstract class AbstractDataTreeCandidateNode implements DataTreeCandidateNode {
- private static final Function<NormalizedNode<?, ?>, DataTreeCandidateNode> TO_DELETED_NODES = new Function<NormalizedNode<?, ?>, DataTreeCandidateNode>() {
+ private static final Function<NormalizedNode<?, ?>, DataTreeCandidateNode> TO_DELETED_NODE = new Function<NormalizedNode<?, ?>, DataTreeCandidateNode>() {
@Override
public DataTreeCandidateNode apply(final NormalizedNode<?, ?> input) {
return AbstractRecursiveCandidateNode.deleteNode(input);
}
- }; private static final Function<NormalizedNode<?, ?>, DataTreeCandidateNode> TO_WRITTEN_NODES = new Function<NormalizedNode<?, ?>, DataTreeCandidateNode>() {
+ };
+ private static final Function<NormalizedNode<?, ?>, DataTreeCandidateNode> TO_WRITTEN_NODE = new Function<NormalizedNode<?, ?>, DataTreeCandidateNode>() {
@Override
public DataTreeCandidateNode apply(final NormalizedNode<?, ?> input) {
return AbstractRecursiveCandidateNode.writeNode(input);
}
};
+ private static Optional<NormalizedNode<?, ?>> getChild(final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> container, final PathArgument identifier) {
+ if (container != null) {
+ return container.getChild(identifier);
+ } else {
+ return Optional.absent();
+ }
+ }
+
+ static DataTreeCandidateNode deltaChild(
+ final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> oldData,
+ final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> newData, final PathArgument identifier) {
+
+ final Optional<NormalizedNode<?, ?>> maybeNewChild = getChild(newData, identifier);
+ final Optional<NormalizedNode<?, ?>> maybeOldChild = getChild(oldData, identifier);
+ if (maybeOldChild.isPresent()) {
+ final NormalizedNode<?, ?> oldChild = maybeOldChild.get();
+ if (maybeNewChild.isPresent()) {
+ return AbstractRecursiveCandidateNode.replaceNode(oldChild, maybeNewChild.get());
+ } else {
+ return TO_DELETED_NODE.apply(oldChild);
+ }
+ } else {
+ if (maybeNewChild.isPresent()) {
+ return TO_WRITTEN_NODE.apply(maybeNewChild.get());
+ } else {
+ return null;
+ }
+ }
+ }
+
static Collection<DataTreeCandidateNode> deltaChildren(@Nullable final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> oldData,
@Nullable final NormalizedNodeContainer<?, PathArgument, NormalizedNode<?, ?>> newData) {
if (newData == null) {
- return Collections2.transform(oldData.getValue(), TO_DELETED_NODES);
+ return Collections2.transform(oldData.getValue(), TO_DELETED_NODE);
}
if (oldData == null) {
- return Collections2.transform(newData.getValue(), TO_WRITTEN_NODES);
+ return Collections2.transform(newData.getValue(), TO_WRITTEN_NODE);
}
// Create index for fast cross-references
abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandidateNode {
- private static final Function<NormalizedNode<?, ?>, DataTreeCandidateNode> TO_UNMODIFIED_NODES = new Function<NormalizedNode<?, ?>, DataTreeCandidateNode>() {
+ private static final Function<NormalizedNode<?, ?>, DataTreeCandidateNode> TO_UNMODIFIED_NODE = new Function<NormalizedNode<?, ?>, DataTreeCandidateNode>() {
@Override
public DataTreeCandidateNode apply(final NormalizedNode<?, ?> input) {
return AbstractRecursiveCandidateNode.unmodifiedNode(input);
// Unmodified node, but we still need to resolve potential children. canHaveChildren returns
// false if both arguments are null.
if (canHaveChildren(oldMeta, newMeta)) {
- return Collections2.transform(getContainer(newMeta != null ? newMeta : oldMeta).getValue(), TO_UNMODIFIED_NODES);
+ return Collections2.transform(getContainer(newMeta != null ? newMeta : oldMeta).getValue(), TO_UNMODIFIED_NODE);
} else {
return Collections.emptyList();
}
return childNode(childMod.get());
}
return null;
- case DELETE:
case UNMODIFIED:
- case WRITE:
- // FIXME: this is a linear walk. We need a Map of these in order to
- // do something like getChildMap().get(identifier);
- for (DataTreeCandidateNode c : getChildNodes()) {
- if (identifier.equals(c.getIdentifier())) {
- return c;
+ if (canHaveChildren(oldMeta, newMeta)) {
+ final Optional<NormalizedNode<?, ?>> maybeChild = getContainer(newMeta != null ? newMeta : oldMeta).getChild(identifier);
+ if (maybeChild.isPresent()) {
+ return TO_UNMODIFIED_NODE.apply(maybeChild.get());
+ } else {
+ return null;
}
+ } else {
+ return null;
+ }
+ case DELETE:
+ case WRITE:
+ if (canHaveChildren(oldMeta, newMeta)) {
+ return AbstractDataTreeCandidateNode.deltaChild(getContainer(oldMeta), getContainer(newMeta), identifier);
+ } else {
+ return null;
}
- return null;
default:
throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType());
}