From 89b32412a608065d0b25345be410715e0a5e1434 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Fri, 3 Jul 2020 11:56:35 +0200 Subject: [PATCH] Refactor {Module,Submodule}EffectiveStatementImpl Modules and submodules are tied together via AbstractEffectiveModule, which holds on to old layout. While it is not directly harmful to these implementations, having statement creation outside of actual constructors is a long-term goal. Refactor AbstractEffectiveModule and thus both implementations to create substatements separately in BaseStatementSupport. The inlining of submodule statements is hooked into BaseStatementSupport lifecycle via buildEffectiveSubstatements(), so that modules can stop mucking with statement build rules and just pick up whatever was created for the corresponding submodule. For declared statements we introduce AbstractDeclaredEffectiveRootStatement as a replacement for AbstractRootStatement, which is now deprecated for removal. JIRA: YANGTOOLS-1065 Change-Id: I032bb1ea4f2ee5db87d9b0dbbdeb89f152bc4593 Signed-off-by: Robert Varga --- .../api/stmt/ModuleEffectiveStatement.java | 7 + .../yang/model/api/stmt/ModuleStatement.java | 7 + .../api/stmt/SubmoduleEffectiveStatement.java | 7 +- .../model/api/stmt/SubmoduleStatement.java | 7 + ...bstractDeclaredEffectiveRootStatement.java | 27 +++ .../stmt/AbstractDeclaredStatement.java | 6 + .../rfc7950/stmt/AbstractEffectiveModule.java | 21 +- .../rfc7950/stmt/AbstractRootStatement.java | 1 + .../rfc7950/stmt/BaseStatementSupport.java | 26 ++- .../AbstractModuleStatementSupport.java | 95 ++++++-- .../module/ModuleEffectiveStatementImpl.java | 22 +- .../stmt/module/ModuleStatementImpl.java | 13 +- .../stmt/module/ModuleStmtContext.java | 221 ------------------ .../AbstractSubmoduleStatementSupport.java | 47 ++-- .../SubmoduleEffectiveStatementImpl.java | 6 +- .../submodule/SubmoduleStatementImpl.java | 13 +- 16 files changed, 238 insertions(+), 288 deletions(-) create mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveRootStatement.java delete mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStmtContext.java diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleEffectiveStatement.java index bb6053b921..e13d3776b3 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleEffectiveStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleEffectiveStatement.java @@ -10,7 +10,9 @@ package org.opendaylight.yangtools.yang.model.api.stmt; import com.google.common.annotations.Beta; import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; /** * Effective view of a {@link ModuleStatement}. @@ -52,6 +54,11 @@ public interface ModuleEffectiveStatement extends DataTreeAwareEffectiveStatemen } } + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.MODULE; + } + /** * Get the local QNameModule of this module. All implementations need to override this default method. * diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleStatement.java index 693926fc6b..6a4aae3938 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/ModuleStatement.java @@ -11,9 +11,16 @@ import static com.google.common.base.Verify.verifyNotNull; import java.util.Optional; import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; public interface ModuleStatement extends MetaDeclaredStatement, ModuleHeaderGroup, LinkageDeclaredStatement, RevisionAwareDeclaredStatement, BodyDeclaredStatement { + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.MODULE; + } + default @NonNull String getName() { // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here return verifyNotNull(rawArgument()); diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleEffectiveStatement.java index 65993c39c4..24c7716aab 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleEffectiveStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleEffectiveStatement.java @@ -8,6 +8,8 @@ package org.opendaylight.yangtools.yang.model.api.stmt; import com.google.common.annotations.Beta; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; /** * Representation of {@code submodule} statement. Note that implementations of this interface are required to provide @@ -16,5 +18,8 @@ import com.google.common.annotations.Beta; */ @Beta public interface SubmoduleEffectiveStatement extends DataTreeAwareEffectiveStatement { - + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.SUBMODULE; + } } diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleStatement.java index 2e003dbdea..468ad24388 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/SubmoduleStatement.java @@ -12,9 +12,16 @@ import static com.google.common.base.Verify.verifyNotNull; import java.util.Optional; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; public interface SubmoduleStatement extends MetaDeclaredStatement, LinkageDeclaredStatement, RevisionAwareDeclaredStatement, BodyDeclaredStatement { + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.SUBMODULE; + } + default @NonNull String getName() { // FIXME: YANGTOOLS-908: verifyNotNull() should not be needed here return verifyNotNull(rawArgument()); diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveRootStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveRootStatement.java new file mode 100644 index 0000000000..60fb169cdd --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredEffectiveRootStatement.java @@ -0,0 +1,27 @@ +/* + * 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.rfc7950.stmt; + +import com.google.common.annotations.Beta; +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.BodyDeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.LinkageDeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.MetaDeclaredStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.RevisionAwareDeclaredStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument.WithSubstatements; + +@Beta +public abstract class AbstractDeclaredEffectiveRootStatement> + extends WithSubstatements implements LinkageDeclaredStatement, MetaDeclaredStatement, + RevisionAwareDeclaredStatement, BodyDeclaredStatement { + protected AbstractDeclaredEffectiveRootStatement(final String rawArgument, + final ImmutableList> substatements) { + super(rawArgument, substatements); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java index 8a713abe40..4e0a7bffbb 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractDeclaredStatement.java @@ -113,6 +113,12 @@ public abstract class AbstractDeclaredStatement extends AbstractModelStatemen this.substatements = maskList(substatements); } + protected WithSubstatements(final String rawArgument, + final ImmutableList> substatements) { + super(rawArgument); + this.substatements = maskList(substatements); + } + @Override public final Collection> declaredSubstatements() { return unmaskList(substatements); diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java index b5c519eb8d..376bf624ee 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveModule.java @@ -13,6 +13,7 @@ import static java.util.Objects.requireNonNull; import com.google.common.annotations.Beta; import com.google.common.base.MoreObjects; import com.google.common.collect.Collections2; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableMap.Builder; import com.google.common.collect.ImmutableSet; @@ -54,6 +55,8 @@ import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStateme import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.compat.NotificationNodeContainerCompat; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DocumentedNodeMixin; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils; import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx; @@ -61,19 +64,18 @@ import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; @Beta public abstract class AbstractEffectiveModule, - E extends DataTreeAwareEffectiveStatement> - extends AbstractEffectiveDocumentedNodeWithStatus - implements Module, NotificationNodeContainerCompat { + E extends DataTreeAwareEffectiveStatement> extends WithSubstatements + implements Module, DocumentedNodeMixin, NotificationNodeContainerCompat { private final String prefix; private final ImmutableSet groupings; private final ImmutableSet uses; private final ImmutableSet> typeDefinitions; private final ImmutableMap> schemaTreeNamespace; - protected AbstractEffectiveModule( - final @NonNull StmtContext> ctx, - final @NonNull String prefix) { - super(ctx); + protected AbstractEffectiveModule(final D declared, + final StmtContext> ctx, + final ImmutableList> substatements, final String prefix) { + super(declared, ctx, substatements); // This check is rather weird, but comes from our desire to lower memory footprint while providing both // EffectiveStatements and SchemaNode interfaces -- which do not overlap completely where child lookups are @@ -112,6 +114,11 @@ public abstract class AbstractEffectiveModule> extends AbstractDeclaredStatement implements LinkageDeclaredStatement, MetaDeclaredStatement, RevisionAwareDeclaredStatement, BodyDeclaredStatement { diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java index 941eb12d9e..3cab48caee 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java @@ -57,7 +57,7 @@ public abstract class BaseStatementSupport, public final E createEffective(final StmtContext ctx) { final D declared = ctx.buildDeclared(); final ImmutableList> substatements = - buildEffectiveSubstatements(statementsToBuild(ctx, declaredSubstatements(ctx))); + buildEffectiveSubstatements(ctx, statementsToBuild(ctx, declaredSubstatements(ctx))); return substatements.isEmpty() ? createEmptyEffective(ctx, declared) : createEffective(ctx, declared, substatements); } @@ -97,13 +97,24 @@ public abstract class BaseStatementSupport, } /** - * Create a set of substatements. This method is split out so it can be overridden in - * ExtensionEffectiveStatementImpl to leak a not-fully-initialized instance. + * Create a set of substatements. This method is split out so it can be overridden in subclasses adjust the + * resulting statements. * + * @param ctx Parent statement context * @param substatements proposed substatements - * @return Filtered substatements + * @return Built effective substatements */ - private static ImmutableList> buildEffectiveSubstatements( + protected ImmutableList> buildEffectiveSubstatements( + final StmtContext ctx, final List> substatements) { + return defaultBuildEffectiveSubstatements(substatements); + } + + static final ImmutableList> buildEffectiveSubstatements( + final StmtContext ctx) { + return defaultBuildEffectiveSubstatements(declaredSubstatements(ctx)); + } + + private static ImmutableList> defaultBuildEffectiveSubstatements( final List> substatements) { return substatements.stream() .filter(StmtContext::isSupportedToBuildEffective) @@ -111,11 +122,6 @@ public abstract class BaseStatementSupport, .collect(ImmutableList.toImmutableList()); } - static final ImmutableList> buildEffectiveSubstatements( - final StmtContext ctx) { - return buildEffectiveSubstatements(declaredSubstatements(ctx)); - } - static final @NonNull List> declaredSubstatements(final StmtContext ctx) { /* * This dance is required to ensure that effects of 'uses' nodes are applied in the same order as diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/AbstractModuleStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/AbstractModuleStatementSupport.java index 09d0ce8e67..bfeacc7b82 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/AbstractModuleStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/AbstractModuleStatementSupport.java @@ -7,14 +7,25 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module; +import static com.google.common.base.Verify.verify; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; +import com.google.common.collect.ImmutableList; import java.net.URI; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; import java.util.Optional; import org.opendaylight.yangtools.concepts.SemVer; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.common.Revision; +import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.ModuleEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement; import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement; @@ -22,10 +33,10 @@ import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement; import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace; import org.opendaylight.yangtools.yang.parser.spi.NamespaceToModule; import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; @@ -33,6 +44,7 @@ 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.ImpPrefixToNamespace; import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx; +import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToModuleCtx; import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName; import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToSourceIdentifier; import org.opendaylight.yangtools.yang.parser.spi.source.ModuleNameToModuleQName; @@ -43,7 +55,7 @@ import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule; import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; abstract class AbstractModuleStatementSupport - extends AbstractStatementSupport { + extends BaseStatementSupport { AbstractModuleStatementSupport() { super(YangStmtMapping.MODULE); } @@ -53,17 +65,6 @@ abstract class AbstractModuleStatementSupport return value; } - @Override - public final ModuleStatement createDeclared(final StmtContext ctx) { - return new ModuleStatementImpl(ctx); - } - - @Override - public final ModuleEffectiveStatement createEffective( - final StmtContext ctx) { - return new ModuleEffectiveStatementImpl(ctx); - } - @Override public final void onPreLinkageDeclared(final Mutable stmt) { final String moduleName = stmt.getStatementArgument(); @@ -127,6 +128,74 @@ abstract class AbstractModuleStatementSupport } } + @Override + protected final ImmutableList> buildEffectiveSubstatements( + final StmtContext ctx, + final List> substatements) { + final ImmutableList> local = + super.buildEffectiveSubstatements(ctx, substatements); + final Collection> submodules = submoduleContexts(ctx); + if (submodules.isEmpty()) { + return local; + } + + // Concatenate statements so they appear as if they were part of target module + final List> others = new ArrayList<>(); + for (StmtContext submoduleCtx : submodules) { + for (EffectiveStatement effective : submoduleCtx.buildEffective().effectiveSubstatements()) { + if (effective instanceof SchemaNode || effective instanceof DataNodeContainer) { + others.add(effective); + } + } + } + + return ImmutableList.>builderWithExpectedSize(local.size() + others.size()) + .addAll(local) + .addAll(others) + .build(); + } + + @Override + protected final ModuleStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new ModuleStatementImpl(ctx.coerceRawStatementArgument(), substatements); + } + + @Override + protected final ModuleStatement createEmptyDeclared(final StmtContext ctx) { + throw noNamespace(ctx); + } + + @Override + protected final ModuleEffectiveStatement createEffective( + final StmtContext ctx, + final ModuleStatement declared, final ImmutableList> substatements) { + final List submodules = new ArrayList<>(); + for (StmtContext submoduleCtx : submoduleContexts(ctx)) { + final EffectiveStatement submodule = submoduleCtx.buildEffective(); + verify(submodule instanceof Module, "Submodule statement %s is not a Module", submodule); + submodules.add((Module) submodule); + } + + return new ModuleEffectiveStatementImpl(ctx, declared, substatements, submodules); + } + + @Override + protected final ModuleEffectiveStatement createEmptyEffective( + final StmtContext ctx, final ModuleStatement declared) { + throw noNamespace(ctx); + } + + private static Collection> submoduleContexts(final StmtContext ctx) { + final Map> submodules = ctx.getAllFromCurrentStmtCtxNamespace( + IncludedSubmoduleNameToModuleCtx.class); + return submodules == null ? List.of() : submodules.values(); + } + + private static SourceException noNamespace(final StmtContext ctx) { + return new SourceException("No namespace declared in module", ctx.getStatementSourceReference()); + } + private static void addToSemVerModuleNamespace( final Mutable stmt, final SourceIdentifier moduleIdentifier) { diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleEffectiveStatementImpl.java index d6a9a16081..26a73b4e64 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleEffectiveStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleEffectiveStatementImpl.java @@ -9,10 +9,11 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module; import static com.google.common.base.Verify.verifyNotNull; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableMap.Builder; -import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; +import java.util.Collection; import java.util.Map; import java.util.Map.Entry; import java.util.Optional; @@ -20,6 +21,7 @@ import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ExtensionEffectiveStatementNamespace; @@ -51,13 +53,15 @@ final class ModuleEffectiveStatementImpl extends AbstractEffectiveModule prefixToModule; private final ImmutableMap namespaceToPrefix; private final @NonNull QNameModule qnameModule; - private final ImmutableSet submodules; + private final ImmutableList submodules; - private ModuleEffectiveStatementImpl(final @NonNull ModuleStmtContext ctx) { - super(ctx, findPrefix(ctx.delegate(), "module", ctx.getStatementArgument())); - submodules = ctx.getSubmodules(); + ModuleEffectiveStatementImpl(final StmtContext ctx, + final ModuleStatement declared, final ImmutableList> substatements, + final Collection submodules) { + super(declared, ctx, substatements, findPrefix(ctx, "module", ctx.getStatementArgument())); - qnameModule = verifyNotNull(ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.delegate())); + qnameModule = verifyNotNull(ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx)); + this.submodules = ImmutableList.copyOf(submodules); final String localPrefix = findFirstEffectiveSubstatementArgument(PrefixEffectiveStatement.class).get(); final Builder prefixToModuleBuilder = ImmutableMap.builder(); @@ -92,10 +96,6 @@ final class ModuleEffectiveStatementImpl extends AbstractEffectiveModule ctx) { - this(ModuleStmtContext.create(ctx)); - } - @Override public @NonNull QNameModule localQNameModule() { return qnameModule; @@ -107,7 +107,7 @@ final class ModuleEffectiveStatementImpl extends AbstractEffectiveModule getSubmodules() { + public Collection getSubmodules() { return submodules; } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStatementImpl.java index e358e6b019..fab4de6aef 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStatementImpl.java @@ -7,12 +7,15 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.module; +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractRootStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveRootStatement; -final class ModuleStatementImpl extends AbstractRootStatement implements ModuleStatement { - ModuleStatementImpl(final StmtContext context) { - super(context); +final class ModuleStatementImpl extends AbstractDeclaredEffectiveRootStatement + implements ModuleStatement { + ModuleStatementImpl(final String rawArgument, + final ImmutableList> substatements) { + super(rawArgument, substatements); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStmtContext.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStmtContext.java deleted file mode 100644 index d5e7e14d13..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/module/ModuleStmtContext.java +++ /dev/null @@ -1,221 +0,0 @@ -/* - * Copyright (c) 2019 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.rfc7950.stmt.module; - -import static com.google.common.base.Verify.verify; -import static java.util.Objects.requireNonNull; - -import com.google.common.collect.ForwardingObject; -import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableSet; -import java.util.ArrayList; -import java.util.Collection; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import org.eclipse.jdt.annotation.NonNull; -import org.eclipse.jdt.annotation.Nullable; -import org.opendaylight.yangtools.yang.common.YangVersion; -import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; -import org.opendaylight.yangtools.yang.model.api.Module; -import org.opendaylight.yangtools.yang.model.api.SchemaNode; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; -import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace; -import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; -import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; -import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory; -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.source.IncludedSubmoduleNameToModuleCtx; -import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; - -/** - * A concentrator {@link StmtContext}, which makes it appear as though as all effective statements in submodules - * are included in it. - */ -final class ModuleStmtContext extends ForwardingObject - implements StmtContext { - - private final @NonNull StmtContext delegate; - private final @NonNull ImmutableList> effectiveSubstatements; - private final @NonNull ImmutableSet submodules; - - private ModuleStmtContext(final StmtContext delegate, - final Collection> submodules) { - this.delegate = requireNonNull(delegate); - - final List> statements = new ArrayList<>(delegate.effectiveSubstatements()); - final Set subs = new LinkedHashSet<>(submodules.size()); - for (StmtContext submoduleCtx : submodules) { - final EffectiveStatement submodule = submoduleCtx.buildEffective(); - verify(submodule instanceof Module, "Submodule statement %s is not a Module", submodule); - subs.add((Module) submodule); - - for (StmtContext stmt : submoduleCtx.allSubstatements()) { - if (stmt.isSupportedByFeatures()) { - final EffectiveStatement effective = stmt.buildEffective(); - if (effective instanceof SchemaNode || effective instanceof DataNodeContainer) { - statements.add(stmt); - } - } - } - } - - this.effectiveSubstatements = ImmutableList.copyOf(statements); - this.submodules = ImmutableSet.copyOf(subs); - } - - static @NonNull ModuleStmtContext create( - final StmtContext delegate) { - final Map> includedSubmodules = delegate.getAllFromCurrentStmtCtxNamespace( - IncludedSubmoduleNameToModuleCtx.class); - return new ModuleStmtContext(delegate, includedSubmodules == null || includedSubmodules.isEmpty() - ? ImmutableList.of() : includedSubmodules.values()); - } - - @Override - protected @NonNull StmtContext delegate() { - return delegate; - } - - ImmutableSet getSubmodules() { - return submodules; - } - - @Override - public ImmutableList> effectiveSubstatements() { - return effectiveSubstatements; - } - - @Override - public ModuleEffectiveStatement buildEffective() { - throw new UnsupportedOperationException("Attempted to instantiate proxy context " + this); - } - - @Override - public ModuleStatement buildDeclared() { - return delegate.buildDeclared(); - } - - @Override - public StatementSource getStatementSource() { - return delegate.getStatementSource(); - } - - @Override - public StatementSourceReference getStatementSourceReference() { - return delegate.getStatementSourceReference(); - } - - @Override - public StatementDefinition getPublicDefinition() { - return delegate.getPublicDefinition(); - } - - @Override - public StmtContext getParentContext() { - return delegate.getParentContext(); - } - - @Override - public String rawStatementArgument() { - return delegate.rawStatementArgument(); - } - - @Override - public @Nullable String getStatementArgument() { - return delegate.getStatementArgument(); - } - - @Override - public @NonNull Optional getSchemaPath() { - return delegate.getSchemaPath(); - } - - @Override - public boolean isConfiguration() { - return delegate.isConfiguration(); - } - - @Override - public boolean isEnabledSemanticVersioning() { - return delegate.isEnabledSemanticVersioning(); - } - - @Override - public > V getFromNamespace(final Class type, - final T key) { - return delegate.getFromNamespace(type, key); - } - - @Override - public > Map getAllFromNamespace(final Class type) { - return delegate.getAllFromNamespace(type); - } - - @Override - public > Map getAllFromCurrentStmtCtxNamespace( - final Class type) { - return delegate.getAllFromCurrentStmtCtxNamespace(type); - } - - @Override - public StmtContext getRoot() { - return delegate.getRoot(); - } - - @Override - public Collection> declaredSubstatements() { - return delegate.declaredSubstatements(); - } - - @Override - public boolean isSupportedToBuildEffective() { - return delegate.isSupportedToBuildEffective(); - } - - @Override - public boolean isSupportedByFeatures() { - return delegate.isSupportedByFeatures(); - } - - @Override - public Collection> getEffectOfStatement() { - return delegate.getEffectOfStatement(); - } - - @Override - public CopyHistory getCopyHistory() { - return delegate.getCopyHistory(); - } - - @Override - public Optional> getOriginalCtx() { - return delegate.getOriginalCtx(); - } - - @Override - public Optional> getPreviousCopyCtx() { - return delegate.getPreviousCopyCtx(); - } - - @Override - public ModelProcessingPhase getCompletedPhase() { - return delegate.getCompletedPhase(); - } - - @Override - public @NonNull YangVersion getRootVersion() { - return delegate.getRootVersion(); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/AbstractSubmoduleStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/AbstractSubmoduleStatementSupport.java index db6523f8a2..849ba95852 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/AbstractSubmoduleStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/AbstractSubmoduleStatementSupport.java @@ -10,15 +10,18 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.findFirstDeclaredSubstatement; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; +import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +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.stmt.BelongsToStatement; import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement; import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport; import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport; 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; @@ -26,7 +29,7 @@ import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModule import org.opendaylight.yangtools.yang.parser.spi.source.SourceException; abstract class AbstractSubmoduleStatementSupport - extends AbstractStatementSupport { + extends BaseStatementSupport { AbstractSubmoduleStatementSupport() { super(YangStmtMapping.SUBMODULE); } @@ -36,17 +39,6 @@ abstract class AbstractSubmoduleStatementSupport return value; } - @Override - public final SubmoduleStatement createDeclared(final StmtContext ctx) { - return new SubmoduleStatementImpl(ctx); - } - - @Override - public final SubmoduleEffectiveStatement createEffective( - final StmtContext ctx) { - return new SubmoduleEffectiveStatementImpl(ctx); - } - @Override public final void onPreLinkageDeclared( final Mutable stmt) { @@ -78,4 +70,33 @@ abstract class AbstractSubmoduleStatementSupport stmt.addToNs(BelongsToPrefixToModuleName.class, prefix, belongsToModuleName); } + + @Override + protected final SubmoduleStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new SubmoduleStatementImpl(ctx.coerceRawStatementArgument(), substatements); + } + + @Override + protected final SubmoduleStatement createEmptyDeclared(final StmtContext ctx) { + throw noBelongsTo(ctx); + } + + @Override + protected final SubmoduleEffectiveStatement createEffective( + final StmtContext ctx, + final SubmoduleStatement declared, final ImmutableList> substatements) { + return new SubmoduleEffectiveStatementImpl(ctx, declared, substatements); + } + + @Override + protected final SubmoduleEffectiveStatement createEmptyEffective( + final StmtContext ctx, + final SubmoduleStatement declared) { + throw noBelongsTo(ctx); + } + + private static SourceException noBelongsTo(final StmtContext ctx) { + return new SourceException("No belongs-to declared in submodule", ctx.getStatementSourceReference()); + } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java index dcdd68bd7c..473ae8ba82 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleEffectiveStatementImpl.java @@ -10,6 +10,7 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule; import static com.google.common.base.Preconditions.checkState; import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableMap.Builder; import com.google.common.collect.ImmutableSet; @@ -53,8 +54,9 @@ final class SubmoduleEffectiveStatementImpl private ImmutableSet submodules; private boolean sealed; - SubmoduleEffectiveStatementImpl(final StmtContext ctx) { - super(ctx, findSubmodulePrefix(ctx)); + SubmoduleEffectiveStatementImpl(final StmtContext ctx, + final SubmoduleStatement declared, final ImmutableList> substatements) { + super(declared, ctx, substatements, findSubmodulePrefix(ctx)); final String belongsToModuleName = firstAttributeOf(ctx.declaredSubstatements(), BelongsToStatement.class); final QNameModule belongsToModuleQName = ctx.getFromNamespace(ModuleNameToModuleQName.class, diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleStatementImpl.java index 514f57c41c..4aa5a0ef29 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/submodule/SubmoduleStatementImpl.java @@ -7,12 +7,15 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.submodule; +import com.google.common.collect.ImmutableList; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractRootStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveRootStatement; -final class SubmoduleStatementImpl extends AbstractRootStatement implements SubmoduleStatement { - SubmoduleStatementImpl(final StmtContext context) { - super(context); +final class SubmoduleStatementImpl extends AbstractDeclaredEffectiveRootStatement + implements SubmoduleStatement { + SubmoduleStatementImpl(final String rawArgument, + final ImmutableList> substatements) { + super(rawArgument, substatements); } } -- 2.36.6