From 12880a5876c644243ba46ce8c674f29a7d0c773a Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Thu, 8 Jun 2017 00:51:21 +0200 Subject: [PATCH] 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 --- .../yang/parser/spi/meta/StmtContext.java | 23 ++++------ .../stmt/reactor/RootStatementContext.java | 8 ++-- .../stmt/reactor/StatementContextBase.java | 37 +++++++++------ .../stmt/reactor/SubstatementContext.java | 17 ++++--- .../stmt/rfc6020/AugmentStatementImpl.java | 29 ++++++------ .../stmt/rfc6020/DeviateStatementImpl.java | 29 ++++++------ .../stmt/rfc6020/UsesStatementImpl.java | 46 +++++++++---------- 7 files changed, 98 insertions(+), 91 deletions(-) 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 b26b1d6349..d174b97543 100644 --- 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, E extends Effect Collection> getEffectOfStatement(); - StatementContextBase createCopy(StatementContextBase newParent, CopyType typeOfCopy); + Mutable createCopy(StatementContextBase newParent, CopyType typeOfCopy); - StatementContextBase createCopy(QNameModule newQNameModule, StatementContextBase newParent, + Mutable createCopy(QNameModule newQNameModule, StatementContextBase newParent, CopyType typeOfCopy); CopyHistory getCopyHistory(); @@ -142,23 +142,20 @@ public interface StmtContext, E extends Effect extends StmtContext { @Override - StmtContext.Mutable getParentContext(); + Mutable getParentContext(); - > void addToNs( - Class type, KT key, VT value) - throws NamespaceNotAvailableException; + > void addToNs(Class type, KT key, + VT value) throws NamespaceNotAvailableException; @Nonnull @Override - StmtContext.Mutable getRoot(); + Mutable getRoot(); - @Override @Nonnull - Collection> declaredSubstatements(); + Collection> mutableDeclaredSubstatements(); - @Override @Nonnull - Collection> effectiveSubstatements(); + Collection> mutableEffectiveSubstatements(); /** * Create a new inference action to be executed during specified phase. The action cannot be cancelled @@ -180,8 +177,8 @@ public interface StmtContext, E extends Effect * @param stmt * to be added to namespace map */ - > void addContext( - Class namespace, KT key, StmtContext stmt); + > void addContext(Class 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 a86e7ecb2c..7bb341e73c 100644 --- 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, E extends E sourceContext = Preconditions.checkNotNull(original.sourceContext); this.argument = original.argument; - final Collection> declared = original.declaredSubstatements(); - final Collection> effective = original.effectiveSubstatements(); - final Collection> buffer = new ArrayList<>(declared.size() + effective.size()); + final Collection> declared = original.mutableDeclaredSubstatements(); + final Collection> effective = original.mutableEffectiveSubstatements(); + final Collection> 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 eaf8aeb909..423a0cabb9 100644 --- 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, E private Multimap phaseListeners = ImmutableMultimap.of(); private Multimap phaseMutation = ImmutableMultimap.of(); - private Collection> effective = ImmutableList.of(); + private Collection> effective = ImmutableList.of(); private Collection> effectOfStatement = ImmutableList.of(); private StatementMap substatements = StatementMap.empty(); @@ -237,13 +237,24 @@ public abstract class StatementContextBase, E @Nonnull @Override - public Collection> declaredSubstatements() { + public Collection> declaredSubstatements() { return substatements.values(); } @Nonnull @Override - public Collection> effectiveSubstatements() { + public Collection> mutableDeclaredSubstatements() { + return substatements.values(); + } + + @Override + public Collection> effectiveSubstatements() { + return mutableEffectiveSubstatements(); + } + + @Nonnull + @Override + public Collection> mutableEffectiveSubstatements() { if (effective instanceof ImmutableCollection) { return effective; } @@ -269,9 +280,9 @@ public abstract class StatementContextBase, E return; } - final Iterator> iterator = effective.iterator(); + final Iterator> 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, E return; } - final Iterator> iterator = effective.iterator(); + final Iterator> 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, 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, E * @throws NullPointerException * if statement parameter is null */ - public void addEffectiveSubstatements(final Collection> substatements) { + public void addEffectiveSubstatements(final Collection> substatements) { if (substatements.isEmpty()) { return; } @@ -450,8 +459,10 @@ public abstract class StatementContextBase, 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 3380a1e216..2710f0802a 100644 --- 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, E extends Eff private void copyStatements(final SubstatementContext original, final QNameModule newQNameModule, final CopyType typeOfCopy) { - final Collection> declared = original.declaredSubstatements(); - final Collection> effective = original.effectiveSubstatements(); - final Collection> buffer = new ArrayList<>(declared.size() + effective.size()); + final Collection> declared = original.mutableDeclaredSubstatements(); + final Collection> effective = original.mutableEffectiveSubstatements(); + final Collection> 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> buffer) { + private void copySubstatement(final Mutable stmtContext, final QNameModule newQNameModule, + final CopyType typeOfCopy, final Collection> 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 7822c05c4c..e99dd91b0d 100644 --- 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> augmentNode) { + final Mutable> augmentNode) { if (!augmentNode.isSupportedByFeatures()) { return; } @@ -211,16 +211,16 @@ public class AugmentStatementImpl extends AbstractDeclaredStatement> declared = sourceCtx.declaredSubstatements(); - final Collection> effective = sourceCtx.effectiveSubstatements(); - final Collection> buffer = new ArrayList<>(declared.size() + effective.size()); + final Collection> declared = sourceCtx.mutableDeclaredSubstatements(); + final Collection> effective = sourceCtx.mutableEffectiveSubstatements(); + final Collection> 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 original, - final StatementContextBase target, final CopyType typeOfCopy, - final Collection> buffer, final boolean skipCheckOfMandatoryNodes) { + private static void copyStatement(final Mutable original, final StatementContextBase target, + final CopyType typeOfCopy, final Collection> 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> targetSubStatements = new Builder>() - .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build(); + final List> targetSubStatements = ImmutableList.>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 2a1a9dd85f..1cee5d7cdf 100644 --- 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 } @Override - public void onFullDefinitionDeclared(final StmtContext.Mutable> deviateStmtCtx) { final DeviateKind deviateKind = deviateStmtCtx.getStatementArgument(); getSubstatementValidatorForDeviate(deviateKind).validate(deviateStmtCtx); @@ -143,7 +144,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement DeviateStatement>>> sourceCtxPrerequisite = deviateAction.requiresCtx(deviateStmtCtx, ModelProcessingPhase.EFFECTIVE_MODEL); - final Prerequisite>> targetCtxPrerequisite = + final Prerequisite>> targetCtxPrerequisite = deviateAction.mutatesEffectiveCtx(deviateStmtCtx.getRoot(), SchemaNodeIdentifierBuildNamespace.class, deviationTarget); @@ -179,7 +180,7 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement }); } - private static boolean isDeviationSupported(final StmtContext.Mutable> deviateStmtCtx, final SchemaNodeIdentifier deviationTarget) { final Map> modulesDeviatedByModules = deviateStmtCtx.getFromNamespace( @@ -202,13 +203,13 @@ public class DeviateStatementImpl extends AbstractDeclaredStatement 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 if (SINGLETON_STATEMENTS.contains(stmtToBeAdded) || YangStmtMapping.DEFAULT.equals(stmtToBeAdded) && YangStmtMapping.LEAF.equals(targetCtx.getPublicDefinition())) { - final Iterable> targetCtxSubstatements = Iterables.concat( + final Iterable> 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 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 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 } } - 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 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 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 } } - 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 283e72d97f..fa03722788 100644 --- 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 implements UsesStatement { private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping .USES) @@ -83,7 +82,7 @@ public class UsesStatementImpl extends AbstractDeclaredStatement implemen @Override public void onFullDefinitionDeclared( - final StmtContext.Mutable> usesNode) { + final Mutable> usesNode) { if (!usesNode.isSupportedByFeatures()) { return; } @@ -202,18 +201,18 @@ public class UsesStatementImpl extends AbstractDeclaredStatement implemen private static void copyFromSourceToTarget(final Mutable sourceGrpStmtCtx, final StatementContextBase targetCtx, final StmtContext.Mutable> usesNode) { - final Collection> declared = sourceGrpStmtCtx.declaredSubstatements(); - final Collection> effective = sourceGrpStmtCtx.effectiveSubstatements(); - final Collection> buffer = new ArrayList<>(declared.size() + effective.size()); + final Collection> declared = sourceGrpStmtCtx.mutableDeclaredSubstatements(); + final Collection> effective = sourceGrpStmtCtx.mutableEffectiveSubstatements(); + final Collection> 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 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> buffer) { + final Collection> 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 implemen public static void resolveUsesNode( final Mutable> 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 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(); -- 2.36.6