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 <robert.varga@pantheon.tech>

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 71f90cd24af77319024db053191a55ced73b7732..72a54559dc67a262daa28eb36321edaadde27998 100644 (file)
--- 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<InputStatement>,
-    DataTreeAwareEffectiveStatement<QName, InputStatement> {
-
+public interface InputEffectiveStatement
+        extends SchemaTreeEffectiveStatement<InputStatement>, DataTreeAwareEffectiveStatement<QName, InputStatement> {
+    @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 1f39845a4ed62cd9eb337ebb67f3a5a8e3030bb0..04b4d01601eeb19b7909afcf2f798bc9205aad08 100644 (file)
--- 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<QName>,
         DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
         MustStatementAwareDeclaredStatement<QName> {
-
+    @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 3172152f09171f5fcede53b4b2ad49020e526754..f1ba00bb7a2d4557ec206d4a14fa3db9122ba0ca 100644 (file)
--- 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<OutputStatement>,
-    DataTreeAwareEffectiveStatement<QName, OutputStatement> {
-
+public interface OutputEffectiveStatement
+        extends SchemaTreeEffectiveStatement<OutputStatement>, DataTreeAwareEffectiveStatement<QName, OutputStatement> {
+    @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 f15d82012879aa4e7dc5631703d41aa155dba025..74a524f6898c7ec1b6fe796375b91b60cf1fb3a1 100644 (file)
--- 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<QName>,
         DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<QName>,
         MustStatementAwareDeclaredStatement<QName> {
-
+    @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 3f72aad3f9aea9acd3e4d96f75b3e8ab82211c1f..43cdce69465b7cfc441212f202c147f1fa5d8cc3 100644 (file)
--- 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<D extends DeclaredStatement<QName>>
         extends AbstractEffectiveContainerSchemaNode<D> {
     protected AbstractEffectiveOperationContainerSchemaNode(final StmtContext<QName, D, ?> 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 (file)
index 0000000..e09c371
--- /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<A, D extends DeclaredStatement<A>>
+        extends AbstractEffectiveStatement<A, D>  {
+    @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 <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <D> Class representing declared version of this statement.
+     * @param <E> Class representing effective version of this statement.
+     */
+    public abstract static class WithSchemaTree<A, D extends DeclaredStatement<A>,
+            E extends SchemaTreeAwareEffectiveStatement<A, D>> extends AbstractUndeclaredEffectiveStatement<A, D> {
+        @Override
+        @SuppressWarnings("unchecked")
+        protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
+                final Class<N> namespace) {
+            if (SchemaTreeAwareEffectiveStatement.Namespace.class.equals(namespace)) {
+                return Optional.of((Map<K, V>) schemaTreeNamespace());
+            }
+            return super.getNamespaceContents(namespace);
+        }
+
+        /**
+         * Indexing support for {@link DataNodeContainer#findDataChildByName(QName)}.
+         */
+        protected final Optional<DataSchemaNode> 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<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace();
+    }
+
+    /**
+     * Base stateless superclass form {@link DataTreeAwareEffectiveStatement}s. It maintains the contents of data tree
+     * namespace based of effective substatements.
+     *
+     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <D> Class representing declared version of this statement.
+     * @param <E> Class representing effective version of this statement.
+     */
+    public abstract static class WithDataTree<A, D extends DeclaredStatement<A>,
+            E extends DataTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
+        @Override
+        @SuppressWarnings("unchecked")
+        protected <K, V, N extends IdentifierNamespace<K, V>> Optional<? extends Map<K, V>> getNamespaceContents(
+                final Class<N> namespace) {
+            if (DataTreeAwareEffectiveStatement.Namespace.class.equals(namespace)) {
+                return Optional.of((Map<K, V>) dataTreeNamespace());
+            }
+            return super.getNamespaceContents(namespace);
+        }
+
+        protected abstract Map<QName, DataTreeEffectiveStatement<?>> dataTreeNamespace();
+    }
+
+    /**
+     * Stateful version of {@link WithSchemaTree}. Schema tree namespace is eagerly instantiated (and checked).
+     *
+     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <D> Class representing declared version of this statement.
+     * @param <E> Class representing effective version of this statement.
+     */
+    public abstract static class DefaultWithSchemaTree<A, D extends DeclaredStatement<A>,
+            E extends SchemaTreeAwareEffectiveStatement<A, D>> extends WithSchemaTree<A, D, E> {
+        private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+
+        protected DefaultWithSchemaTree(final D declared, final StmtContext<?, ?, ?> ctx,
+                final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+            this.schemaTree = ImmutableMap.copyOf(AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(
+                ctx.getStatementSourceReference(), substatements));
+        }
+
+        @Override
+        protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
+            return schemaTree;
+        }
+    }
+
+    /**
+     * Stateful version of {@link WithDataTree}. Schema tree and data tree namespaces are eagerly instantiated
+     * (and checked).
+     *
+     * @param <A> Argument type ({@link Void} if statement does not have argument.)
+     * @param <D> Class representing declared version of this statement.
+     * @param <E> Class representing effective version of this statement.
+     */
+    public abstract static class DefaultWithDataTree<A, D extends DeclaredStatement<A>,
+            E extends DataTreeAwareEffectiveStatement<A, D>> extends WithDataTree<A, D, E> {
+        public abstract static class WithSubstatements<A, D extends DeclaredStatement<A>,
+                E extends DataTreeAwareEffectiveStatement<A, D>> extends DefaultWithDataTree<A, D, E> {
+            private final @NonNull Object substatements;
+
+            protected WithSubstatements(final StmtContext<?, ?, ?> ctx,
+                    final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+                super(ctx, substatements);
+                this.substatements = maskList(substatements);
+            }
+
+            @Override
+            public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
+                return unmaskList(substatements);
+            }
+        }
+
+        private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
+        private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
+
+        protected DefaultWithDataTree(final StmtContext<?, ?, ?> ctx,
+                final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+            final StatementSourceReference ref = ctx.getStatementSourceReference();
+            final Map<QName, SchemaTreeEffectiveStatement<?>> schema =
+                    AbstractSchemaEffectiveDocumentedNode.createSchemaTreeNamespace(ref, substatements);
+            this.schemaTree = ImmutableMap.copyOf(schema);
+            this.dataTree = AbstractSchemaEffectiveDocumentedNode.createDataTreeNamespace(ref, schema.values(),
+                schemaTree);
+        }
+
+        @Override
+        protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
+            return schemaTree;
+        }
+
+        @Override
+        protected final Map<QName, DataTreeEffectiveStatement<?>> 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 (file)
index 0000000..b8c63ed
--- /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 <D> Declared Statement representation
+ * @param <E> Effective Statement representation
+ */
+@Beta
+public abstract class BaseOperationContainerStatementSupport<D extends DeclaredStatement<QName>,
+        E extends EffectiveStatement<QName, D>> extends BaseQNameStatementSupport<D, E> {
+    protected BaseOperationContainerStatementSupport(final StatementDefinition publicDefinition) {
+        super(publicDefinition);
+    }
+
+    @Override
+    public final void onStatementAdded(final Mutable<QName, D, E> stmt) {
+        stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
+    }
+
+    @Override
+    protected final E createEffective(
+            final StmtContext<QName, D, E> ctx,
+            final D declared, final ImmutableList<? extends EffectiveStatement<?, ?>> 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<QName, D, E> ctx, final D declared) {
+        return createEffective(ctx, declared, ImmutableList.of());
+    }
+
+    protected abstract @NonNull E createDeclaredEffective(int flags, @NonNull StmtContext<QName, D, E> ctx,
+            @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements, @NonNull D declared);
+
+    protected abstract @NonNull E createUndeclaredEffective(int flags, @NonNull StmtContext<QName, D, E> ctx,
+            @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
+
+    private static int computeFlags(final StmtContext<?, ?, ?> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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 d4e6df5ce8820490b660db8766f17dd1d65ccee7..07c88afea734d8b43d9669483410ba7e6c613033 100644 (file)
--- 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 <D> Class representing declared version of this statement.
+     */
+    @Beta
+    public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
+            extends ContainerSchemaNode, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
+                    MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
+                    CopyableMixin<QName, D> {
+        @Override
+        default @NonNull QName argument() {
+            return getPath().getLastComponent();
+        }
+
+        @Override
+        default QName getQName() {
+            return argument();
+        }
+
+        @Override
+        default Optional<ActionDefinition> findAction(final QName qname) {
+            return Optional.empty();
+        }
+
+        @Override
+        default Optional<NotificationDefinition> findNotification(final QName qname) {
+            return Optional.empty();
+        }
+
+        @Override
+        default Collection<? extends ActionDefinition> getActions() {
+            return ImmutableSet.of();
+        }
+
+        @Override
+        default Collection<? extends NotificationDefinition> 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 9a061c6a6d305d457eb57e705ed768e1062c52b9..34b04e7eec8aa2265fa4f0d3112da9b297293257 100644 (file)
--- 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<InputStatement, InputEffectiveStatement> {
+        extends BaseOperationContainerStatementSupport<InputStatement, InputEffectiveStatement> {
     AbstractInputStatementSupport() {
         super(YangStmtMapping.INPUT);
     }
@@ -30,18 +31,28 @@ abstract class AbstractInputStatementSupport
     }
 
     @Override
-    public final void onStatementAdded(final Mutable<QName, InputStatement, InputEffectiveStatement> stmt) {
-        stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
+    protected final InputStatement createDeclared(final StmtContext<QName, InputStatement, ?> ctx,
+            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        return new RegularInputStatement(ctx.coerceStatementArgument(), substatements);
     }
 
     @Override
-    public final InputStatement createDeclared(final StmtContext<QName, InputStatement, ?> ctx) {
-        return new InputStatementImpl(ctx);
+    protected final InputStatement createEmptyDeclared(final StmtContext<QName, InputStatement, ?> ctx) {
+        return new EmptyInputStatement(ctx.coerceStatementArgument());
     }
 
     @Override
-    public final InputEffectiveStatement createEffective(
-            final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx) {
-        return new InputEffectiveStatementImpl(ctx);
+    protected final InputEffectiveStatement createDeclaredEffective(final int flags,
+            final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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<QName, InputStatement, InputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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 (file)
index 0000000..53c8ffa
--- /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<QName, InputStatement, InputEffectiveStatement>
+        implements InputEffectiveStatement, OperationContainerMixin<InputStatement> {
+    private final @NonNull SchemaPath path;
+    private final int flags;
+
+    DeclaredInputEffectiveStatement(final InputStatement declared, final int flags,
+            final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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<DataSchemaNode> 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 870a006e3374aa4c91e545b2b7134a24810b90d1..685f3f9b0c30c143553f79b7072cc82f27b1f4d1 100644 (file)
--- 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<QName> implements InputStatement {
-    InputStatementImpl(final StmtContext<QName, InputStatement, ?> 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 596cd36df5807b31f80d057e202d0fe0277864e5..b599a54bb2bbe18c979988282d46a9a2563f9a0a 100644 (file)
--- 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<InputStatement>
-        implements InputEffectiveStatement {
-    InputEffectiveStatementImpl(final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx) {
-        super(ctx);
+final class RegularInputStatement extends WithSubstatements implements InputStatement {
+    RegularInputStatement(final QName argument, final ImmutableList<? extends DeclaredStatement<?>> 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 (file)
index 0000000..ac6f7d2
--- /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<QName, InputStatement, InputEffectiveStatement>
+        implements InputEffectiveStatement, OperationContainerMixin<InputStatement> {
+    private final @NonNull SchemaPath path;
+    private final int flags;
+
+    UndeclaredInputEffectiveStatement(final int flags,
+            final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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<DataSchemaNode> 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 34170bedf88e595c32aeb65411c60335b689f77f..004ad1049c52223849ad0c875d8c59186e950666 100644 (file)
--- 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<OutputStatement, OutputEffectiveStatement> {
+        extends BaseOperationContainerStatementSupport<OutputStatement, OutputEffectiveStatement> {
     AbstractOutputStatementSupport() {
         super(YangStmtMapping.OUTPUT);
     }
@@ -30,18 +31,27 @@ abstract class AbstractOutputStatementSupport
     }
 
     @Override
-    public final void onStatementAdded(final Mutable<QName, OutputStatement, OutputEffectiveStatement> stmt) {
-        stmt.coerceParentContext().addToNs(ChildSchemaNodeNamespace.class, stmt.coerceStatementArgument(), stmt);
+    protected final OutputStatement createDeclared(final StmtContext<QName, OutputStatement, ?> ctx,
+            final ImmutableList<? extends DeclaredStatement<?>> substatements) {
+        return new RegularOutputStatement(ctx.coerceStatementArgument(), substatements);
     }
 
     @Override
-    public final OutputStatement createDeclared(final StmtContext<QName, OutputStatement, ?> ctx) {
-        return new OutputStatementImpl(ctx);
+    protected final OutputStatement createEmptyDeclared(final StmtContext<QName, OutputStatement, ?> ctx) {
+        return new EmptyOutputStatement(ctx.coerceStatementArgument());
     }
 
     @Override
-    public final OutputEffectiveStatement createEffective(
-            final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx) {
-        return new OutputEffectiveStatementImpl(ctx);
+    protected final OutputEffectiveStatement createDeclaredEffective(final int flags,
+            final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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<QName, OutputStatement, OutputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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 (file)
index 0000000..f9623ae
--- /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<QName, OutputStatement, OutputEffectiveStatement>
+        implements OutputEffectiveStatement, OperationContainerMixin<OutputStatement> {
+    private final @NonNull SchemaPath path;
+    private final int flags;
+
+    DeclaredOutputEffectiveStatement(final OutputStatement declared, final int flags,
+            final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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<DataSchemaNode> 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 b1b8fccf4f038051e252900c59e946ed076844ff..0787c94e24daaf8e3b67f6d944da06d446363b97 100644 (file)
--- 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<QName> implements OutputStatement {
-    OutputStatementImpl(final StmtContext<QName, OutputStatement, ?> 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 5b449c0a87151f69be53e6afd3bb7a570972287d..d5f125b83fd565528df462669015c4543af60f24 100644 (file)
--- 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<OutputStatement>
-        implements OutputEffectiveStatement {
-    OutputEffectiveStatementImpl(final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx) {
-        super(ctx);
+final class RegularOutputStatement extends WithSubstatements implements OutputStatement {
+    RegularOutputStatement(final QName argument, final ImmutableList<? extends DeclaredStatement<?>> 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 (file)
index 0000000..de55dfc
--- /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<QName, OutputStatement, OutputEffectiveStatement>
+        implements OutputEffectiveStatement, OperationContainerMixin<OutputStatement> {
+    private final @NonNull SchemaPath path;
+    private final int flags;
+
+    UndeclaredOutputEffectiveStatement(final int flags,
+            final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx,
+            final ImmutableList<? extends EffectiveStatement<?, ?>> 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<DataSchemaNode> 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 63a72fcb14fdf6f5f52efac39a36b5dfafe81ec1..67c27973e4293d9bf3e35fc9feb7f83cdfdf5c1d 100644 (file)
--- 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 4ff7eb1298faf9ad96bee80971dca54f1b75c8f3..3456a3791a3dc9cd111a2e29c6f5fa1e60459213 100644 (file)
--- 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());
     }
 }