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;
+ }
}
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;
+ }
}
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;
+ }
}
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;
+ }
}
*/
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;
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) {
--- /dev/null
+/*
+ * 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;
+ }
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
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;
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;
}
}
+ /**
+ * 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.
*/
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);
}
}
@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);
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
/*
- * 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,
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);
}
}
*/
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);
}
}
--- /dev/null
+/*
+ * 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();
+ }
+}
*/
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);
}
}
@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);
+ }
+}
--- /dev/null
+/*
+ * 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();
+ }
+}
/*
- * 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,
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);
}
}
*/
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);
}
}
--- /dev/null
+/*
+ * 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();
+ }
+}
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());
}
}
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());
}
}