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>
Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement();
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();
CopyType typeOfCopy);
CopyHistory getCopyHistory();
extends StmtContext<A, D, E> {
@Override
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;
- StmtContext.Mutable<?, ?, ?> getRoot();
+ Mutable<?, ?, ?> getRoot();
- Collection<StatementContextBase<?, ?, ?>> declaredSubstatements();
+ Collection<? extends Mutable<?, ?, ?>> mutableDeclaredSubstatements();
- Collection<StatementContextBase<?, ?, ?>> effectiveSubstatements();
+ Collection<? extends Mutable<?, ?, ?>> mutableEffectiveSubstatements();
/**
* Create a new inference action to be executed during specified phase. The action cannot be cancelled
/**
* Create a new inference action to be executed during specified phase. The action cannot be cancelled
* @param stmt
* to be added to namespace map
*/
* @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.
/**
* Set version of root statement context.
sourceContext = Preconditions.checkNotNull(original.sourceContext);
this.argument = original.argument;
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));
}
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 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();
private Collection<StmtContext<?, ?, ?>> effectOfStatement = ImmutableList.of();
private StatementMap substatements = StatementMap.empty();
- public Collection<StatementContextBase<?, ?, ?>> declaredSubstatements() {
+ public Collection<? extends StmtContext<?, ?, ?>> declaredSubstatements() {
return substatements.values();
}
@Nonnull
@Override
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;
}
if (effective instanceof ImmutableCollection) {
return effective;
}
- final Iterator<StatementContextBase<?, ?, ?>> iterator = effective.iterator();
+ final Iterator<? extends StmtContext<?, ?, ?>> iterator = effective.iterator();
while (iterator.hasNext()) {
while (iterator.hasNext()) {
- final StatementContextBase<?, ?, ?> next = iterator.next();
+ final StmtContext<?, ?, ?> next = iterator.next();
if (statementDef.equals(next.getPublicDefinition())) {
iterator.remove();
}
if (statementDef.equals(next.getPublicDefinition())) {
iterator.remove();
}
- final Iterator<StatementContextBase<?, ?, ?>> iterator = effective.iterator();
+ final Iterator<Mutable<?, ?, ?>> iterator = effective.iterator();
while (iterator.hasNext()) {
while (iterator.hasNext()) {
- final StatementContextBase<?, ?, ?> next = iterator.next();
+ final Mutable<?, ?, ?> next = iterator.next();
if (statementDef.equals(next.getPublicDefinition()) && statementArg.equals(next.rawStatementArgument())) {
iterator.remove();
}
if (statementDef.equals(next.getPublicDefinition()) && statementArg.equals(next.rawStatementArgument())) {
iterator.remove();
}
* @throws NullPointerException
* if statement parameter is null
*/
* @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);
}
beforeAddEffectiveStatement(1);
effective.add(substatement);
}
* @throws NullPointerException
* if statement parameter is null
*/
* @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;
}
if (substatements.isEmpty()) {
return;
}
for (final StatementContextBase<?, ?, ?> child : substatements.values()) {
finished &= child.tryToCompletePhase(phase);
}
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);
+ }
private void copyStatements(final SubstatementContext<A, D, E> original, final QNameModule newQNameModule,
final CopyType typeOfCopy) {
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);
}
}
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);
}
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)) {
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)) {
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;
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;
import com.google.common.collect.ImmutableSet;
import java.util.ArrayList;
import java.util.Collection;
@Override
public void onFullDefinitionDeclared(
@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;
}
if (!augmentNode.isSupportedByFeatures()) {
return;
}
final boolean skipCheckOfMandatoryNodes = YangVersion.VERSION_1_1.equals(sourceCtx.getRootVersion())
&& isConditionalAugmentStmt(sourceCtx);
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);
}
}
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);
}
copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
}
&& StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
}
&& 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);
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);
buffer.add(copy);
} else if (isReusedByAugment(original)) {
buffer.add(original);
checkForMandatoryNodes(sourceCtx);
}
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
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.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;
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;
- 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);
EffectiveStatement<DeviateKind, DeviateStatement>> deviateStmtCtx) {
final DeviateKind deviateKind = deviateStmtCtx.getStatementArgument();
getSubstatementValidatorForDeviate(deviateKind).validate(deviateStmtCtx);
DeviateStatement>>> sourceCtxPrerequisite =
deviateAction.requiresCtx(deviateStmtCtx, ModelProcessingPhase.EFFECTIVE_MODEL);
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);
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(
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) {
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);
}
}
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));
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())) {
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());
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.",
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) {
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);
}
}
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();
final StatementContextBase<?, ?, ?> targetCtx) {
final StatementDefinition stmtToBeReplaced = stmtCtxToBeReplaced.getPublicDefinition();
- 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));
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));
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) {
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);
}
validateDeviationTarget(originalStmtCtx, targetCtx);
deleteStatement(originalStmtCtx, targetCtx);
}
final StatementDefinition stmtToBeDeleted = stmtCtxToBeDeleted.getPublicDefinition();
final String stmtArgument = stmtCtxToBeDeleted.rawStatementArgument();
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);
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);
if (statementsAreEqual(stmtToBeDeleted, stmtArgument, targetCtxSubstatement.getPublicDefinition(),
targetCtxSubstatement.rawStatementArgument())) {
targetCtxSubstatement.setIsSupportedToBuildEffective(false);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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)
public class UsesStatementImpl extends AbstractDeclaredStatement<QName> implements UsesStatement {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.USES)
@Override
public void onFullDefinitionDeclared(
@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;
}
if (!usesNode.isSupportedByFeatures()) {
return;
}
private static void copyFromSourceToTarget(final Mutable<?, ?, ?> sourceGrpStmtCtx,
final StatementContextBase<?, ?, ?> targetCtx,
final StmtContext.Mutable<QName, UsesStatement, EffectiveStatement<QName, UsesStatement>> usesNode) {
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);
final QNameModule newQNameModule = getNewQNameModule(targetCtx, sourceGrpStmtCtx);
- for (final StatementContextBase<?, ?, ?> original : declared) {
+ for (final Mutable<?, ?, ?> original : declared) {
if (original.isSupportedByFeatures()) {
copyStatement(original, targetCtx, newQNameModule, buffer);
}
}
if (original.isSupportedByFeatures()) {
copyStatement(original, targetCtx, newQNameModule, buffer);
}
}
- for (final StatementContextBase<?, ?, ?> original : effective) {
+ for (final Mutable<?, ?, ?> original : effective) {
copyStatement(original, targetCtx, newQNameModule, buffer);
}
copyStatement(original, targetCtx, newQNameModule, buffer);
}
usesNode.addAsEffectOfStatement(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 StatementContextBase<?, ?, ?> targetCtx, final QNameModule targetModule,
- final Collection<StatementContextBase<?, ?, ?>> buffer) {
+ final Collection<Mutable<?, ?, ?>> buffer) {
if (needToCopyByUses(original)) {
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);
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) {
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);
if (StmtContextUtils.producesDeclared(subStmtCtx, RefineStatement.class)
&& areFeaturesSupported(subStmtCtx)) {
performRefine(subStmtCtx, targetNodeStmtCtx);
return !YangVersion.VERSION_1_1.equals(subStmtCtx.getRootVersion()) || subStmtCtx.isSupportedByFeatures();
}
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 StatementContextBase<?, ?, ?> usesParentCtx) {
- final Object refineArgument = refineCtx.getStatementArgument();
+ final Object refineArgument = subStmtCtx.getStatementArgument();
InferenceException.throwIf(!(refineArgument instanceof SchemaNodeIdentifier),
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);
"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: {}",
"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);
- 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) {
final StatementContextBase<?, ?, ?> refineTargetNodeCtx) {
- for (final StatementContextBase<?, ?, ?> refineSubstatementCtx : refineCtx.declaredSubstatements()) {
+ for (final Mutable<?, ?, ?> refineSubstatementCtx : subStmtCtx.mutableDeclaredSubstatements()) {
if (isSupportedRefineSubstatement(refineSubstatementCtx)) {
addOrReplaceNode(refineSubstatementCtx, refineTargetNodeCtx);
}
}
}
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();
final StatementContextBase<?, ?, ?> refineTargetNodeCtx) {
final StatementDefinition refineSubstatementDef = refineSubstatementCtx.getPublicDefinition();