Remove SourceSpecificContext.getRoot()

[yangtools.git] / parser / yang-parser-reactor / src / main / java / org / opendaylight / yangtools / yang / parser / stmt / reactor / StatementMap.java

diff --git a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java
index d837b93ba6e5ad9a6d494a2bf0d0491794f45345..931f6a16f0cfbcf7bc69bae740d4cebb66f998a5 100644 (file)
--- a/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java
+++ b/parser/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java
@@ -32,15 +32,15 @@ import org.eclipse.jdt.annotation.Nullable;
  *
  * @author Robert Varga
  */
-abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<?, ?, ?>> {
+abstract class StatementMap extends AbstractCollection<OriginalStmtCtx<?, ?, ?>> {
     private static final class Empty extends StatementMap {
-        private static final Iterator<AbstractResumedStatement<?, ?, ?>> EMPTY_ITERATOR;
+        private static final Iterator<OriginalStmtCtx<?, ?, ?>> EMPTY_ITERATOR;
 
         static {
             // This may look weird, but we really want to return two Iterator implementations from StatementMap, so that
             // users have to deal with bimorphic invocation. Note that we want to invoke hasNext() here, as we want to
             // initialize state to AbstractIterator.endOfData().
-            final Iterator<AbstractResumedStatement<?, ?, ?>> it = new Regular(0).iterator();
+            final Iterator<OriginalStmtCtx<?, ?, ?>> it = new Regular(0).iterator();
             verify(!it.hasNext());
             EMPTY_ITERATOR = it;
         }
@@ -51,7 +51,7 @@ abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<
         }
 
         @Override
-        StatementMap put(final int index, final AbstractResumedStatement<?, ?, ?> obj) {
+        StatementMap put(final int index, final OriginalStmtCtx<?, ?, ?> obj) {
             return index == 0 ? new Singleton(obj) : new Regular(index, obj);
         }
 
@@ -66,48 +66,47 @@ abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<
         }
 
         @Override
-        public void forEach(final Consumer<? super AbstractResumedStatement<?, ?, ?>> action) {
+        public void forEach(final Consumer<? super OriginalStmtCtx<?, ?, ?>> action) {
             // No-op
         }
 
         @Override
-        public Iterator<AbstractResumedStatement<?, ?, ?>> iterator() {
+        public Iterator<OriginalStmtCtx<?, ?, ?>> iterator() {
             return EMPTY_ITERATOR;
         }
     }
 
     private static final class Regular extends StatementMap {
-        private AbstractResumedStatement<?, ?, ?>[] elements;
+        private OriginalStmtCtx<?, ?, ?>[] elements;
         private int size;
 
         Regular(final int expectedLimit) {
-            elements = new AbstractResumedStatement<?, ?, ?>[expectedLimit];
+            elements = new OriginalStmtCtx<?, ?, ?>[expectedLimit];
         }
 
-        Regular(final int index, final AbstractResumedStatement<?, ?, ?> object) {
+        Regular(final int index, final OriginalStmtCtx<?, ?, ?> object) {
             this(index + 1, index, object);
         }
 
-        Regular(final AbstractResumedStatement<?, ?, ?> object0, final int index,
-                final AbstractResumedStatement<?, ?, ?> object) {
+        Regular(final OriginalStmtCtx<?, ?, ?> object0, final int index, final OriginalStmtCtx<?, ?, ?> object) {
             this(index + 1, 0, object0);
             elements[index] = requireNonNull(object);
             size = 2;
         }
 
-        Regular(final int expectedLimit, final int index, final AbstractResumedStatement<?, ?, ?> object) {
+        Regular(final int expectedLimit, final int index, final OriginalStmtCtx<?, ?, ?> object) {
             this(expectedLimit);
             elements[index] = requireNonNull(object);
             size = 1;
         }
 
         @Override
-        AbstractResumedStatement<?, ?, ?> get(final int index) {
+        OriginalStmtCtx<?, ?, ?> get(final int index) {
             return index >= elements.length ? null : elements[index];
         }
 
         @Override
-        StatementMap put(final int index, final AbstractResumedStatement<?, ?, ?> obj) {
+        StatementMap put(final int index, final OriginalStmtCtx<?, ?, ?> obj) {
             if (index < elements.length) {
                 checkArgument(elements[index] == null);
             } else {
@@ -134,41 +133,49 @@ abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<
         }
 
         @Override
-        public Iterator<AbstractResumedStatement<?, ?, ?>> iterator() {
-            return new AbstractIterator<>() {
-                private int nextOffset = 0;
+        public Iterator<OriginalStmtCtx<?, ?, ?>> iterator() {
+            return new Iter(this);
+        }
 
-                @Override
-                protected AbstractResumedStatement<?, ?, ?> computeNext() {
-                    while (nextOffset < elements.length) {
-                        final AbstractResumedStatement<?, ?, ?> ret = elements[nextOffset++];
-                        if (ret != null) {
-                            return ret;
-                        }
-                    }
+        private static final class Iter extends AbstractIterator<OriginalStmtCtx<?, ?, ?>> {
+            private int nextOffset = 0;
+            private Regular map;
+
+            Iter(final Regular map) {
+                this.map = requireNonNull(map);
+            }
 
-                    return endOfData();
+            @Override
+            protected OriginalStmtCtx<?, ?, ?> computeNext() {
+                while (nextOffset < map.elements.length) {
+                    final OriginalStmtCtx<?, ?, ?> ret = map.elements[nextOffset++];
+                    if (ret != null) {
+                        return ret;
+                    }
                 }
-            };
+
+                map = null;
+                return endOfData();
+            }
         }
     }
 
     private static final class Singleton extends StatementMap {
-        private final AbstractResumedStatement<?, ?, ?> object;
+        private final OriginalStmtCtx<?, ?, ?> object;
 
-        Singleton(final AbstractResumedStatement<?, ?, ?> object) {
+        Singleton(final OriginalStmtCtx<?, ?, ?> object) {
             this.object = requireNonNull(object);
         }
 
         @Override
-        AbstractResumedStatement<?, ?, ?> get(final int index) {
+        OriginalStmtCtx<?, ?, ?> get(final int index) {
             return index == 0 ? object : null;
         }
 
         @Override
-        StatementMap put(final int index, final AbstractResumedStatement<?, ?, ?> obj) {
+        StatementMap put(final int index, final OriginalStmtCtx<?, ?, ?> obj) {
             checkArgument(index != 0);
-            return new Regular(this.object, index, obj);
+            return new Regular(object, index, obj);
         }
 
         @Override
@@ -182,14 +189,19 @@ abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<
         }
 
         @Override
-        public Iterator<AbstractResumedStatement<?, ?, ?>> iterator() {
+        public Iterator<OriginalStmtCtx<?, ?, ?>> iterator() {
             return Iterators.singletonIterator(object);
         }
     }
 
-    private static final StatementMap EMPTY = new Empty();
+    private static final @NonNull StatementMap EMPTY = new Empty();
 
-    static StatementMap empty() {
+    /**
+     * Return an empty map.
+     *
+     * @return An empty map.
+     */
+    static @NonNull StatementMap empty() {
         return EMPTY;
     }
 
@@ -199,7 +211,7 @@ abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<
      * @param index Element index, must be non-negative
      * @return Requested element or null if there is no element at that index
      */
-    abstract @Nullable AbstractResumedStatement<?, ?, ?> get(int index);
+    abstract @Nullable OriginalStmtCtx<?, ?, ?> get(int index);
 
     /**
      * Add a statement at specified index.
@@ -209,7 +221,13 @@ abstract class StatementMap extends AbstractCollection<AbstractResumedStatement<
      * @return New statement map
      * @throws IllegalArgumentException if the index is already occupied
      */
-    abstract @NonNull StatementMap put(int index, @NonNull AbstractResumedStatement<?, ?, ?> obj);
+    abstract @NonNull StatementMap put(int index, @NonNull OriginalStmtCtx<?, ?, ?> obj);
 
+    /**
+     * Ensure storage space for at least {@code explectedLimit} substatements.
+     *
+     * @param expectedLimit Expected number of substatements
+     * @return New statement map
+     */
     abstract @NonNull StatementMap ensureCapacity(int expectedLimit);
 }