X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fimpl%2Fschema%2Ftree%2FAbstractModifiedNodeBasedCandidateNode.java;h=e6967edae404d3043a24ac4c8e71a4683018f00a;hb=b19410d5a467d095d05057d58e9c3e0b95a92f5b;hp=6c947843ccd57f989891a1442f0a81767934651d;hpb=69680caa00028178595852506403f91ca3e8a1d7;p=yangtools.git

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java
index 6c947843cc..e6967edae4 100644
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java
@@ -23,7 +23,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
 
 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);
@@ -53,7 +53,7 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida
         return oldMeta;
     }
 
-    private static final TreeNode childMeta(final TreeNode parent, final PathArgument id) {
+    private static TreeNode childMeta(final TreeNode parent, final PathArgument id) {
         if (parent != null) {
             return parent.getChild(id).orNull();
         } else {
@@ -84,6 +84,8 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida
     @Override
     public Collection<DataTreeCandidateNode> getChildNodes() {
         switch (mod.getModificationType()) {
+        case APPEARED:
+        case DISAPPEARED:
         case SUBTREE_MODIFIED:
             return Collections2.transform(mod.getChildren(), new Function<ModifiedNode, DataTreeCandidateNode>() {
                 @Override
@@ -95,7 +97,7 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida
             // 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();
             }
@@ -127,35 +129,44 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida
     }
 
     @Override
-    public Optional<NormalizedNode<?, ?>> getDataAfter() {
+    public final Optional<NormalizedNode<?, ?>> getDataAfter() {
         return optionalData(newMeta);
     }
 
     @Override
-    public Optional<NormalizedNode<?, ?>> getDataBefore() {
+    public final Optional<NormalizedNode<?, ?>> getDataBefore() {
         return optionalData(oldMeta);
     }
 
     @Override
-    public DataTreeCandidateNode getModifiedChild(final PathArgument identifier) {
+    public final DataTreeCandidateNode getModifiedChild(final PathArgument identifier) {
         switch (mod.getModificationType()) {
+        case APPEARED:
+        case DISAPPEARED:
         case SUBTREE_MODIFIED:
             final Optional<ModifiedNode> childMod = mod.getChild(identifier);
             if (childMod.isPresent()) {
                 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());
         }
@@ -171,4 +182,10 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida
             return getMod().getIdentifier();
         }
     }
-}
\ No newline at end of file
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + "{mod = " + this.mod + ", oldMeta = " + this.oldMeta + ", newMeta = " +
+                this.newMeta + "}";
+    }
+}