From 735f3c1d9c2243eac0976e0db7af9d62a4e88f98 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Sat, 25 Jan 2020 12:43:44 +0100 Subject: [PATCH] Extract AbstractResumedStatement Separate out data structures related to statement source traversal into a dedicated class. This lowers the footprint required to implement StatementContextBase, as well as lowering clutter around which functionality is related to which part. JIRA: YANGTOOLS-652 Change-Id: I811c6fcf3bfba83421609af13dfed8fe445184b9 Signed-off-by: Robert Varga (cherry picked from commit d3425a5bdd83c76d186d59f711d3c41cd24c1fee) --- .../reactor/AbstractResumedStatement.java | 143 ++++++++++++++++++ .../stmt/reactor/RootStatementContext.java | 7 +- .../stmt/reactor/SourceSpecificContext.java | 8 +- .../stmt/reactor/StatementContextBase.java | 134 +++++----------- .../stmt/reactor/StatementContextWriter.java | 20 ++- .../parser/stmt/reactor/StatementMap.java | 42 ++--- .../stmt/reactor/SubstatementContext.java | 12 +- .../stmt/action/ActionStatementSupport.java | 9 +- .../stmt/rpc/AbstractRpcStatementSupport.java | 5 +- 9 files changed, 239 insertions(+), 141 deletions(-) create mode 100644 yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java new file mode 100644 index 0000000000..c3a62b8f88 --- /dev/null +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/AbstractResumedStatement.java @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.stmt.reactor; + +import static com.google.common.base.Preconditions.checkState; + +import java.util.Collection; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; +import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType; +import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase; +import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement; +import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; +import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter.ResumedStatement; + +/** + * Intermediate subclass of StatementContextBase facing the parser stream via implementation of ResumedStatement. This + * shields inference-type substatements from these details. + * + * @param Argument type + * @param Declared Statement representation + * @param Effective Statement representation + */ +abstract class AbstractResumedStatement, E extends EffectiveStatement> + extends StatementContextBase implements ResumedStatement { + private StatementMap substatements = StatementMap.empty(); + + AbstractResumedStatement(final StatementDefinitionContext def, final StatementSourceReference ref, + final String rawArgument) { + super(def, ref, rawArgument); + } + + AbstractResumedStatement(final StatementDefinitionContext def, final StatementSourceReference ref, + final String rawArgument, final CopyType copyType) { + super(def, ref, rawArgument, copyType); + } + + AbstractResumedStatement(final StatementContextBase original, final CopyType copyType) { + super(original, copyType); + } + + AbstractResumedStatement(final AbstractResumedStatement original) { + super(original); + this.substatements = original.substatements; + } + + @Override + public Collection> declaredSubstatements() { + return substatements.values(); + } + + @Override + public Collection> mutableDeclaredSubstatements() { + return substatements.values(); + } + + @Override + public @NonNull StatementDefinition getDefinition() { + return getPublicDefinition(); + } + + @Override + public @NonNull StatementSourceReference getSourceReference() { + return getStatementSourceReference(); + } + + @Override + public boolean isFullyDefined() { + return fullyDefined(); + } + + /** + * Create a new substatement at the specified offset. + * + * @param offset Substatement offset + * @param def definition context + * @param ref source reference + * @param argument statement argument + * @param new substatement argument type + * @param new substatement declared type + * @param new substatement effective type + * @return A new substatement + */ + @SuppressWarnings("checkstyle:methodTypeParameterName") + final , Z extends EffectiveStatement> + AbstractResumedStatement createSubstatement(final int offset, + final StatementDefinitionContext def, final StatementSourceReference ref, + final String argument) { + final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase(); + checkState(inProgressPhase != ModelProcessingPhase.EFFECTIVE_MODEL, + "Declared statement cannot be added in effective phase at: %s", getStatementSourceReference()); + + final Optional> implicitParent = + definition().getImplicitParentFor(def.getPublicView()); + if (implicitParent.isPresent()) { + return createImplicitParent(offset, implicitParent.get(), ref, argument).createSubstatement(offset, def, + ref, argument); + } + + final AbstractResumedStatement ret = new SubstatementContext<>(this, def, ref, argument); + substatements = substatements.put(offset, ret); + def.onStatementAdded(ret); + return ret; + } + + /** + * Lookup substatement by its offset in this statement. + * + * @param offset Substatement offset + * @return Substatement, or null if substatement does not exist. + */ + final AbstractResumedStatement lookupSubstatement(final int offset) { + return substatements.get(offset); + } + + final void resizeSubstatements(final int expectedSize) { + substatements = substatements.ensureCapacity(expectedSize); + } + + final void walkChildren(final ModelProcessingPhase phase) { + checkState(isFullyDefined()); + substatements.values().forEach(stmt -> { + stmt.walkChildren(phase); + stmt.endDeclared(phase); + }); + } + + private AbstractResumedStatement createImplicitParent(final int offset, + final StatementSupport implicitParent, final StatementSourceReference ref, final String argument) { + final StatementDefinitionContext def = new StatementDefinitionContext<>(implicitParent); + return createSubstatement(offset, def, ImplicitSubstatement.of(ref), argument); + } +} diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java index ab5b9f9348..e0c7cf2636 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/RootStatementContext.java @@ -41,7 +41,7 @@ import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReferenc * of this class, hence recursive lookups from them cross this class. */ public class RootStatementContext, E extends EffectiveStatement> extends - StatementContextBase { + AbstractResumedStatement { public static final YangVersion DEFAULT_VERSION = YangVersion.VERSION_1; @@ -256,4 +256,9 @@ public class RootStatementContext, E extends E protected boolean isParentSupportedByFeatures() { return true; } + + @Override + StatementContextBase reparent(final StatementContextBase newParent) { + throw new UnsupportedOperationException("Root statement cannot be reparented to" + newParent); + } } diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java index 43eb2332ae..f1d2652a26 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SourceSpecificContext.java @@ -101,14 +101,14 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh return inProgressPhase; } - Optional> lookupDeclaredChild(final StatementContextBase current, + Optional> lookupDeclaredChild(final AbstractResumedStatement current, final int childId) { if (current == null) { return Optional.empty(); } // Fast path: we are entering a statement which was emitted in previous phase - StatementContextBase existing = current.lookupSubstatement(childId); + AbstractResumedStatement existing = current.lookupSubstatement(childId); while (existing != null && StatementSource.CONTEXT == existing.getStatementSource()) { existing = existing.lookupSubstatement(childId); } @@ -116,8 +116,8 @@ public class SourceSpecificContext implements NamespaceStorageNode, NamespaceBeh return Optional.ofNullable(existing); } - StatementContextBase createDeclaredChild(final StatementContextBase current, final int childId, - final QName name, final String argument, final StatementSourceReference ref) { + AbstractResumedStatement createDeclaredChild(final AbstractResumedStatement current, + final int childId, final QName name, final String argument, final StatementSourceReference ref) { StatementDefinitionContext def = currentContext.getStatementDefinition(getRootVersion(), name); if (def == null) { def = currentContext.getModelDefinedStatementDefinition(name); diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java index cace674f04..a26cd97055 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextBase.java @@ -59,7 +59,6 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; import org.opendaylight.yangtools.yang.parser.spi.source.ImplicitSubstatement; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; -import org.opendaylight.yangtools.yang.parser.spi.source.StatementWriter.ResumedStatement; import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace; import org.opendaylight.yangtools.yang.parser.spi.source.SupportedFeaturesNamespace.SupportedFeatures; import org.opendaylight.yangtools.yang.parser.stmt.reactor.NamespaceBehaviourWithListeners.KeyedValueAddedListener; @@ -75,7 +74,7 @@ import org.slf4j.LoggerFactory; * @param Effective Statement representation */ public abstract class StatementContextBase, E extends EffectiveStatement> - extends NamespaceStorageSupport implements Mutable, ResumedStatement { + extends NamespaceStorageSupport implements Mutable { /** * Event listener when an item is added to model namespace. */ @@ -135,17 +134,20 @@ public abstract class StatementContextBase, E private Multimap phaseMutation = ImmutableMultimap.of(); private List> effective = ImmutableList.of(); private List> effectOfStatement = ImmutableList.of(); - private StatementMap substatements = StatementMap.empty(); private @Nullable ModelProcessingPhase completedPhase; private @Nullable D declaredInstance; private @Nullable E effectiveInstance; - // Common state bits + // Master flag controlling whether this context can yield an effective statement + // FIXME: investigate the mechanics that are being supported by this, as it would be beneficial if we can get rid + // of this flag -- eliminating the initial alignment shadow used by below gap-filler fields. private boolean isSupportedToBuildEffective = true; + + // Flag for use with AbstractResumedStatement. This is hiding in the alignment shadow created by above boolean private boolean fullyDefined; - // Flags for use with SubstatementContext. These are hiding in the alignment shadow created by above booleans and + // Flags for use with SubstatementContext. These are hiding in the alignment shadow created by above boolean and // hence improve memory layout. private byte flags; @@ -185,7 +187,6 @@ public abstract class StatementContextBase, E this.copyHistory = original.getCopyHistory(); this.originalCtx = original.getOriginalCtx().orElse(original); this.prevCopyCtx = original; - this.substatements = original.substatements; this.effective = original.effective; } @@ -307,14 +308,7 @@ public abstract class StatementContextBase, E } @Override - public Collection> declaredSubstatements() { - return substatements.values(); - } - - @Override - public Collection> mutableDeclaredSubstatements() { - return substatements.values(); - } + public abstract Collection> mutableDeclaredSubstatements(); @Override public Collection> effectiveSubstatements() { @@ -402,6 +396,19 @@ public abstract class StatementContextBase, E shrinkEffective(); } + // YANG example: RPC/action statements always have 'input' and 'output' defined + @Beta + public , Z extends EffectiveStatement> @NonNull Mutable + appendImplicitSubstatement(final StatementSupport support, final String rawArg) { + // FIXME: YANGTOOLS-652: This does not need to be a SubstatementContext, in can be a specialized + // StatementContextBase subclass. + final Mutable ret = new SubstatementContext<>(this, new StatementDefinitionContext<>(support), + ImplicitSubstatement.of(getStatementSourceReference()), rawArg); + support.onStatementAdded(ret); + addEffectiveSubstatement(ret); + return ret; + } + /** * Adds an effective statement to collection of substatements. * @@ -446,74 +453,14 @@ public abstract class StatementContextBase, E } } - /** - * Create a new substatement at the specified offset. - * - * @param offset Substatement offset - * @param def definition context - * @param ref source reference - * @param argument statement argument - * @param new substatement argument type - * @param new substatement declared type - * @param new substatement effective type - * @return A new substatement - */ - @SuppressWarnings("checkstyle:methodTypeParameterName") - public final , Z extends EffectiveStatement> - StatementContextBase createSubstatement(final int offset, - final StatementDefinitionContext def, final StatementSourceReference ref, - final String argument) { - final ModelProcessingPhase inProgressPhase = getRoot().getSourceContext().getInProgressPhase(); - checkState(inProgressPhase != ModelProcessingPhase.EFFECTIVE_MODEL, - "Declared statement cannot be added in effective phase at: %s", getStatementSourceReference()); - - final Optional> implicitParent = definition.getImplicitParentFor(def.getPublicView()); - if (implicitParent.isPresent()) { - return createImplicitParent(offset, implicitParent.get(), ref, argument).createSubstatement(offset, def, - ref, argument); - } - - final StatementContextBase ret = new SubstatementContext<>(this, def, ref, argument); - substatements = substatements.put(offset, ret); - def.onStatementAdded(ret); - return ret; - } - - private StatementContextBase createImplicitParent(final int offset, - final StatementSupport implicitParent, final StatementSourceReference ref, final String argument) { - final StatementDefinitionContext def = new StatementDefinitionContext<>(implicitParent); - return createSubstatement(offset, def, ImplicitSubstatement.of(ref), argument); - } - - public void appendImplicitStatement(final StatementSupport statementToAdd) { - createSubstatement(substatements.capacity(), new StatementDefinitionContext<>(statementToAdd), - ImplicitSubstatement.of(getStatementSourceReference()), null); - } - - /** - * Lookup substatement by its offset in this statement. - * - * @param offset Substatement offset - * @return Substatement, or null if substatement does not exist. - */ - final StatementContextBase lookupSubstatement(final int offset) { - return substatements.get(offset); + // Exists only due to memory optimization + final boolean fullyDefined() { + return fullyDefined; } + // Exists only due to memory optimization, should live in AbstractResumedStatement final void setFullyDefined() { - this.fullyDefined = true; - } - - final void resizeSubstatements(final int expectedSize) { - substatements = substatements.ensureCapacity(expectedSize); - } - - final void walkChildren(final ModelProcessingPhase phase) { - checkState(fullyDefined); - substatements.values().forEach(stmt -> { - stmt.walkChildren(phase); - stmt.endDeclared(phase); - }); + fullyDefined = true; } @Override @@ -566,7 +513,7 @@ public abstract class StatementContextBase, E } } - for (final StatementContextBase child : substatements.values()) { + for (final StatementContextBase child : mutableDeclaredSubstatements()) { finished &= child.tryToCompletePhase(phase); } for (final Mutable child : effective) { @@ -796,7 +743,7 @@ public abstract class StatementContextBase, E if (implicitParent.isPresent()) { final StatementDefinitionContext def = new StatementDefinitionContext<>(implicitParent.get()); - result = new SubstatementContext(this, def, original.getSourceReference(), + result = new SubstatementContext(this, def, original.getStatementSourceReference(), original.rawStatementArgument(), original.getStatementArgument(), type); final CopyType childCopyType; @@ -824,21 +771,6 @@ public abstract class StatementContextBase, E return result; } - @Override - public @NonNull StatementDefinition getDefinition() { - return getPublicDefinition(); - } - - @Override - public @NonNull StatementSourceReference getSourceReference() { - return getStatementSourceReference(); - } - - @Override - public boolean isFullyDefined() { - return fullyDefined; - } - @Beta public final boolean hasImplicitParentSupport() { return definition.getFactory() instanceof ImplicitParentAwareStatementSupport; @@ -858,11 +790,13 @@ public abstract class StatementContextBase, E original.getStatementSourceReference(), original.rawStatementArgument(), original.getStatementArgument(), type); - result.addEffectiveSubstatement(new SubstatementContext<>(original, result)); + result.addEffectiveSubstatement(original.reparent(result)); result.setCompletedPhase(original.getCompletedPhase()); return result; } + abstract StatementContextBase reparent(StatementContextBase newParent); + /** * Config statements are not all that common which means we are performing a recursive search towards the root * every time {@link #isConfiguration()} is invoked. This is quite expensive because it causes a linear search @@ -954,14 +888,14 @@ public abstract class StatementContextBase, E final void copyTo(final StatementContextBase target, final CopyType typeOfCopy, @Nullable final QNameModule targetModule) { - final Collection> buffer = new ArrayList<>(substatements.size() + effective.size()); + final Collection> declared = mutableDeclaredSubstatements(); + final Collection> buffer = new ArrayList<>(declared.size() + effective.size()); - for (final Mutable stmtContext : substatements.values()) { + for (final Mutable stmtContext : declared) { if (stmtContext.isSupportedByFeatures()) { copySubstatement(stmtContext, target, typeOfCopy, targetModule, buffer); } } - for (final Mutable stmtContext : effective) { copySubstatement(stmtContext, target, typeOfCopy, targetModule, buffer); } diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java index 34e27ea8b5..27bd70f2c6 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementContextWriter.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.yang.parser.stmt.reactor; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; +import static com.google.common.base.Verify.verify; import static com.google.common.base.Verify.verifyNotNull; import static java.util.Objects.requireNonNull; @@ -23,7 +24,7 @@ final class StatementContextWriter implements StatementWriter { private final ModelProcessingPhase phase; private final SourceSpecificContext ctx; - private StatementContextBase current; + private AbstractResumedStatement current; StatementContextWriter(final SourceSpecificContext ctx, final ModelProcessingPhase phase) { this.ctx = requireNonNull(ctx); @@ -32,12 +33,12 @@ final class StatementContextWriter implements StatementWriter { @Override public Optional resumeStatement(final int childId) { - final Optional> existing = ctx.lookupDeclaredChild(current, childId); + final Optional> existing = ctx.lookupDeclaredChild(current, childId); existing.ifPresent(this::resumeStatement); return existing; } - private void resumeStatement(final StatementContextBase child) { + private void resumeStatement(final AbstractResumedStatement child) { if (child.isFullyDefined()) { child.walkChildren(phase); child.endDeclared(phase); @@ -60,7 +61,7 @@ final class StatementContextWriter implements StatementWriter { @Override public void startStatement(final int childId, final QName name, final String argument, final StatementSourceReference ref) { - final Optional> existing = ctx.lookupDeclaredChild(current, childId); + final Optional> existing = ctx.lookupDeclaredChild(current, childId); current = existing.isPresent() ? existing.get() : verifyNotNull(ctx.createDeclaredChild(current, childId, name, argument, ref)); } @@ -78,11 +79,20 @@ final class StatementContextWriter implements StatementWriter { } private void exitStatement() { + // TODO: AbstractResumedStatement should only ever have AbstractResumedStatement parents, which would: + // - remove the StatementSource check + // - allow endDeclared() to be moved to AbstractResumedStatement + // - remove the need for verify() StatementContextBase parentContext = current.getParentContext(); while (parentContext != null && StatementSource.CONTEXT == parentContext.getStatementSource()) { parentContext.endDeclared(phase); parentContext = parentContext.getParentContext(); } - current = parentContext; + if (parentContext != null) { + verify(parentContext instanceof AbstractResumedStatement, "Unexpected parent context %s", parentContext); + current = (AbstractResumedStatement) parentContext; + } else { + current = null; + } } } diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java index a901cdce4b..e50c618fac 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/StatementMap.java @@ -30,17 +30,17 @@ import org.eclipse.jdt.annotation.Nullable; abstract class StatementMap { private static final class Empty extends StatementMap { @Override - StatementContextBase get(final int index) { + AbstractResumedStatement get(final int index) { return null; } @Override - StatementMap put(final int index, final StatementContextBase obj) { + StatementMap put(final int index, final AbstractResumedStatement obj) { return index == 0 ? new Singleton(obj) : new Regular(index, obj); } @Override - Collection> values() { + Collection> values() { return ImmutableList.of(); } @@ -61,37 +61,37 @@ abstract class StatementMap { } private static final class Regular extends StatementMap { - private StatementContextBase[] elements; + private AbstractResumedStatement[] elements; private int size; Regular(final int expectedLimit) { - elements = new StatementContextBase[expectedLimit]; + elements = new AbstractResumedStatement[expectedLimit]; } - Regular(final int index, final StatementContextBase object) { + Regular(final int index, final AbstractResumedStatement object) { this(index + 1, index, object); } - Regular(final StatementContextBase object0, final int index, - final StatementContextBase object) { + Regular(final AbstractResumedStatement object0, final int index, + final AbstractResumedStatement object) { this(index + 1, 0, object0); elements[index] = requireNonNull(object); size = 2; } - Regular(final int expectedLimit, final int index, final StatementContextBase object) { + Regular(final int expectedLimit, final int index, final AbstractResumedStatement object) { this(expectedLimit); elements[index] = requireNonNull(object); size = 1; } @Override - StatementContextBase get(final int index) { + AbstractResumedStatement get(final int index) { return index >= elements.length ? null : elements[index]; } @Override - StatementMap put(final int index, final StatementContextBase obj) { + StatementMap put(final int index, final AbstractResumedStatement obj) { if (index < elements.length) { checkArgument(elements[index] == null); } else { @@ -105,7 +105,7 @@ abstract class StatementMap { } @Override - Collection> values() { + Collection> values() { return new RegularAsCollection<>(elements, size); } @@ -148,7 +148,7 @@ abstract class StatementMap { @Override public Iterator iterator() { - return new AbstractIterator() { + return new AbstractIterator<>() { private int nextOffset = 0; @Override @@ -172,25 +172,25 @@ abstract class StatementMap { } private static final class Singleton extends StatementMap { - private final StatementContextBase object; + private final AbstractResumedStatement object; - Singleton(final StatementContextBase object) { + Singleton(final AbstractResumedStatement object) { this.object = requireNonNull(object); } @Override - StatementContextBase get(final int index) { + AbstractResumedStatement get(final int index) { return index == 0 ? object : null; } @Override - StatementMap put(final int index, final StatementContextBase obj) { + StatementMap put(final int index, final AbstractResumedStatement obj) { checkArgument(index != 0); return new Regular(this.object, index, obj); } @Override - Collection> values() { + Collection> values() { return ImmutableList.of(object); } @@ -222,7 +222,7 @@ abstract class StatementMap { * @param index Element index, must be non-negative * @return Requested element or null if there is no element at that index */ - abstract @Nullable StatementContextBase get(int index); + abstract @Nullable AbstractResumedStatement get(int index); /** * Add a statement at specified index. @@ -232,7 +232,7 @@ abstract class StatementMap { * @return New statement map * @throws IllegalArgumentException if the index is already occupied */ - abstract @NonNull StatementMap put(int index, @NonNull StatementContextBase obj); + abstract @NonNull StatementMap put(int index, @NonNull AbstractResumedStatement obj); /** * Return a read-only view of the elements in this map. Unlike other maps, this view does not detect concurrent @@ -241,7 +241,7 @@ abstract class StatementMap { * * @return Read-only view of available statements. */ - abstract @NonNull Collection> values(); + abstract @NonNull Collection> values(); abstract int size(); diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java index 205fb36fdb..ea4fa1b91e 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/SubstatementContext.java @@ -33,7 +33,7 @@ import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; final class SubstatementContext, E extends EffectiveStatement> extends - StatementContextBase { + AbstractResumedStatement { private final StatementContextBase parent; private final A argument; @@ -61,10 +61,11 @@ final class SubstatementContext, E extends Eff : original.definition().adaptArgumentValue(original, targetModule); } - SubstatementContext(final StatementContextBase original, final StatementContextBase parent) { + private SubstatementContext(final SubstatementContext original, + final StatementContextBase parent) { super(original); this.parent = requireNonNull(parent, "Parent must not be null"); - this.argument = original.getStatementArgument(); + this.argument = original.argument; } @Override @@ -196,4 +197,9 @@ final class SubstatementContext, E extends Eff protected boolean isParentSupportedByFeatures() { return parent.isSupportedByFeatures(); } + + @Override + SubstatementContext reparent(final StatementContextBase newParent) { + return new SubstatementContext<>(this, newParent); + } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionStatementSupport.java index d97b1b9ad5..1ec1fab284 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionStatementSupport.java @@ -91,11 +91,12 @@ public final class ActionStatementSupport super.onFullDefinitionDeclared(stmt); if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) { - ((StatementContextBase) stmt).appendImplicitStatement(InputStatementRFC7950Support.getInstance()); + ((StatementContextBase) stmt).appendImplicitSubstatement( + InputStatementRFC7950Support.getInstance(), null); } - if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) { - ((StatementContextBase) stmt).appendImplicitStatement(OutputStatementRFC7950Support.getInstance()); + ((StatementContextBase) stmt).appendImplicitSubstatement( + OutputStatementRFC7950Support.getInstance(), null); } } @@ -103,4 +104,4 @@ public final class ActionStatementSupport protected SubstatementValidator getSubstatementValidator() { return SUBSTATEMENT_VALIDATOR; } -} \ No newline at end of file +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/rpc/AbstractRpcStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/rpc/AbstractRpcStatementSupport.java index f6027b85de..fbcd14d265 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/rpc/AbstractRpcStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/rpc/AbstractRpcStatementSupport.java @@ -66,11 +66,10 @@ abstract class AbstractRpcStatementSupport super.onFullDefinitionDeclared(stmt); if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, InputStatement.class) == null) { - ((StatementContextBase) stmt).appendImplicitStatement(implictInput()); + ((StatementContextBase) stmt).appendImplicitSubstatement(implictInput(), null); } - if (StmtContextUtils.findFirstDeclaredSubstatement(stmt, OutputStatement.class) == null) { - ((StatementContextBase) stmt).appendImplicitStatement(implictOutput()); + ((StatementContextBase) stmt).appendImplicitSubstatement(implictOutput(), null); } } -- 2.36.6