Bug 2882: Fix off-by-one usage of cursor.

[yangtools.git] / yang / yang-data-api / src / main / java / org / opendaylight / yangtools / yang / data / api / schema / tree / DataTreeCandidateNodes.java

diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java
index e1636ae77e8707baccc837e5f721ad78cbc30a55..3cc1202a26b83b86276145eb413dc616066fcc73 100644 (file)
--- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java
+++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java
@@ -11,6 +11,8 @@ import com.google.common.annotations.Beta;
 import com.google.common.base.Preconditions;
 import java.util.Collection;
 import java.util.Iterator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
 
 @Beta
@@ -29,8 +31,8 @@ public final class DataTreeCandidateNodes {
             cursor.delete(node.getIdentifier());
             break;
         case SUBTREE_MODIFIED:
-            cursor.enter(node.getIdentifier());
-            NodeIterator iterator = new NodeIterator(null, node.getChildNodes().iterator());
+                cursor.enter(node.getIdentifier());
+                AbstractNodeIterator iterator = new ExitingNodeIterator(null, node.getChildNodes().iterator());
             do {
                 iterator = iterator.next(cursor);
             } while (iterator != null);
@@ -46,16 +48,33 @@ public final class DataTreeCandidateNodes {
         }
     }
 
-    private static final class NodeIterator {
+    public static void applyRootToCursor(final DataTreeModificationCursor cursor, final DataTreeCandidateNode node) {
+        switch (node.getModificationType()) {
+            case DELETE:
+                throw new IllegalArgumentException("Can not delete root.");
+            case WRITE:
+            case SUBTREE_MODIFIED:
+                AbstractNodeIterator iterator = new RootNonExitingIterator(node.getChildNodes().iterator());
+                do {
+                    iterator = iterator.next(cursor);
+                } while (iterator != null);
+                break;
+            case UNMODIFIED:
+                // No-op
+                break;
+            default:
+                throw new IllegalArgumentException("Unsupported modification " + node.getModificationType());
+        }
+    }
+
+    private static abstract class AbstractNodeIterator {
         private final Iterator<DataTreeCandidateNode> iterator;
-        private final NodeIterator parent;
 
-        NodeIterator(final NodeIterator parent, final Iterator<DataTreeCandidateNode> iterator) {
-            this.parent = Preconditions.checkNotNull(parent);
+        AbstractNodeIterator(final Iterator<DataTreeCandidateNode> iterator) {
             this.iterator = Preconditions.checkNotNull(iterator);
         }
 
-        NodeIterator next(final DataTreeModificationCursor cursor) {
+        AbstractNodeIterator next(final DataTreeModificationCursor cursor) {
             while (iterator.hasNext()) {
                 final DataTreeCandidateNode node = iterator.next();
                 switch (node.getModificationType()) {
@@ -66,7 +85,7 @@ public final class DataTreeCandidateNodes {
                     final Collection<DataTreeCandidateNode> children = node.getChildNodes();
                     if (!children.isEmpty()) {
                         cursor.enter(node.getIdentifier());
-                        return new NodeIterator(this, children.iterator());
+                            return new ExitingNodeIterator(this, children.iterator());
                     }
                     break;
                 case UNMODIFIED:
@@ -79,9 +98,52 @@ public final class DataTreeCandidateNodes {
                     throw new IllegalArgumentException("Unsupported modification " + node.getModificationType());
                 }
             }
+            exitNode(cursor);
+            return getParent();
+        }
 
-            cursor.exit();
+        protected abstract @Nullable AbstractNodeIterator getParent();
+
+        protected abstract void exitNode(DataTreeModificationCursor cursor);
+    }
+
+    private static final class RootNonExitingIterator extends AbstractNodeIterator {
+
+        protected RootNonExitingIterator(@Nonnull final Iterator<DataTreeCandidateNode> iterator) {
+            super(iterator);
+        }
+
+        @Override
+        protected void exitNode(final DataTreeModificationCursor cursor) {
+            // Intentional noop.
+        }
+
+        @Override
+        protected AbstractNodeIterator getParent() {
+            return null;
+        }
+
+    }
+
+    private static final class ExitingNodeIterator extends AbstractNodeIterator {
+
+        private final AbstractNodeIterator parent;
+
+        public ExitingNodeIterator(@Nullable final AbstractNodeIterator parent,
+                @Nonnull final Iterator<DataTreeCandidateNode> iterator) {
+            super(iterator);
+            this.parent = parent;
+        }
+
+        @Override
+        protected AbstractNodeIterator getParent() {
             return parent;
         }
+
+        @Override
+        protected final void exitNode(final DataTreeModificationCursor cursor) {
+            cursor.exit();
+        }
+
     }
 }