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();
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
* @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.
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));
}
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();
@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;
}
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();
}
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();
}
* @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);
}
* @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;
}
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) {
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)) {
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;
@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;
}
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);
}
&& 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);
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
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;
}
@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);
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);
});
}
- 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(
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));
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.",
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();
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));
}
}
- 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));
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);
}
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);
}
}
- for (final StatementContextBase<?, ?, ?> targetCtxSubstatement : targetCtx.declaredSubstatements()) {
+ for (final Mutable<?, ?, ?> targetCtxSubstatement : targetCtx.mutableDeclaredSubstatements()) {
if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
targetCtxSubstatement.rawStatementArgument())) {
targetCtxSubstatement.setIsSupportedToBuildEffective(false);
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)
@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;
}
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);
}
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);
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);
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();