BUG-7052: reduce StatementContextBase proliferation even more

This splits up the mutable and immutable views of declared/effective
statements so we do not access mutable state when all we need is
immutable view.

The mutable view now has only StmtContext.Mutable, hence users get
more isolation from the reactor implementation.

Change-Id: I3e77b3837beea533590cad681c1895e047c9a2a6
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java
index b26b1d6349e262d046e21d0adddd27d9b25a057e..d174b9754392e40239ff14bedc466acc2322fb76 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StmtContext.java
@@ -114,9 +114,9 @@ public interface StmtContext<A, D extends DeclaredStatement<A>, E extends Effect
 
     Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement();
 
-    StatementContextBase<A, D, E> createCopy(StatementContextBase<?, ?, ?> newParent, CopyType typeOfCopy);
+    Mutable<A, D, E> createCopy(StatementContextBase<?, ?, ?> newParent, CopyType typeOfCopy);
 
-    StatementContextBase<A, D, E> createCopy(QNameModule newQNameModule, StatementContextBase<?, ?, ?> newParent,
+    Mutable<A, D, E> createCopy(QNameModule newQNameModule, StatementContextBase<?, ?, ?> newParent,
             CopyType typeOfCopy);
 
     CopyHistory getCopyHistory();
@@ -142,23 +142,20 @@ public interface StmtContext<A, D extends DeclaredStatement<A>, E extends Effect
             extends StmtContext<A, D, E> {
 
         @Override
-        StmtContext.Mutable<?, ?, ?> getParentContext();
+        Mutable<?, ?, ?> getParentContext();
 
-        <K, V, KT extends K, VT extends V, N extends IdentifierNamespace<K, V>> void addToNs(
-                Class<N> type, KT key, VT value)
-                throws NamespaceNotAvailableException;
+        <K, V, KT extends K, VT extends V, N extends IdentifierNamespace<K, V>> void addToNs(Class<N> type, KT key,
+                VT value) throws NamespaceNotAvailableException;
 
         @Nonnull
         @Override
-        StmtContext.Mutable<?, ?, ?> getRoot();
+        Mutable<?, ?, ?> getRoot();
 
-        @Override
         @Nonnull
-        Collection<StatementContextBase<?, ?, ?>> declaredSubstatements();
+        Collection<? extends Mutable<?, ?, ?>> mutableDeclaredSubstatements();
 
-        @Override
         @Nonnull
-        Collection<StatementContextBase<?, ?, ?>> effectiveSubstatements();
+        Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements();
 
         /**
          * Create a new inference action to be executed during specified phase. The action cannot be cancelled
@@ -180,8 +177,8 @@ public interface StmtContext<A, D extends DeclaredStatement<A>, E extends Effect
          * @param stmt
          *            to be added to namespace map
          */
-        <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(
-                Class<N> namespace, KT key, StmtContext<?, ?, ?> stmt);
+        <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(Class<N> namespace, KT key,
+                StmtContext<?, ?, ?> stmt);
 
         /**
          * Set version of root statement context.

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java
index a86e7ecb2cb48a18c708dc1fc873efc95134440c..7bb341e73c5dc633de57bb2f739d5b800316a736 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java
@@ -78,11 +78,11 @@ public class RootStatementContext<A, D extends DeclaredStatement<A>, E extends E
         sourceContext = Preconditions.checkNotNull(original.sourceContext);
         this.argument = original.argument;
 
-        final Collection<StatementContextBase<?, ?, ?>> declared = original.declaredSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> effective = original.effectiveSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+        final Collection<? extends Mutable<?, ?, ?>> declared = original.mutableDeclaredSubstatements();
+        final Collection<? extends Mutable<?, ?, ?>> effective = original.mutableEffectiveSubstatements();
+        final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
 
-        for (final StatementContextBase<?, ?, ?> stmtContext : declared) {
+        for (final Mutable<?, ?, ?> stmtContext : declared) {
             if (stmtContext.isSupportedByFeatures()) {
                 buffer.add(stmtContext.createCopy(newQNameModule, this, typeOfCopy));
             }

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
index eaf8aeb909e66976c2d5c9b69daf6ffc1c2cb566..423a0cabb9ff5936f3c29c0147915f29c31a737e 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java
@@ -85,7 +85,7 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
 
     private Multimap<ModelProcessingPhase, OnPhaseFinished> phaseListeners = ImmutableMultimap.of();
     private Multimap<ModelProcessingPhase, ContextMutation> phaseMutation = ImmutableMultimap.of();
-    private Collection<StatementContextBase<?, ?, ?>> effective = ImmutableList.of();
+    private Collection<Mutable<?, ?, ?>> effective = ImmutableList.of();
     private Collection<StmtContext<?, ?, ?>> effectOfStatement = ImmutableList.of();
     private StatementMap substatements = StatementMap.empty();
 
@@ -237,13 +237,24 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
 
     @Nonnull
     @Override
-    public Collection<StatementContextBase<?, ?, ?>> declaredSubstatements() {
+    public Collection<? extends StmtContext<?, ?, ?>> declaredSubstatements() {
         return substatements.values();
     }
 
     @Nonnull
     @Override
-    public Collection<StatementContextBase<?, ?, ?>> effectiveSubstatements() {
+    public Collection<? extends Mutable<?, ?, ?>> mutableDeclaredSubstatements() {
+        return substatements.values();
+    }
+
+    @Override
+    public Collection<? extends StmtContext<?, ?, ?>> effectiveSubstatements() {
+        return mutableEffectiveSubstatements();
+    }
+
+    @Nonnull
+    @Override
+    public Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements() {
         if (effective instanceof ImmutableCollection) {
             return effective;
         }
@@ -269,9 +280,9 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
             return;
         }
 
-        final Iterator<StatementContextBase<?, ?, ?>> iterator = effective.iterator();
+        final Iterator<? extends StmtContext<?, ?, ?>> iterator = effective.iterator();
         while (iterator.hasNext()) {
-            final StatementContextBase<?, ?, ?> next = iterator.next();
+            final StmtContext<?, ?, ?> next = iterator.next();
             if (statementDef.equals(next.getPublicDefinition())) {
                 iterator.remove();
             }
@@ -301,9 +312,9 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
             return;
         }
 
-        final Iterator<StatementContextBase<?, ?, ?>> iterator = effective.iterator();
+        final Iterator<Mutable<?, ?, ?>> iterator = effective.iterator();
         while (iterator.hasNext()) {
-            final StatementContextBase<?, ?, ?> next = iterator.next();
+            final Mutable<?, ?, ?> next = iterator.next();
             if (statementDef.equals(next.getPublicDefinition()) && statementArg.equals(next.rawStatementArgument())) {
                 iterator.remove();
             }
@@ -321,9 +332,7 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
      * @throws NullPointerException
      *             if statement parameter is null
      */
-    public void addEffectiveSubstatement(final StatementContextBase<?, ?, ?> substatement) {
-        Preconditions.checkNotNull(substatement, "StatementContextBase effective substatement cannot be null at: %s",
-            getStatementSourceReference());
+    public void addEffectiveSubstatement(final Mutable<?, ?, ?> substatement) {
         beforeAddEffectiveStatement(1);
         effective.add(substatement);
     }
@@ -337,7 +346,7 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
      * @throws NullPointerException
      *             if statement parameter is null
      */
-    public void addEffectiveSubstatements(final Collection<StatementContextBase<?, ?, ?>> substatements) {
+    public void addEffectiveSubstatements(final Collection<? extends Mutable<?, ?, ?>> substatements) {
         if (substatements.isEmpty()) {
             return;
         }
@@ -450,8 +459,10 @@ public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E
         for (final StatementContextBase<?, ?, ?> child : substatements.values()) {
             finished &= child.tryToCompletePhase(phase);
         }
-        for (final StatementContextBase<?, ?, ?> child : effective) {
-            finished &= child.tryToCompletePhase(phase);
+        for (final Mutable<?, ?, ?> child : effective) {
+            if (child instanceof StatementContextBase) {
+                finished &= ((StatementContextBase<?, ?, ?>) child).tryToCompletePhase(phase);
+            }
         }
 
         if (finished) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java
index 3380a1e21602023fbec4b47522341dbd63f9066f..2710f0802ad025bb3fc26f1f233b8f40487acc7a 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java
@@ -163,28 +163,27 @@ final class SubstatementContext<A, D extends DeclaredStatement<A>, E extends Eff
 
     private void copyStatements(final SubstatementContext<A, D, E> original, final QNameModule newQNameModule,
             final CopyType typeOfCopy) {
-        final Collection<StatementContextBase<?, ?, ?>> declared = original.declaredSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> effective = original.effectiveSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+        final Collection<? extends Mutable<?, ?, ?>> declared = original.mutableDeclaredSubstatements();
+        final Collection<? extends Mutable<?, ?, ?>> effective = original.mutableEffectiveSubstatements();
+        final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
 
-        for (final StatementContextBase<?, ?, ?> stmtContext : declared) {
+        for (final Mutable<?, ?, ?> stmtContext : declared) {
             if (stmtContext.isSupportedByFeatures()) {
                 copySubstatement(stmtContext, newQNameModule, typeOfCopy, buffer);
             }
         }
 
-        for (final StatementContextBase<?, ?, ?> stmtContext : effective) {
+        for (final Mutable<?, ?, ?> stmtContext : effective) {
             copySubstatement(stmtContext, newQNameModule, typeOfCopy, buffer);
         }
 
         addEffectiveSubstatements(buffer);
     }
 
-    private void copySubstatement(final StatementContextBase<?, ?, ?> stmtContext,
-            final QNameModule newQNameModule, final CopyType typeOfCopy,
-            final Collection<StatementContextBase<?, ?, ?>> buffer) {
+    private void copySubstatement(final Mutable<?, ?, ?> stmtContext, final QNameModule newQNameModule,
+            final CopyType typeOfCopy, final Collection<Mutable<?, ?, ?>> buffer) {
         if (needToCopyByUses(stmtContext)) {
-            final StatementContextBase<?, ?, ?> copy = stmtContext.createCopy(newQNameModule, this, typeOfCopy);
+            final Mutable<?, ?, ?> copy = stmtContext.createCopy(newQNameModule, this, typeOfCopy);
             LOG.debug("Copying substatement {} for {} as", stmtContext, this, copy);
             buffer.add(copy);
         } else if (isReusedByUses(stmtContext)) {

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
index 7822c05c4c44612f8acca11e35c02b8af96712e5..e99dd91b0ddfa6f24388b71bf109d95ca2bcad49 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/AugmentStatementImpl.java
@@ -8,7 +8,7 @@
 package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
 
 import com.google.common.base.Verify;
-import com.google.common.collect.ImmutableList.Builder;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -105,7 +105,7 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
 
         @Override
         public void onFullDefinitionDeclared(
-                final StmtContext.Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
+                final Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
             if (!augmentNode.isSupportedByFeatures()) {
                 return;
             }
@@ -211,16 +211,16 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
             final boolean skipCheckOfMandatoryNodes = YangVersion.VERSION_1_1.equals(sourceCtx.getRootVersion())
                     && isConditionalAugmentStmt(sourceCtx);
 
-            final Collection<StatementContextBase<?, ?, ?>> declared = sourceCtx.declaredSubstatements();
-            final Collection<StatementContextBase<?, ?, ?>> effective = sourceCtx.effectiveSubstatements();
-            final Collection<StatementContextBase<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+            final Collection<? extends Mutable<?, ?, ?>> declared = sourceCtx.mutableDeclaredSubstatements();
+            final Collection<? extends Mutable<?, ?, ?>> effective = sourceCtx.mutableEffectiveSubstatements();
+            final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
 
-            for (final StatementContextBase<?, ?, ?> originalStmtCtx : declared) {
+            for (final Mutable<?, ?, ?> originalStmtCtx : declared) {
                 if (originalStmtCtx.isSupportedByFeatures()) {
                     copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
                 }
             }
-            for (final StatementContextBase<?, ?, ?> originalStmtCtx : effective) {
+            for (final Mutable<?, ?, ?> originalStmtCtx : effective) {
                 copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
             }
 
@@ -242,13 +242,13 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                     && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
         }
 
-        private static void copyStatement(final StatementContextBase<?, ?, ?> original,
-                final StatementContextBase<?, ?, ?> target, final CopyType typeOfCopy,
-                final Collection<StatementContextBase<?, ?, ?>> buffer, final boolean skipCheckOfMandatoryNodes) {
+        private static void copyStatement(final Mutable<?, ?, ?> original, final StatementContextBase<?, ?, ?> target,
+                final CopyType typeOfCopy, final Collection<Mutable<?, ?, ?>> buffer,
+                final boolean skipCheckOfMandatoryNodes) {
             if (needToCopyByAugment(original)) {
                 validateNodeCanBeCopiedByAugment(original, target, typeOfCopy, skipCheckOfMandatoryNodes);
 
-                final StatementContextBase<?, ?, ?> copy = original.createCopy(target, typeOfCopy);
+                final Mutable<?, ?, ?> copy = original.createCopy(target, typeOfCopy);
                 buffer.add(copy);
             } else if (isReusedByAugment(original)) {
                 buffer.add(original);
@@ -268,10 +268,11 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement<SchemaNodeId
                 checkForMandatoryNodes(sourceCtx);
             }
 
-            final List<StatementContextBase<?, ?, ?>> targetSubStatements = new Builder<StatementContextBase<?, ?, ?>>()
-                    .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
+            final List<Mutable<?, ?, ?>> targetSubStatements = ImmutableList.<Mutable<?, ?, ?>>builder()
+                    .addAll(targetCtx.mutableDeclaredSubstatements()).addAll(targetCtx.mutableEffectiveSubstatements())
+                    .build();
 
-            for (final StatementContextBase<?, ?, ?> subStatement : targetSubStatements) {
+            for (final Mutable<?, ?, ?> subStatement : targetSubStatements) {
                 final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
                         .getPublicDefinition().getDeclaredRepresentationClass());
                 final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(subStatement

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java
index 2a1a9dd85f630e2a899f6264c34f6fcd36b4be3d..1cee5d7cdf82613ecf21b2cd78c3c51946fd41cf 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/DeviateStatementImpl.java
@@ -35,6 +35,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Infere
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.Prerequisite;
 import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
 import org.opendaylight.yangtools.yang.parser.spi.source.ModulesDeviatedByModules;
@@ -124,7 +125,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
         }
 
         @Override
-        public void onFullDefinitionDeclared(final StmtContext.Mutable<DeviateKind, DeviateStatement,
+        public void onFullDefinitionDeclared(final Mutable<DeviateKind, DeviateStatement,
                 EffectiveStatement<DeviateKind, DeviateStatement>> deviateStmtCtx) {
             final DeviateKind deviateKind = deviateStmtCtx.getStatementArgument();
             getSubstatementValidatorForDeviate(deviateKind).validate(deviateStmtCtx);
@@ -143,7 +144,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
                     DeviateStatement>>> sourceCtxPrerequisite =
                     deviateAction.requiresCtx(deviateStmtCtx, ModelProcessingPhase.EFFECTIVE_MODEL);
 
-            final Prerequisite<StmtContext.Mutable<?, ?, EffectiveStatement<?, ?>>> targetCtxPrerequisite =
+            final Prerequisite<Mutable<?, ?, EffectiveStatement<?, ?>>> targetCtxPrerequisite =
                     deviateAction.mutatesEffectiveCtx(deviateStmtCtx.getRoot(),
                         SchemaNodeIdentifierBuildNamespace.class,  deviationTarget);
 
@@ -179,7 +180,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
             });
         }
 
-        private static boolean isDeviationSupported(final StmtContext.Mutable<DeviateKind, DeviateStatement,
+        private static boolean isDeviationSupported(final Mutable<DeviateKind, DeviateStatement,
                 EffectiveStatement<DeviateKind, DeviateStatement>> deviateStmtCtx,
                 final SchemaNodeIdentifier deviationTarget) {
             final Map<QNameModule, Set<QNameModule>> modulesDeviatedByModules = deviateStmtCtx.getFromNamespace(
@@ -202,13 +203,13 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
 
         private static void performDeviateAdd(final StatementContextBase<?, ?, ?> deviateStmtCtx,
                 final StatementContextBase<?, ?, ?> targetCtx) {
-            for (StatementContextBase<?, ?, ?> originalStmtCtx : deviateStmtCtx.declaredSubstatements()) {
+            for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
                 validateDeviationTarget(originalStmtCtx, targetCtx);
                 addStatement(originalStmtCtx, targetCtx);
             }
         }
 
-        private static void addStatement(final StatementContextBase<?, ?, ?> stmtCtxToBeAdded,
+        private static void addStatement(final Mutable<?, ?, ?> stmtCtxToBeAdded,
                 final StatementContextBase<?, ?, ?> targetCtx) {
             if (StmtContextUtils.isUnknownStatement(stmtCtxToBeAdded)) {
                 targetCtx.addEffectiveSubstatement(stmtCtxToBeAdded.createCopy(targetCtx, CopyType.ORIGINAL));
@@ -219,10 +220,10 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
 
             if (SINGLETON_STATEMENTS.contains(stmtToBeAdded) || YangStmtMapping.DEFAULT.equals(stmtToBeAdded)
                     && YangStmtMapping.LEAF.equals(targetCtx.getPublicDefinition())) {
-                final Iterable<StatementContextBase<?, ?, ?>> targetCtxSubstatements = Iterables.concat(
+                final Iterable<StmtContext<?, ?, ?>> targetCtxSubstatements = Iterables.concat(
                         targetCtx.declaredSubstatements(), targetCtx.effectiveSubstatements());
 
-                for (final StatementContextBase<?, ?, ?> targetCtxSubstatement : targetCtxSubstatements) {
+                for (final StmtContext<?, ?, ?> targetCtxSubstatement : targetCtxSubstatements) {
                     InferenceException.throwIf(stmtToBeAdded.equals(targetCtxSubstatement.getPublicDefinition()),
                             stmtCtxToBeAdded.getStatementSourceReference(), "Deviation cannot add substatement %s " +
                             "to target node %s because it is already defined in target and can appear only once.",
@@ -235,13 +236,13 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
 
         private static void performDeviateReplace(final StatementContextBase<?, ?, ?> deviateStmtCtx,
                 final StatementContextBase<?, ?, ?> targetCtx) {
-            for (StatementContextBase<?, ?, ?> originalStmtCtx : deviateStmtCtx.declaredSubstatements()) {
+            for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
                 validateDeviationTarget(originalStmtCtx, targetCtx);
                 replaceStatement(originalStmtCtx, targetCtx);
             }
         }
 
-        private static void replaceStatement(final StatementContextBase<?, ?, ?> stmtCtxToBeReplaced,
+        private static void replaceStatement(final Mutable<?, ?, ?> stmtCtxToBeReplaced,
                 final StatementContextBase<?, ?, ?> targetCtx) {
             final StatementDefinition stmtToBeReplaced = stmtCtxToBeReplaced.getPublicDefinition();
 
@@ -253,7 +254,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
                 return;
             }
 
-            for (final StatementContextBase<?, ?, ?> targetCtxSubstatement : targetCtx.effectiveSubstatements()) {
+            for (final StmtContext<?, ?, ?> targetCtxSubstatement : targetCtx.effectiveSubstatements()) {
                 if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) {
                     targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeReplaced);
                     targetCtx.addEffectiveSubstatement(stmtCtxToBeReplaced.createCopy(targetCtx, CopyType.ORIGINAL));
@@ -261,7 +262,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
                 }
             }
 
-            for (final StatementContextBase<?, ?, ?> targetCtxSubstatement : targetCtx.declaredSubstatements()) {
+            for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) {
                 if (stmtToBeReplaced.equals(targetCtxSubstatement.getPublicDefinition())) {
                     targetCtxSubstatement.setIsSupportedToBuildEffective(false);
                     targetCtx.addEffectiveSubstatement(stmtCtxToBeReplaced.createCopy(targetCtx, CopyType.ORIGINAL));
@@ -276,7 +277,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
 
         private static void performDeviateDelete(final StatementContextBase<?, ?, ?> deviateStmtCtx,
                 final StatementContextBase<?, ?, ?> targetCtx) {
-            for (StatementContextBase<?, ?, ?> originalStmtCtx : deviateStmtCtx.declaredSubstatements()) {
+            for (Mutable<?, ?, ?> originalStmtCtx : deviateStmtCtx.mutableDeclaredSubstatements()) {
                 validateDeviationTarget(originalStmtCtx, targetCtx);
                 deleteStatement(originalStmtCtx, targetCtx);
             }
@@ -287,7 +288,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
             final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.getPublicDefinition();
             final String stmtArgument = stmtCtxToBeDeleted.rawStatementArgument();
 
-            for (final StatementContextBase<?, ?, ?> targetCtxSubstatement : targetCtx.effectiveSubstatements()) {
+            for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableEffectiveSubstatements()) {
                 if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
                         targetCtxSubstatement.rawStatementArgument())) {
                     targetCtx.removeStatementFromEffectiveSubstatements(stmtToBeDeleted, stmtArgument);
@@ -295,7 +296,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement<DeviateKind>
                 }
             }
 
-            for (final StatementContextBase<?, ?, ?> targetCtxSubstatement : targetCtx.declaredSubstatements()) {
+            for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) {
                 if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
                         targetCtxSubstatement.rawStatementArgument())) {
                     targetCtxSubstatement.setIsSupportedToBuildEffective(false);

diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
index 283e72d97fe7bb901a3a1e10835660d4c4e23566..fa0372278854b748b7c03bbdea5514fbc85b7e7a 100644 (file)
--- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
+++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/rfc6020/UsesStatementImpl.java
@@ -50,7 +50,6 @@ import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.UsesEffecti
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-
 public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implements UsesStatement {
     private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
             .USES)
@@ -83,7 +82,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
 
         @Override
         public void onFullDefinitionDeclared(
-                final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
+                final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
             if (!usesNode.isSupportedByFeatures()) {
                 return;
             }
@@ -202,18 +201,18 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
     private static void copyFromSourceToTarget(final Mutable<?, ?, ?> sourceGrpStmtCtx,
             final StatementContextBase<?, ?, ?> targetCtx,
             final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
-        final Collection<StatementContextBase<?, ?, ?>> declared = sourceGrpStmtCtx.declaredSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> effective = sourceGrpStmtCtx.effectiveSubstatements();
-        final Collection<StatementContextBase<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+        final Collection<? extends Mutable<?, ?, ?>> declared = sourceGrpStmtCtx.mutableDeclaredSubstatements();
+        final Collection<? extends Mutable<?, ?, ?>> effective = sourceGrpStmtCtx.mutableEffectiveSubstatements();
+        final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
         final QNameModule newQNameModule = getNewQNameModule(targetCtx, sourceGrpStmtCtx);
 
-        for (final StatementContextBase<?, ?, ?> original : declared) {
+        for (final Mutable<?, ?, ?> original : declared) {
             if (original.isSupportedByFeatures()) {
                 copyStatement(original, targetCtx, newQNameModule, buffer);
             }
         }
 
-        for (final StatementContextBase<?, ?, ?> original : effective) {
+        for (final Mutable<?, ?, ?> original : effective) {
             copyStatement(original, targetCtx, newQNameModule, buffer);
         }
 
@@ -221,12 +220,11 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
         usesNode.addAsEffectOfStatement(buffer);
     }
 
-    private static void copyStatement(final StatementContextBase<?, ?, ?> original,
+    private static void copyStatement(final Mutable<?, ?, ?> original,
             final StatementContextBase<?, ?, ?> targetCtx, final QNameModule targetModule,
-            final Collection<StatementContextBase<?, ?, ?>> buffer) {
+            final Collection<Mutable<?, ?, ?>> buffer) {
         if (needToCopyByUses(original)) {
-            final StatementContextBase<?, ?, ?> copy = original.createCopy(targetModule, targetCtx,
-                    CopyType.ADDED_BY_USES);
+            final Mutable<?, ?, ?> copy = original.createCopy(targetModule, targetCtx, CopyType.ADDED_BY_USES);
             buffer.add(copy);
         } else if (isReusedByUsesOnTop(original)) {
             buffer.add(original);
@@ -267,7 +265,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
     public static void resolveUsesNode(
             final Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode,
             final StatementContextBase<?, ?, ?> targetNodeStmtCtx) {
-        for (final StatementContextBase<?, ?, ?> subStmtCtx : usesNode.declaredSubstatements()) {
+        for (final Mutable<?, ?, ?> subStmtCtx : usesNode.mutableDeclaredSubstatements()) {
             if (StmtContextUtils.producesDeclared(subStmtCtx, RefineStatement.class)
                     && areFeaturesSupported(subStmtCtx)) {
                 performRefine(subStmtCtx, targetNodeStmtCtx);
@@ -282,44 +280,44 @@ public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implemen
         return !YangVersion.VERSION_1_1.equals(subStmtCtx.getRootVersion()) || subStmtCtx.isSupportedByFeatures();
     }
 
-    private static void performRefine(final StatementContextBase<?, ?, ?> refineCtx,
+    private static void performRefine(final Mutable<?, ?, ?> subStmtCtx,
             final StatementContextBase<?, ?, ?> usesParentCtx) {
 
-        final Object refineArgument = refineCtx.getStatementArgument();
+        final Object refineArgument = subStmtCtx.getStatementArgument();
         InferenceException.throwIf(!(refineArgument instanceof SchemaNodeIdentifier),
-            refineCtx.getStatementSourceReference(),
+            subStmtCtx.getStatementSourceReference(),
             "Invalid refine argument %s. It must be instance of SchemaNodeIdentifier.", refineArgument);
 
         final SchemaNodeIdentifier refineTargetNodeIdentifier = (SchemaNodeIdentifier) refineArgument;
         final StatementContextBase<?, ?, ?> refineTargetNodeCtx = Utils.findNode(usesParentCtx,
                 refineTargetNodeIdentifier);
 
-        InferenceException.throwIfNull(refineTargetNodeCtx, refineCtx.getStatementSourceReference(),
+        InferenceException.throwIfNull(refineTargetNodeCtx, subStmtCtx.getStatementSourceReference(),
             "Refine target node %s not found.", refineTargetNodeIdentifier);
 
         if (StmtContextUtils.isUnknownStatement(refineTargetNodeCtx)) {
             LOG.debug(
                     "Refine node '{}' in uses '{}' has target node unknown statement '{}'. Refine has been skipped. At line: {}",
-                    refineCtx.getStatementArgument(), refineCtx.getParentContext().getStatementArgument(),
-                    refineTargetNodeCtx.getStatementArgument(), refineCtx.getStatementSourceReference());
-            refineCtx.addAsEffectOfStatement(refineTargetNodeCtx);
+                    subStmtCtx.getStatementArgument(), subStmtCtx.getParentContext().getStatementArgument(),
+                    refineTargetNodeCtx.getStatementArgument(), subStmtCtx.getStatementSourceReference());
+            subStmtCtx.addAsEffectOfStatement(refineTargetNodeCtx);
             return;
         }
 
-        addOrReplaceNodes(refineCtx, refineTargetNodeCtx);
-        refineCtx.addAsEffectOfStatement(refineTargetNodeCtx);
+        addOrReplaceNodes(subStmtCtx, refineTargetNodeCtx);
+        subStmtCtx.addAsEffectOfStatement(refineTargetNodeCtx);
     }
 
-    private static void addOrReplaceNodes(final StatementContextBase<?, ?, ?> refineCtx,
+    private static void addOrReplaceNodes(final Mutable<?, ?, ?> subStmtCtx,
             final StatementContextBase<?, ?, ?> refineTargetNodeCtx) {
-        for (final StatementContextBase<?, ?, ?> refineSubstatementCtx : refineCtx.declaredSubstatements()) {
+        for (final Mutable<?, ?, ?> refineSubstatementCtx : subStmtCtx.mutableDeclaredSubstatements()) {
             if (isSupportedRefineSubstatement(refineSubstatementCtx)) {
                 addOrReplaceNode(refineSubstatementCtx, refineTargetNodeCtx);
             }
         }
     }
 
-    private static void addOrReplaceNode(final StatementContextBase<?, ?, ?> refineSubstatementCtx,
+    private static void addOrReplaceNode(final Mutable<?, ?, ?> refineSubstatementCtx,
             final StatementContextBase<?, ?, ?> refineTargetNodeCtx) {
 
         final StatementDefinition refineSubstatementDef = refineSubstatementCtx.getPublicDefinition();