From 527ed5e88a3ec3bddff18f7814b892698d07beb7 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Tue, 4 Feb 2020 10:59:51 +0100 Subject: [PATCH] Migrate input/output statements Optimize declared/effective implementations to save memory and share more codepaths. As a side-effect of this refactor, implicitly-created input statements accurately do not retain declared instances. JIRA: YANGTOOLS-1065 Change-Id: I2a51759ad80a7e07be362a9d349c2ddeb1d7e849 Signed-off-by: Robert Varga --- .../api/stmt/InputEffectiveStatement.java | 11 +- .../yang/model/api/stmt/InputStatement.java | 7 +- .../api/stmt/OutputEffectiveStatement.java | 11 +- .../yang/model/api/stmt/OutputStatement.java | 7 +- ...EffectiveOperationContainerSchemaNode.java | 3 +- .../AbstractUndeclaredEffectiveStatement.java | 174 ++++++++++++++++++ ...aseOperationContainerStatementSupport.java | 77 ++++++++ .../stmt/EffectiveStatementMixins.java | 60 ++++++ .../input/AbstractInputStatementSupport.java | 35 ++-- .../DeclaredInputEffectiveStatement.java | 55 ++++++ ...mentImpl.java => EmptyInputStatement.java} | 11 +- ...ntImpl.java => RegularInputStatement.java} | 13 +- .../UndeclaredInputEffectiveStatement.java | 56 ++++++ .../AbstractOutputStatementSupport.java | 34 ++-- .../DeclaredOutputEffectiveStatement.java | 55 ++++++ ...entImpl.java => EmptyOutputStatement.java} | 11 +- ...tImpl.java => RegularOutputStatement.java} | 13 +- .../UndeclaredOutputEffectiveStatement.java | 56 ++++++ .../yang/parser/stmt/rfc7950/Bug9241Test.java | 4 +- .../yangtools/yang/stmt/RpcStmtTest.java | 4 +- 20 files changed, 633 insertions(+), 64 deletions(-) create mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java create mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java create mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/DeclaredInputEffectiveStatement.java rename yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/{InputStatementImpl.java => EmptyInputStatement.java} (50%) rename yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/{InputEffectiveStatementImpl.java => RegularInputStatement.java} (54%) create mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/UndeclaredInputEffectiveStatement.java create mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/DeclaredOutputEffectiveStatement.java rename yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/{OutputStatementImpl.java => EmptyOutputStatement.java} (50%) rename yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/{OutputEffectiveStatementImpl.java => RegularOutputStatement.java} (54%) create mode 100644 yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/UndeclaredOutputEffectiveStatement.java diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputEffectiveStatement.java index 71f90cd24a..72a54559dc 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputEffectiveStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputEffectiveStatement.java @@ -9,9 +9,14 @@ package org.opendaylight.yangtools.yang.model.api.stmt; import com.google.common.annotations.Beta; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; @Beta -public interface InputEffectiveStatement extends SchemaTreeEffectiveStatement, - DataTreeAwareEffectiveStatement { - +public interface InputEffectiveStatement + extends SchemaTreeEffectiveStatement, DataTreeAwareEffectiveStatement { + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.INPUT; + } } diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputStatement.java index 1f39845a4e..04b4d01601 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/InputStatement.java @@ -8,10 +8,15 @@ package org.opendaylight.yangtools.yang.model.api.stmt; import org.opendaylight.yangtools.yang.common.QName; +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.StatementDefinition; public interface InputStatement extends DeclaredStatement, DataDefinitionAwareDeclaredStatement.WithReusableDefinitions, MustStatementAwareDeclaredStatement { - + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.INPUT; + } } diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputEffectiveStatement.java index 3172152f09..f1ba00bb7a 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputEffectiveStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputEffectiveStatement.java @@ -9,9 +9,14 @@ package org.opendaylight.yangtools.yang.model.api.stmt; import com.google.common.annotations.Beta; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; +import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; @Beta -public interface OutputEffectiveStatement extends SchemaTreeEffectiveStatement, - DataTreeAwareEffectiveStatement { - +public interface OutputEffectiveStatement + extends SchemaTreeEffectiveStatement, DataTreeAwareEffectiveStatement { + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.OUTPUT; + } } diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputStatement.java index f15d820128..74a524f689 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/OutputStatement.java @@ -8,10 +8,15 @@ package org.opendaylight.yangtools.yang.model.api.stmt; import org.opendaylight.yangtools.yang.common.QName; +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.StatementDefinition; public interface OutputStatement extends DeclaredStatement, DataDefinitionAwareDeclaredStatement.WithReusableDefinitions, MustStatementAwareDeclaredStatement { - + @Override + default StatementDefinition statementDefinition() { + return YangStmtMapping.OUTPUT; + } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveOperationContainerSchemaNode.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveOperationContainerSchemaNode.java index 3f72aad3f9..43cdce6946 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveOperationContainerSchemaNode.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractEffectiveOperationContainerSchemaNode.java @@ -7,7 +7,6 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt; -import com.google.common.annotations.Beta; import com.google.common.base.MoreObjects; import com.google.common.collect.ImmutableSet; import java.util.Collection; @@ -17,7 +16,7 @@ import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; -@Beta +@Deprecated(forRemoval = true) public abstract class AbstractEffectiveOperationContainerSchemaNode> extends AbstractEffectiveContainerSchemaNode { protected AbstractEffectiveOperationContainerSchemaNode(final StmtContext ctx) { 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 new file mode 100644 index 0000000000..e09c3714e4 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/AbstractUndeclaredEffectiveStatement.java @@ -0,0 +1,174 @@ +/* + * 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 static com.google.common.base.Verify.verify; +import static java.util.Objects.requireNonNull; + +import com.google.common.annotations.Beta; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import java.util.Map; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +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.IdentifierNamespace; +import org.opendaylight.yangtools.yang.model.api.meta.StatementSource; +import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeAwareEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference; + +@Beta +public abstract class AbstractUndeclaredEffectiveStatement> + extends AbstractEffectiveStatement { + @Override + public final StatementSource getStatementSource() { + return StatementSource.CONTEXT; + } + + @Override + public final D getDeclared() { + return null; + } + + /** + * Base stateless superclass form {@link SchemaTreeAwareEffectiveStatement}s. It maintains the contents of schema + * tree namespace based of effective substatements. + * + * @param Argument type ({@link Void} if statement does not have argument.) + * @param Class representing declared version of this statement. + * @param Class representing effective version of this statement. + */ + public abstract static class WithSchemaTree, + E extends SchemaTreeAwareEffectiveStatement> extends AbstractUndeclaredEffectiveStatement { + @Override + @SuppressWarnings("unchecked") + protected > Optional> getNamespaceContents( + final Class namespace) { + if (SchemaTreeAwareEffectiveStatement.Namespace.class.equals(namespace)) { + return Optional.of((Map) schemaTreeNamespace()); + } + return super.getNamespaceContents(namespace); + } + + /** + * Indexing support for {@link DataNodeContainer#findDataChildByName(QName)}. + */ + protected final Optional findDataSchemaNode(final QName name) { + // Only DataNodeContainer subclasses should be calling this method + verify(this instanceof DataNodeContainer); + final SchemaTreeEffectiveStatement child = schemaTreeNamespace().get(requireNonNull(name)); + return child instanceof DataSchemaNode ? Optional.of((DataSchemaNode) child) : Optional.empty(); + } + + protected abstract Map> schemaTreeNamespace(); + } + + /** + * Base stateless superclass form {@link DataTreeAwareEffectiveStatement}s. It maintains the contents of data tree + * namespace based of effective substatements. + * + * @param Argument type ({@link Void} if statement does not have argument.) + * @param Class representing declared version of this statement. + * @param Class representing effective version of this statement. + */ + public abstract static class WithDataTree, + E extends DataTreeAwareEffectiveStatement> extends WithSchemaTree { + @Override + @SuppressWarnings("unchecked") + protected > Optional> getNamespaceContents( + final Class namespace) { + if (DataTreeAwareEffectiveStatement.Namespace.class.equals(namespace)) { + return Optional.of((Map) dataTreeNamespace()); + } + return super.getNamespaceContents(namespace); + } + + protected abstract Map> dataTreeNamespace(); + } + + /** + * Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked). + * + * @param Argument type ({@link Void} if statement does not have argument.) + * @param Class representing declared version of this statement. + * @param Class representing effective version of this statement. + */ + public abstract static class DefaultWithSchemaTree, + E extends SchemaTreeAwareEffectiveStatement> extends WithSchemaTree { + private final @NonNull ImmutableMap> schemaTree; + + protected DefaultWithSchemaTree(final D declared, final StmtContext ctx, + final ImmutableList> substatements) { + this.schemaTree = ImmutableMap.copyOf(AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace( + ctx.getStatementSourceReference(), substatements)); + } + + @Override + protected final Map> schemaTreeNamespace() { + return schemaTree; + } + } + + /** + * Stateful version of {@link WithDataTree}. Schema tree and data tree namespaces are eagerly instantiated + * (and checked). + * + * @param Argument type ({@link Void} if statement does not have argument.) + * @param Class representing declared version of this statement. + * @param Class representing effective version of this statement. + */ + public abstract static class DefaultWithDataTree, + E extends DataTreeAwareEffectiveStatement> extends WithDataTree { + public abstract static class WithSubstatements, + E extends DataTreeAwareEffectiveStatement> extends DefaultWithDataTree { + private final @NonNull Object substatements; + + protected WithSubstatements(final StmtContext ctx, + final ImmutableList> substatements) { + super(ctx, substatements); + this.substatements = maskList(substatements); + } + + @Override + public final ImmutableList> effectiveSubstatements() { + return unmaskList(substatements); + } + } + + private final @NonNull ImmutableMap> schemaTree; + private final @NonNull ImmutableMap> dataTree; + + protected DefaultWithDataTree(final StmtContext ctx, + final ImmutableList> substatements) { + final StatementSourceReference ref = ctx.getStatementSourceReference(); + final Map> schema = + AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(ref, substatements); + this.schemaTree = ImmutableMap.copyOf(schema); + this.dataTree = AbstractSchemaEffectiveDocumentedNode.createDataTreeNamespace(ref, schema.values(), + schemaTree); + } + + @Override + protected final Map> schemaTreeNamespace() { + return schemaTree; + } + + @Override + protected final Map> dataTreeNamespace() { + return dataTree; + } + } +} 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 new file mode 100644 index 0000000000..b8c63edb34 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseOperationContainerStatementSupport.java @@ -0,0 +1,77 @@ +/* + * 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.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.Status; +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.model.api.meta.StatementSource; +import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ChildSchemaNodeNamespace; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable; + +/** + * Specialization of {@link BaseQNameStatementSupport} for {@code input} and {@code output} statements. + * + * @param Declared Statement representation + * @param Effective Statement representation + */ +@Beta +public abstract class BaseOperationContainerStatementSupport, + E extends EffectiveStatement> extends BaseQNameStatementSupport { + protected BaseOperationContainerStatementSupport(final StatementDefinition publicDefinition) { + super(publicDefinition); + } + + @Override + public final void onStatementAdded(final Mutable stmt) { + stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt); + } + + @Override + protected final E createEffective( + final StmtContext ctx, + final D declared, final ImmutableList> substatements) { + final StatementSource source = ctx.getStatementSource(); + final int flags = computeFlags(ctx, substatements); + switch (ctx.getStatementSource()) { + case CONTEXT: + return createUndeclaredEffective(flags, ctx, substatements); + case DECLARATION: + return createDeclaredEffective(flags, ctx, substatements, declared); + default: + throw new IllegalStateException("Unhandled statement source " + source); + } + } + + @Override + protected final E createEmptyEffective(final StmtContext ctx, final D declared) { + return createEffective(ctx, declared, ImmutableList.of()); + } + + protected abstract @NonNull E createDeclaredEffective(int flags, @NonNull StmtContext ctx, + @NonNull ImmutableList> substatements, @NonNull D declared); + + protected abstract @NonNull E createUndeclaredEffective(int flags, @NonNull StmtContext ctx, + @NonNull ImmutableList> substatements); + + private static int computeFlags(final StmtContext ctx, + final ImmutableList> substatements) { + return new FlagsBuilder() + .setHistory(ctx.getCopyHistory()) + .setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT)) + .toFlags(); + } +} 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 d4e6df5ce8..07c88afea7 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 @@ -8,9 +8,12 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt; import com.google.common.annotations.Beta; +import com.google.common.base.MoreObjects; import com.google.common.collect.Collections2; +import com.google.common.collect.ImmutableSet; import java.util.Collection; import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.NonNullByDefault; import org.opendaylight.yangtools.concepts.Mutable; import org.opendaylight.yangtools.yang.common.QName; @@ -19,6 +22,7 @@ import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer; import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware; import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; +import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.CopyableNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; @@ -300,6 +304,62 @@ public final class EffectiveStatementMixins { } } + /** + * Helper bridge for operation containers ({@code input} and {@code output}). + * + * @param Class representing declared version of this statement. + */ + @Beta + public interface OperationContainerMixin> + extends ContainerSchemaNode, DocumentedNodeMixin.WithStatus, DataNodeContainerMixin, + MustConstraintMixin, WhenConditionMixin, AugmentationTargetMixin, + CopyableMixin { + @Override + default @NonNull QName argument() { + return getPath().getLastComponent(); + } + + @Override + default QName getQName() { + return argument(); + } + + @Override + default Optional findAction(final QName qname) { + return Optional.empty(); + } + + @Override + default Optional findNotification(final QName qname) { + return Optional.empty(); + } + + @Override + default Collection getActions() { + return ImmutableSet.of(); + } + + @Override + default Collection getNotifications() { + return ImmutableSet.of(); + } + + @Override + default boolean isConfiguration() { + return false; + } + + @Override + default boolean isPresenceContainer() { + // FIXME: this should not really be here + return false; + } + + default String defaultToString() { + return MoreObjects.toStringHelper(this).add("path", getPath()).toString(); + } + } + /** * Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are * globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties. diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java index 9a061c6a6d..34b04e7eec 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/AbstractInputStatementSupport.java @@ -7,19 +7,20 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input; +import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.YangConstants; 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.InputEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement; -import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ChildSchemaNodeNamespace; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseOperationContainerStatementSupport; 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; abstract class AbstractInputStatementSupport - extends AbstractQNameStatementSupport { + extends BaseOperationContainerStatementSupport { AbstractInputStatementSupport() { super(YangStmtMapping.INPUT); } @@ -30,18 +31,28 @@ abstract class AbstractInputStatementSupport } @Override - public final void onStatementAdded(final Mutable stmt) { - stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt); + protected final InputStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularInputStatement(ctx.coerceStatementArgument(), substatements); } @Override - public final InputStatement createDeclared(final StmtContext ctx) { - return new InputStatementImpl(ctx); + protected final InputStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyInputStatement(ctx.coerceStatementArgument()); } @Override - public final InputEffectiveStatement createEffective( - final StmtContext ctx) { - return new InputEffectiveStatementImpl(ctx); + protected final InputEffectiveStatement createDeclaredEffective(final int flags, + final StmtContext ctx, + final ImmutableList> substatements, + final InputStatement declared) { + return new DeclaredInputEffectiveStatement(declared, flags, ctx, substatements); } -} \ No newline at end of file + + @Override + protected final InputEffectiveStatement createUndeclaredEffective(final int flags, + final StmtContext ctx, + final ImmutableList> substatements) { + return new UndeclaredInputEffectiveStatement(flags, ctx, substatements); + } +} 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 new file mode 100644 index 0000000000..53c8ffa22c --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/DeclaredInputEffectiveStatement.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. 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.input; + +import com.google.common.collect.ImmutableList; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class DeclaredInputEffectiveStatement extends WithSubstatements + implements InputEffectiveStatement, OperationContainerMixin { + private final @NonNull SchemaPath path; + private final int flags; + + DeclaredInputEffectiveStatement(final InputStatement declared, final int flags, + final StmtContext ctx, + final ImmutableList> substatements) { + super(declared, ctx, substatements); + this.flags = flags; + this.path = ctx.getSchemaPath().get(); + } + + @Override + public @NonNull SchemaPath getPath() { + return path; + } + + @Override + public int flags() { + return flags; + } + + @Override + public Optional findDataChildByName(final QName name) { + return findDataSchemaNode(name); + } + + @Override + public String toString() { + return defaultToString(); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/InputStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/EmptyInputStatement.java similarity index 50% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/InputStatementImpl.java rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/EmptyInputStatement.java index 870a006e33..685f3f9b0c 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/InputStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/EmptyInputStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * 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, @@ -9,11 +9,10 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument; -final class InputStatementImpl extends AbstractDeclaredStatement implements InputStatement { - InputStatementImpl(final StmtContext context) { - super(context); +final class EmptyInputStatement extends WithQNameArgument implements InputStatement { + EmptyInputStatement(final QName argument) { + super(argument); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/InputEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/RegularInputStatement.java similarity index 54% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/InputEffectiveStatementImpl.java rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/RegularInputStatement.java index 596cd36df5..b599a54bb2 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/InputEffectiveStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/RegularInputStatement.java @@ -7,15 +7,14 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input; +import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveOperationContainerSchemaNode; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements; -final class InputEffectiveStatementImpl extends AbstractEffectiveOperationContainerSchemaNode - implements InputEffectiveStatement { - InputEffectiveStatementImpl(final StmtContext ctx) { - super(ctx); +final class RegularInputStatement extends WithSubstatements implements InputStatement { + RegularInputStatement(final QName argument, final ImmutableList> substatements) { + super(argument, substatements); } } 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 new file mode 100644 index 0000000000..ac6f7d2936 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/input/UndeclaredInputEffectiveStatement.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. 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.input; + +import com.google.common.collect.ImmutableList; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractUndeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class UndeclaredInputEffectiveStatement + extends WithSubstatements + implements InputEffectiveStatement, OperationContainerMixin { + private final @NonNull SchemaPath path; + private final int flags; + + UndeclaredInputEffectiveStatement(final int flags, + final StmtContext ctx, + final ImmutableList> substatements) { + super(ctx, substatements); + this.flags = flags; + this.path = ctx.getSchemaPath().get(); + } + + @Override + public @NonNull SchemaPath getPath() { + return path; + } + + @Override + public int flags() { + return flags; + } + + @Override + public Optional findDataChildByName(final QName name) { + return findDataSchemaNode(name); + } + + @Override + public String toString() { + return defaultToString(); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java index 34170bedf8..004ad1049c 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/AbstractOutputStatementSupport.java @@ -7,19 +7,20 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output; +import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.YangConstants; 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.OutputEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement; -import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ChildSchemaNodeNamespace; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractQNameStatementSupport; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseOperationContainerStatementSupport; 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; abstract class AbstractOutputStatementSupport - extends AbstractQNameStatementSupport { + extends BaseOperationContainerStatementSupport { AbstractOutputStatementSupport() { super(YangStmtMapping.OUTPUT); } @@ -30,18 +31,27 @@ abstract class AbstractOutputStatementSupport } @Override - public final void onStatementAdded(final Mutable stmt) { - stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt); + protected final OutputStatement createDeclared(final StmtContext ctx, + final ImmutableList> substatements) { + return new RegularOutputStatement(ctx.coerceStatementArgument(), substatements); } @Override - public final OutputStatement createDeclared(final StmtContext ctx) { - return new OutputStatementImpl(ctx); + protected final OutputStatement createEmptyDeclared(final StmtContext ctx) { + return new EmptyOutputStatement(ctx.coerceStatementArgument()); } @Override - public final OutputEffectiveStatement createEffective( - final StmtContext ctx) { - return new OutputEffectiveStatementImpl(ctx); + protected final OutputEffectiveStatement createDeclaredEffective(final int flags, + final StmtContext ctx, + final ImmutableList> substatements, final OutputStatement declared) { + return new DeclaredOutputEffectiveStatement(declared, flags, ctx, substatements); } -} \ No newline at end of file + + @Override + protected final OutputEffectiveStatement createUndeclaredEffective(final int flags, + final StmtContext ctx, + final ImmutableList> substatements) { + return new UndeclaredOutputEffectiveStatement(flags, ctx, substatements); + } +} 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 new file mode 100644 index 0000000000..f9623aeed3 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/DeclaredOutputEffectiveStatement.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. 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.output; + +import com.google.common.collect.ImmutableList; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class DeclaredOutputEffectiveStatement extends WithSubstatements + implements OutputEffectiveStatement, OperationContainerMixin { + private final @NonNull SchemaPath path; + private final int flags; + + DeclaredOutputEffectiveStatement(final OutputStatement declared, final int flags, + final StmtContext ctx, + final ImmutableList> substatements) { + super(declared, ctx, substatements); + this.flags = flags; + this.path = ctx.getSchemaPath().get(); + } + + @Override + public @NonNull SchemaPath getPath() { + return path; + } + + @Override + public int flags() { + return flags; + } + + @Override + public Optional findDataChildByName(final QName name) { + return findDataSchemaNode(name); + } + + @Override + public String toString() { + return defaultToString(); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/OutputStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/EmptyOutputStatement.java similarity index 50% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/OutputStatementImpl.java rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/EmptyOutputStatement.java index b1b8fccf4f..0787c94e24 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/OutputStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/EmptyOutputStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * 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, @@ -9,11 +9,10 @@ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractDeclaredStatement; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument; -final class OutputStatementImpl extends AbstractDeclaredStatement implements OutputStatement { - OutputStatementImpl(final StmtContext context) { - super(context); +final class EmptyOutputStatement extends WithQNameArgument implements OutputStatement { + EmptyOutputStatement(final QName argument) { + super(argument); } } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/OutputEffectiveStatementImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/RegularOutputStatement.java similarity index 54% rename from yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/OutputEffectiveStatementImpl.java rename to yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/RegularOutputStatement.java index 5b449c0a87..d5f125b83f 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/OutputEffectiveStatementImpl.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/RegularOutputStatement.java @@ -7,15 +7,14 @@ */ package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output; +import com.google.common.collect.ImmutableList; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement; import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement; -import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveOperationContainerSchemaNode; -import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements; -final class OutputEffectiveStatementImpl extends AbstractEffectiveOperationContainerSchemaNode - implements OutputEffectiveStatement { - OutputEffectiveStatementImpl(final StmtContext ctx) { - super(ctx); +final class RegularOutputStatement extends WithSubstatements implements OutputStatement { + RegularOutputStatement(final QName argument, final ImmutableList> substatements) { + super(argument, substatements); } } 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 new file mode 100644 index 0000000000..de55dfcb2d --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/output/UndeclaredOutputEffectiveStatement.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. 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.output; + +import com.google.common.collect.ImmutableList; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractUndeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements; +import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin; +import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext; + +final class UndeclaredOutputEffectiveStatement + extends WithSubstatements + implements OutputEffectiveStatement, OperationContainerMixin { + private final @NonNull SchemaPath path; + private final int flags; + + UndeclaredOutputEffectiveStatement(final int flags, + final StmtContext ctx, + final ImmutableList> substatements) { + super(ctx, substatements); + this.flags = flags; + this.path = ctx.getSchemaPath().get(); + } + + @Override + public @NonNull SchemaPath getPath() { + return path; + } + + @Override + public int flags() { + return flags; + } + + @Override + public Optional findDataChildByName(final QName name) { + return findDataSchemaNode(name); + } + + @Override + public String toString() { + return defaultToString(); + } +} diff --git a/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug9241Test.java b/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug9241Test.java index 63a72fcb14..67c27973e4 100644 --- a/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug9241Test.java +++ b/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/parser/stmt/rfc7950/Bug9241Test.java @@ -40,11 +40,11 @@ public class Bug9241Test { final ContainerSchemaNode input = actionInCont.getInput(); assertNotNull(input); assertEquals(1, input.getChildNodes().size()); - assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) input).getDeclared().getStatementSource()); + assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) input).getStatementSource()); final ContainerSchemaNode output = actionInCont.getOutput(); assertNotNull(output); assertEquals(1, output.getChildNodes().size()); - assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) output).getDeclared().getStatementSource()); + assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) output).getStatementSource()); } } diff --git a/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/RpcStmtTest.java b/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/RpcStmtTest.java index 4ff7eb1298..3456a3791a 100644 --- a/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/RpcStmtTest.java +++ b/yang/yang-parser-rfc7950/src/test/java/org/opendaylight/yangtools/yang/stmt/RpcStmtTest.java @@ -111,11 +111,11 @@ public class RpcStmtTest { final ContainerSchemaNode input = barRpc.getInput(); assertNotNull(input); assertEquals(2, input.getChildNodes().size()); - assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) input).getDeclared().getStatementSource()); + assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) input).getStatementSource()); final ContainerSchemaNode output = barRpc.getOutput(); assertNotNull(output); assertEquals(2, output.getChildNodes().size()); - assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) output).getDeclared().getStatementSource()); + assertEquals(StatementSource.CONTEXT, ((EffectiveStatement) output).getStatementSource()); } } -- 2.36.6