From 1dec11bcd187ebb6605f87338e9b96d57a91af41 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Tue, 26 Jan 2021 23:45:01 +0100 Subject: [PATCH] Allow derived context to be reused Passing the previously-built instance is a boon, as we can skip re-creation of schema/data tree namespaces and instread just share the maps. As a matter of establishing a baseline the following statements are also converted: - action - case - container - nofitication - input - output Other statements will be updated in follow-up patches. JIRA: YANGTOOLS-1213 Change-Id: Ic969fdf32932716ad18761f4da47ec41c3d07f2c Signed-off-by: Robert Varga --- .../reactor/InferredStatementContext.java | 11 +++--- .../AbstractDeclaredEffectiveStatement.java | 34 +++++++++++++++++++ .../AbstractUndeclaredEffectiveStatement.java | 19 +++++++++++ .../stmt/BaseImplicitStatementSupport.java | 17 ++++++++++ ...aseOperationContainerStatementSupport.java | 20 +++++++++++ .../stmt/EffectiveStatementMixins.java | 3 +- .../action/ActionEffectiveStatementImpl.java | 6 ++++ .../stmt/action/ActionStatementSupport.java | 7 ++++ .../stmt/case_/CaseStatementSupport.java | 19 +++++++++-- .../case_/DeclaredCaseEffectiveStatement.java | 8 +++++ .../UndeclaredCaseEffectiveStatement.java | 8 +++++ .../ContainerEffectiveStatementImpl.java | 8 +++++ .../container/ContainerStatementSupport.java | 33 ++++++++++++------ .../ModelDefinedStatementSupport.java | 8 ++--- .../DeclaredInputEffectiveStatement.java | 7 ++++ .../stmt/input/InputStatementSupport.java | 14 ++++++++ .../UndeclaredInputEffectiveStatement.java | 7 ++++ .../AbstractNotificationStatementSupport.java | 8 +++++ .../NotificationEffectiveStatementImpl.java | 7 ++++ .../DeclaredOutputEffectiveStatement.java | 7 ++++ .../stmt/output/OutputStatementSupport.java | 14 ++++++++ .../UndeclaredOutputEffectiveStatement.java | 7 ++++ .../spi/meta/AbstractStatementSupport.java | 17 +++++----- .../spi/meta/ForwardingStatementSupport.java | 6 ++-- .../parser/spi/meta/StatementFactory.java | 9 +++-- 25 files changed, 260 insertions(+), 44 deletions(-) diff --git a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java index f99a46b03f..2ef267c091 100644 --- a/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java +++ b/yang/yang-parser-reactor/src/main/java/org/opendaylight/yangtools/yang/parser/stmt/reactor/InferredStatementContext.java @@ -224,7 +224,7 @@ final class InferredStatementContext, E extend // First check if we can reuse the entire prototype if (!factory.canReuseCurrent(this, prototype, origSubstatements)) { - return tryToReuseSubstatements(factory, origSubstatements); + return tryToReuseSubstatements(factory, origEffective); } // No substatements to deal with, we can freely reuse the original @@ -269,22 +269,21 @@ final class InferredStatementContext, E extend return factory.createEffective(this, declared.stream(), effective.stream()); } - private @NonNull E tryToReuseSubstatements(final StatementFactory factory, - final @NonNull Collection> origSubstatements) { + private @NonNull E tryToReuseSubstatements(final StatementFactory factory, final @NonNull E original) { if (allSubstatementsContextIndependent()) { LOG.debug("Reusing substatements of: {}", prototype); // FIXME: can we skip this if !haveRef()? substatements = reusePrototypeReplicas(); prototype.decRef(); - return factory.createEffective(this, origSubstatements); + return factory.copyEffective(this, original); } // Fall back to full instantiation, which populates our substatements. Then check if we should be reusing // the substatement list, as this operation turned out to not affect them. final E effective = super.createEffective(factory); - if (sameSubstatements(origSubstatements, effective)) { + if (sameSubstatements(original.effectiveSubstatements(), effective)) { LOG.debug("Reusing unchanged substatements of: {}", prototype); - return factory.createEffective(this, origSubstatements); + return factory.copyEffective(this, original); } return effective; } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java index b081d983ab..dcf3d843fd 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveStatement.java @@ -125,6 +125,10 @@ public abstract class AbstractDeclaredEffectiveStatement original) { + this.declared = original.declared; + } + @Override public final D getDeclared() { return declared; @@ -193,6 +197,11 @@ public abstract class AbstractDeclaredEffectiveStatement original) { + super(original); + this.substatements = original.substatements; + } + @Override public final ImmutableList> effectiveSubstatements() { return unmaskList(substatements); @@ -203,6 +212,10 @@ public abstract class AbstractDeclaredEffectiveStatement original) { + super(original); + } + @Override public final A argument() { return getDeclared().argument(); @@ -265,6 +278,11 @@ public abstract class AbstractDeclaredEffectiveStatement original) { + super(original); + this.substatements = original.substatements; + } + @Override public final ImmutableList> effectiveSubstatements() { return unmaskList(substatements); @@ -280,6 +298,11 @@ public abstract class AbstractDeclaredEffectiveStatement original) { + this.declared = original.declared; + this.schemaTree = original.schemaTree; + } + @Override public final D getDeclared() { return declared; @@ -311,6 +334,11 @@ public abstract class AbstractDeclaredEffectiveStatement original) { + super(original); + this.substatements = original.substatements; + } + @Override public final ImmutableList> effectiveSubstatements() { return unmaskList(substatements); @@ -329,6 +357,12 @@ public abstract class AbstractDeclaredEffectiveStatement original) { + this.declared = original.declared; + this.schemaTree = original.schemaTree; + this.dataTree = original.dataTree; + } + @Override public final D getDeclared() { return declared; diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java index 842cbd2c4f..3fc7a798ae 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java @@ -116,6 +116,11 @@ public abstract class AbstractUndeclaredEffectiveStatement original) { + super(original); + this.substatements = original.substatements; + } + @Override public final ImmutableList> effectiveSubstatements() { return unmaskList(substatements); @@ -128,6 +133,10 @@ public abstract class AbstractUndeclaredEffectiveStatement original) { + this.schemaTree = original.schemaTree; + } + @Override protected final Map> schemaTreeNamespace() { return schemaTree; @@ -153,6 +162,11 @@ public abstract class AbstractUndeclaredEffectiveStatement original) { + super(original); + this.substatements = original.substatements; + } + @Override public final ImmutableList> effectiveSubstatements() { return unmaskList(substatements); @@ -168,6 +182,11 @@ public abstract class AbstractUndeclaredEffectiveStatement original) { + this.schemaTree = original.schemaTree; + this.dataTree = original.dataTree; + } + @Override protected final Map> schemaTreeNamespace() { return schemaTree; diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseImplicitStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseImplicitStatementSupport.java index 34d9bce923..9410bd93bf 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseImplicitStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseImplicitStatementSupport.java @@ -33,6 +33,19 @@ public abstract class BaseImplicitStatementSupport stmt, final E original) { + final StatementSource source = stmt.source(); + switch (source) { + case CONTEXT: + return copyUndeclaredEffective(stmt, original); + case DECLARATION: + return copyDeclaredEffective(stmt, original); + default: + throw new IllegalStateException("Unhandled statement source " + source); + } + } + @Override protected E createEffective(final Current stmt, final ImmutableList> substatements) { @@ -47,6 +60,10 @@ public abstract class BaseImplicitStatementSupport stmt, @NonNull E original); + + protected abstract @NonNull E copyUndeclaredEffective(@NonNull Current stmt, @NonNull E original); + protected abstract @NonNull E createDeclaredEffective(@NonNull Current stmt, @NonNull ImmutableList> substatements); diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java index e5d0027189..498d311c9b 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java @@ -47,6 +47,26 @@ public abstract class BaseOperationContainerStatementSupport stmt, final E original) { + return copyDeclaredEffective( + EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()), + stmt, original); + } + + protected abstract @NonNull E copyDeclaredEffective(int flags, @NonNull Current stmt, + @NonNull E original); + + @Override + protected final @NonNull E copyUndeclaredEffective(final Current stmt, final E original) { + return copyUndeclaredEffective( + EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()), + stmt, original); + } + + protected abstract @NonNull E copyUndeclaredEffective(int flags, @NonNull Current stmt, + @NonNull E original); + @Override protected final @NonNull E createDeclaredEffective(final Current stmt, final ImmutableList> substatements) { diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java index 3eb78f0488..9182b2bb8f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/EffectiveStatementMixins.java @@ -11,7 +11,6 @@ import com.google.common.annotations.Beta; import com.google.common.base.MoreObjects; import com.google.common.base.Strings; import com.google.common.collect.Collections2; -import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import java.util.Collection; import java.util.Optional; @@ -576,7 +575,7 @@ public final class EffectiveStatementMixins { } public static int historyAndStatusFlags(final CopyHistory history, - final ImmutableList> substatements) { + final Collection> substatements) { return new FlagsBuilder() .setHistory(history) .setStatus(AbstractStatementSupport.findFirstArgument(substatements, diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionEffectiveStatementImpl.java index 7dd2702586..ddc44ad380 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionEffectiveStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/action/ActionEffectiveStatementImpl.java @@ -33,6 +33,12 @@ final class ActionEffectiveStatementImpl extends WithSubstatements stmt, + final ActionEffectiveStatement original) { + return new ActionEffectiveStatementImpl((ActionEffectiveStatementImpl) original, stmt.wrapSchemaPath(), + EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements())); + } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseStatementSupport.java index 3903e503ea..ee2b0ae293 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/CaseStatementSupport.java @@ -12,6 +12,7 @@ import static java.util.Objects.requireNonNull; import com.google.common.annotations.Beta; import com.google.common.collect.ImmutableList; import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; +import java.util.Collection; import java.util.Optional; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; @@ -117,6 +118,20 @@ public final class CaseStatementSupport } } + @Override + protected CaseEffectiveStatement copyDeclaredEffective(final Current stmt, + final CaseEffectiveStatement original) { + return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original, + computeFlags(stmt, original.effectiveSubstatements()), stmt.wrapSchemaPath(), findOriginal(stmt)); + } + + @Override + protected CaseEffectiveStatement copyUndeclaredEffective(final Current stmt, + final CaseEffectiveStatement original) { + return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original, + computeFlags(stmt, original.effectiveSubstatements()), stmt.wrapSchemaPath(), findOriginal(stmt)); + } + @Override protected CaseEffectiveStatement createDeclaredEffective(final Current stmt, final ImmutableList> substatements) { @@ -144,7 +159,7 @@ public final class CaseStatementSupport } private static int computeFlags(final Current stmt, - final ImmutableList> substatements) { + final Collection> substatements) { final Boolean config; final EffectiveConfig effective = stmt.effectiveConfig(); switch (effective) { @@ -174,7 +189,7 @@ public final class CaseStatementSupport @SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Internal use tagged with @Nullable") private static @Nullable Boolean substatementEffectiveConfig( - final ImmutableList> substatements) { + final Collection> substatements) { for (EffectiveStatement stmt : substatements) { if (stmt instanceof DataSchemaNode) { final Optional opt = ((DataSchemaNode) stmt).effectiveConfig(); diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/DeclaredCaseEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/DeclaredCaseEffectiveStatement.java index 65e18af5d9..4976a38dae 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/DeclaredCaseEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/case_/DeclaredCaseEffectiveStatement.java @@ -35,6 +35,14 @@ final class DeclaredCaseEffectiveStatement extends WithSubstatements> substatements, final int flags, final SchemaPath path, final ContainerSchemaNode original) { super(declared, substatements); + this.original = original; + this.flags = flags; this.path = path; + } + + ContainerEffectiveStatementImpl(final ContainerEffectiveStatementImpl origEffective, + final ContainerSchemaNode original, final int flags, final @Nullable SchemaPath path) { + super(origEffective); this.original = original; this.flags = flags; + this.path = path; } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerStatementSupport.java index 91a6cdbf5d..99e4294d52 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/container/ContainerStatementSupport.java @@ -11,10 +11,10 @@ import static java.util.Objects.requireNonNull; import com.google.common.annotations.Beta; import com.google.common.collect.ImmutableList; +import java.util.Collection; import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; import org.opendaylight.yangtools.yang.model.api.Status; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; @@ -114,23 +114,34 @@ public final class ContainerStatementSupport @Override protected ContainerEffectiveStatement createEffective(final Current stmt, final ImmutableList> substatements) { - final int flags = new FlagsBuilder() - .setHistory(stmt.history()) - .setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT)) - .setConfiguration(stmt.effectiveConfig().asNullable()) - .setPresence(findFirstStatement(substatements, PresenceEffectiveStatement.class) != null) - .toFlags(); - EffectiveStmtUtils.checkUniqueGroupings(stmt, substatements); EffectiveStmtUtils.checkUniqueTypedefs(stmt, substatements); EffectiveStmtUtils.checkUniqueUses(stmt, substatements); - final SchemaPath path = stmt.wrapSchemaPath(); try { - return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, flags, path, - (ContainerSchemaNode) stmt.original()); + return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, createFlags(stmt, substatements), + stmt.wrapSchemaPath(), (ContainerSchemaNode) stmt.original()); } catch (SubstatementIndexingException e) { throw new SourceException(e.getMessage(), stmt, e); } } + + @Override + public ContainerEffectiveStatement copyEffective(final Current stmt, + final ContainerEffectiveStatement original) { + return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original, + (ContainerSchemaNode) stmt.original(), createFlags(stmt, original.effectiveSubstatements()), + stmt.wrapSchemaPath()); + } + + private static int createFlags(final Current stmt, + final Collection> substatements) { + return new FlagsBuilder() + .setHistory(stmt.history()) + .setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT)) + .setConfiguration(stmt.effectiveConfig().asNullable()) + .setPresence(findFirstStatement(substatements, PresenceEffectiveStatement.class) != null) + .toFlags(); + } } + diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/ModelDefinedStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/ModelDefinedStatementSupport.java index 104f6a3f1d..8ac5148b0b 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/ModelDefinedStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/extension/ModelDefinedStatementSupport.java @@ -7,10 +7,8 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension; -import java.util.Collection; import java.util.Optional; import java.util.stream.Stream; -import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement; @@ -47,9 +45,9 @@ final class ModelDefinedStatementSupport } @Override - public UnrecognizedEffectiveStatement createEffective(final Current stmt, - final Collection> substatements) { - return definition.createEffective(stmt, substatements); + public UnrecognizedEffectiveStatement copyEffective(final Current stmt, + final UnrecognizedEffectiveStatement original) { + return definition.copyEffective(stmt, original); } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/DeclaredInputEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/DeclaredInputEffectiveStatement.java index a50542a208..cd11bcb306 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/DeclaredInputEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/DeclaredInputEffectiveStatement.java @@ -32,6 +32,13 @@ final class DeclaredInputEffectiveStatement extends WithSubstatements stmt, final InputEffectiveStatement original) { + return new DeclaredInputEffectiveStatement(flags, (DeclaredInputEffectiveStatement) original, + stmt.wrapSchemaPath()); + } + + @Override + protected InputEffectiveStatement copyUndeclaredEffective(final int flags, + final Current stmt, final InputEffectiveStatement original) { + return new UndeclaredInputEffectiveStatement(flags, (UndeclaredInputEffectiveStatement) original, + stmt.wrapSchemaPath()); + } + @Override protected InputEffectiveStatement createDeclaredEffective(final int flags, final Current stmt, diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/UndeclaredInputEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/UndeclaredInputEffectiveStatement.java index 2d19ee6005..85ecb79190 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/UndeclaredInputEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/UndeclaredInputEffectiveStatement.java @@ -33,6 +33,13 @@ final class UndeclaredInputEffectiveStatement this.flags = flags; } + UndeclaredInputEffectiveStatement(final int flags, final UndeclaredInputEffectiveStatement original, + final SchemaPath path) { + super(original); + this.path = path; + this.flags = flags; + } + @Override @Deprecated public SchemaPath getPath() { diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/AbstractNotificationStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/AbstractNotificationStatementSupport.java index dfe4a374c0..51ab5b62c2 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/AbstractNotificationStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/AbstractNotificationStatementSupport.java @@ -48,4 +48,12 @@ abstract class AbstractNotificationStatementSupport throw new SourceException(e.getMessage(), stmt, e); } } + + @Override + public final NotificationEffectiveStatement copyEffective(final Current stmt, + final NotificationEffectiveStatement original) { + return new NotificationEffectiveStatementImpl((NotificationEffectiveStatementImpl) original, + EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()), + stmt.wrapSchemaPath()); + } } \ No newline at end of file diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/NotificationEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/NotificationEffectiveStatementImpl.java index 3c93a07695..9e83524c9f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/NotificationEffectiveStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/notification/NotificationEffectiveStatementImpl.java @@ -38,8 +38,15 @@ final class NotificationEffectiveStatementImpl final ImmutableList> substatements, final int flags, final SchemaPath path) { super(declared, substatements); + this.flags = flags; this.path = path; + } + + NotificationEffectiveStatementImpl(final NotificationEffectiveStatementImpl original, final int flags, + final SchemaPath path) { + super(original); this.flags = flags; + this.path = path; } @Override diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/DeclaredOutputEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/DeclaredOutputEffectiveStatement.java index 5a3bfb7128..285c4e1927 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/DeclaredOutputEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/DeclaredOutputEffectiveStatement.java @@ -32,6 +32,13 @@ final class DeclaredOutputEffectiveStatement extends WithSubstatements stmt, final OutputEffectiveStatement original) { + return new DeclaredOutputEffectiveStatement(flags, (DeclaredOutputEffectiveStatement) original, + stmt.wrapSchemaPath()); + } + + @Override + protected OutputEffectiveStatement copyUndeclaredEffective(final int flags, + final Current stmt, final OutputEffectiveStatement original) { + return new UndeclaredOutputEffectiveStatement(flags, (UndeclaredOutputEffectiveStatement) original, + stmt.wrapSchemaPath()); + } + @Override protected OutputEffectiveStatement createDeclaredEffective(final int flags, final Current stmt, diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/UndeclaredOutputEffectiveStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/UndeclaredOutputEffectiveStatement.java index 8c4f8e79a0..8e4443ada3 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/UndeclaredOutputEffectiveStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/UndeclaredOutputEffectiveStatement.java @@ -29,8 +29,15 @@ final class UndeclaredOutputEffectiveStatement UndeclaredOutputEffectiveStatement(final int flags, final ImmutableList> substatements, final SchemaPath path) { super(substatements); + this.flags = flags; this.path = path; + } + + UndeclaredOutputEffectiveStatement(final int flags, final UndeclaredOutputEffectiveStatement original, + final SchemaPath path) { + super(original); this.flags = flags; + this.path = path; } @Override diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java index ba8b61fed5..acc2f2880b 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/AbstractStatementSupport.java @@ -61,16 +61,15 @@ public abstract class AbstractStatementSupport return createEffective(stmt, substatements); } - @Override - public final E createEffective(final Current stmt, - final Collection> substatements) { - // This copy should be a no-op - return createEffective(stmt, ImmutableList.copyOf(substatements)); - } - protected abstract @NonNull E createEffective(@NonNull Current stmt, @NonNull ImmutableList> substatements); + @Override + public E copyEffective(final Current stmt, final E original) { + // Most implementations are only interested in substatements. copyOf() here should be a no-op + return createEffective(stmt, ImmutableList.copyOf(original.effectiveSubstatements())); + } + /** * Give statement support a hook to transform statement contexts before they are built. Default implementation * does nothing, but note {@code augment} statement performs a real transformation. @@ -86,7 +85,7 @@ public abstract class AbstractStatementSupport // FIXME: add documentation public static final > @Nullable E findFirstStatement( - final ImmutableList> statements, final Class type) { + final Collection> statements, final Class type) { for (EffectiveStatement stmt : statements) { if (type.isInstance(stmt)) { return type.cast(stmt); @@ -97,7 +96,7 @@ public abstract class AbstractStatementSupport // FIXME: add documentation public static final > A findFirstArgument( - final ImmutableList> statements, final Class<@NonNull E> type, + final Collection> statements, final Class<@NonNull E> type, final A defValue) { final @Nullable E stmt = findFirstStatement(statements, type); return stmt != null ? stmt.argument() : defValue; diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java index 4dd0634cca..5e8d619bbf 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/ForwardingStatementSupport.java @@ -8,7 +8,6 @@ package org.opendaylight.yangtools.yang.parser.spi.meta; import com.google.common.annotations.Beta; -import java.util.Collection; import java.util.stream.Stream; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; @@ -48,9 +47,8 @@ public abstract class ForwardingStatementSupport stmt, - final Collection> substatements) { - return delegate.createEffective(stmt, substatements); + public E copyEffective(final Current stmt, final E original) { + return delegate.copyEffective(stmt, original); } @Override diff --git a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementFactory.java b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementFactory.java index 239644a158..279e933696 100644 --- a/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementFactory.java +++ b/yang/yang-parser-spi/src/main/java/org/opendaylight/yangtools/yang/parser/spi/meta/StatementFactory.java @@ -37,20 +37,19 @@ public interface StatementFactory, E extends E * @param stmt Effective capture of this statement's significant state * @return An effective statement instance */ - @NonNull E createEffective(EffectiveStmtCtx.@NonNull Current stmt, + @NonNull E createEffective(@NonNull Current stmt, Stream> declaredSubstatements, Stream> effectiveSubstatements); /** - * Create a {@link EffectiveStatement} for specified context and substatements. + * Create a {@link EffectiveStatement} copy of provided original for specified context. * * @param stmt Effective capture of this statement's significant state - * @param substatements Current effective substatements + * @param original Original effective statement * @return An effective statement instance * @throws NullPointerException if any argument is null */ - @NonNull E createEffective(EffectiveStmtCtx.@NonNull Current stmt, - @NonNull Collection> substatements); + @NonNull E copyEffective(@NonNull Current stmt, @NonNull E original); /** * Determine reactor copy behaviour of a statement instance. Implementations classes are required to determine -- 2.36.6