2 * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.yang.parser.rfc7950.stmt;
10 import static com.google.common.base.Verify.verify;
12 import com.google.common.annotations.Beta;
13 import com.google.common.base.MoreObjects;
14 import com.google.common.collect.Collections2;
15 import com.google.common.collect.ImmutableSet;
16 import java.util.Collection;
17 import java.util.Optional;
18 import org.eclipse.jdt.annotation.NonNull;
19 import org.eclipse.jdt.annotation.NonNullByDefault;
20 import org.opendaylight.yangtools.concepts.Mutable;
21 import org.opendaylight.yangtools.yang.common.QName;
22 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
23 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
24 import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
25 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
26 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
27 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
28 import org.opendaylight.yangtools.yang.model.api.CopyableNode;
29 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
30 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
31 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
33 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
34 import org.opendaylight.yangtools.yang.model.api.MandatoryAware;
35 import org.opendaylight.yangtools.yang.model.api.MustConstraintAware;
36 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
37 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
38 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
39 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
40 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
41 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.Status;
43 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
44 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.UsesNode;
46 import org.opendaylight.yangtools.yang.model.api.WhenConditionAware;
47 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
48 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
49 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
50 import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
51 import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
52 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
53 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
54 import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
55 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
56 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
59 * Mix-in interfaces providing services required by SchemaNode et al. These interfaces provide implementations, or
60 * implementation helpers based on default methods, so the correct behavior can be logically centralized.
63 public final class EffectiveStatementMixins {
64 // Marker interface requiring all mixins to be derived from EffectiveStatement.
65 private interface Mixin<A, D extends DeclaredStatement<A>> extends EffectiveStatement<A, D> {
66 @SuppressWarnings("unchecked")
67 default <T> Collection<? extends T> filterEffectiveStatements(final Class<T> type) {
68 // Yeah, this is not nice, but saves one transformation
69 return (Collection<? extends T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
74 * Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
76 * @param <A> Argument type ({@link Void} if statement does not have argument.)
77 * @param <D> Class representing declared version of this statement.
79 public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
80 extends Mixin<A, D>, AugmentationTarget {
82 default Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
83 return filterEffectiveStatements(AugmentationSchemaNode.class);
88 * Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
90 * @param <A> Argument type ({@link Void} if statement does not have argument.)
91 * @param <D> Class representing declared version of this statement.
93 public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
94 extends EffectiveStatementWithFlags<A, D>, AddedByUsesAware {
96 default boolean isAddedByUses() {
97 return (flags() & FlagsBuilder.ADDED_BY_USES) != 0;
102 * Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
104 * @param <A> Argument type ({@link Void} if statement does not have argument.)
105 * @param <D> Class representing declared version of this statement.
107 public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
108 extends Mixin<A, D>, ActionNodeContainer {
110 default Collection<? extends ActionDefinition> getActions() {
111 return filterEffectiveStatements(ActionDefinition.class);
116 * Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
118 * @param <A> Argument type ({@link Void} if statement does not have argument.)
119 * @param <D> Class representing declared version of this statement.
121 public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
122 extends Mixin<A, D>, NotificationNodeContainer {
124 default Collection<? extends NotificationDefinition> getNotifications() {
125 return filterEffectiveStatements(NotificationDefinition.class);
130 * Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
132 * @param <A> Argument type ({@link Void} if statement does not have argument.)
133 * @param <D> Class representing declared version of this statement.
135 public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
137 default Collection<? extends MustDefinition> getMustConstraints() {
138 return filterEffectiveStatements(MustDefinition.class);
143 * Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
145 * @param <A> Argument type ({@link Void} if statement does not have argument.)
146 * @param <D> Class representing declared version of this statement.
148 public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
150 default boolean isAugmenting() {
151 return (flags() & FlagsBuilder.AUGMENTING) != 0;
156 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
158 * @param <A> Argument type ({@link Void} if statement does not have argument.)
159 * @param <D> Class representing declared version of this statement.
161 public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
163 default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
164 return filterTypeDefinitions(this);
168 default Collection<? extends DataSchemaNode> getChildNodes() {
169 return filterEffectiveStatements(DataSchemaNode.class);
173 default Collection<? extends GroupingDefinition> getGroupings() {
174 return filterEffectiveStatements(GroupingDefinition.class);
178 default Collection<? extends UsesNode> getUses() {
179 return filterEffectiveStatements(UsesNode.class);
184 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
186 * @param <A> Argument type ({@link Void} if statement does not have argument.)
187 * @param <D> Class representing declared version of this statement.
189 public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
190 extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
192 default boolean isConfiguration() {
193 return (flags() & FlagsBuilder.CONFIGURATION) != 0;
198 * Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
200 * @param <A> Argument type ({@link Void} if statement does not have argument.)
201 * @param <D> Class representing declared version of this statement.
203 public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
205 * Bridge between {@link EffectiveStatementWithFlags} and
206 * {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
208 * @param <A> Argument type ({@link Void} if statement does not have argument.)
209 * @param <D> Class representing declared version of this statement.
211 interface WithStatus<A, D extends DeclaredStatement<A>>
212 extends EffectiveStatementWithFlags<A, D>, DocumentedNodeMixin<A, D>, DocumentedNode.WithStatus {
214 default Status getStatus() {
215 final int status = flags() & FlagsBuilder.MASK_STATUS;
217 case FlagsBuilder.STATUS_CURRENT:
218 return Status.CURRENT;
219 case FlagsBuilder.STATUS_DEPRECATED:
220 return Status.DEPRECATED;
221 case FlagsBuilder.STATUS_OBSOLETE:
222 return Status.OBSOLETE;
224 throw new IllegalStateException("Illegal status " + status);
230 default Optional<String> getDescription() {
231 return findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class);
235 default Optional<String> getReference() {
236 return findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class);
240 default Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
241 return filterEffectiveStatements(UnknownSchemaNode.class);
246 * Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
248 * @param <A> Argument type ({@link Void} if statement does not have argument.)
249 * @param <D> Class representing declared version of this statement.
251 public interface MandatoryMixin<A, D extends DeclaredStatement<A>>
252 extends EffectiveStatementWithFlags<A, D>, MandatoryAware {
254 default boolean isMandatory() {
255 return (flags() & FlagsBuilder.MANDATORY) != 0;
260 * Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
262 * @param <A> Argument type ({@link Void} if statement does not have argument.)
263 * @param <D> Class representing declared version of this statement.
265 public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
266 default boolean presence() {
267 return (flags() & FlagsBuilder.PRESENCE) != 0;
272 * Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
274 * @param <A> Argument type ({@link Void} if statement does not have argument.)
275 * @param <D> Class representing declared version of this statement.
277 public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
278 extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
280 default QName getQName() {
281 return getPath().getLastComponent();
286 * Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
288 * @param <A> Argument type ({@link Void} if statement does not have argument.)
289 * @param <D> Class representing declared version of this statement.
291 public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
292 default boolean userOrdered() {
293 return (flags() & FlagsBuilder.USER_ORDERED) != 0;
298 * Helper used to locate the effective {@code when} statement and exposing its argument as per
299 * {@link WhenConditionAware}.
301 * @param <A> Argument type ({@link Void} if statement does not have argument.)
302 * @param <D> Class representing declared version of this statement.
304 public interface WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
306 default Optional<RevisionAwareXPath> getWhenCondition() {
307 return findFirstEffectiveSubstatementArgument(WhenEffectiveStatement.class);
312 * Helper bridge for operation containers ({@code input} and {@code output}).
314 * @param <D> Class representing declared version of this statement.
316 public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
317 extends ContainerSchemaNode, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
318 MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
319 SchemaNodeMixin<QName, D>, CopyableMixin<QName, D> {
321 default @NonNull QName argument() {
326 default Optional<ActionDefinition> findAction(final QName qname) {
327 return Optional.empty();
331 default Optional<NotificationDefinition> findNotification(final QName qname) {
332 return Optional.empty();
336 default Collection<? extends ActionDefinition> getActions() {
337 return ImmutableSet.of();
341 default Collection<? extends NotificationDefinition> getNotifications() {
342 return ImmutableSet.of();
346 default boolean isConfiguration() {
351 default boolean isPresenceContainer() {
352 // FIXME: this should not really be here
356 default String defaultToString() {
357 return MoreObjects.toStringHelper(this).add("path", getPath()).toString();
362 * Helper bridge for {@code anydata} and {@code anyxml} opaque data.
364 * @param <D> Class representing declared version of this statement.
366 public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
367 extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
368 MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
370 default @NonNull QName argument() {
376 * Helper bridge for {@code rpc} and {@code action} operations.
378 * @param <D> Class representing declared version of this statement.
380 public interface OperationDefinitionMixin<D extends DeclaredStatement<QName>>
381 extends SchemaNodeMixin<QName, D>, OperationDefinition {
383 default @NonNull QName argument() {
388 default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
389 return filterTypeDefinitions(this);
393 default Collection<? extends GroupingDefinition> getGroupings() {
394 return filterEffectiveStatements(GroupingDefinition.class);
398 default ContainerSchemaNode getInput() {
399 return findAsContainer(this, InputEffectiveStatement.class);
403 default ContainerSchemaNode getOutput() {
404 return findAsContainer(this, OutputEffectiveStatement.class);
409 * Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
410 * globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
412 * @param <A> Argument type ({@link Void} if statement does not have argument.)
413 * @param <D> Class representing declared version of this statement.
415 public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {
417 * Return flags assicated with this statements. Flags can be built using {@link FlagsBuilder}.
419 * @return Flag field value (32 bits).
424 final class FlagsBuilder implements Mutable {
425 // We still have 24 flags remaining
426 static final int STATUS_CURRENT = 0x0001;
427 static final int STATUS_DEPRECATED = 0x0002;
428 static final int STATUS_OBSOLETE = 0x0003;
429 static final int MASK_STATUS = 0x0003;
431 static final int CONFIGURATION = 0x0004;
432 static final int MANDATORY = 0x0008;
434 static final int AUGMENTING = 0x0010;
435 static final int ADDED_BY_USES = 0x0020;
436 private static final int MASK_HISTORY = 0x0030;
438 static final int USER_ORDERED = 0x0040;
439 static final int PRESENCE = 0x0080;
443 public FlagsBuilder setConfiguration(final boolean config) {
445 flags |= CONFIGURATION;
447 flags &= ~CONFIGURATION;
452 public FlagsBuilder setHistory(final CopyHistory history) {
454 if (history.contains(CopyType.ADDED_BY_USES_AUGMENTATION)) {
455 bits = AUGMENTING | ADDED_BY_USES;
458 if (history.contains(CopyType.ADDED_BY_AUGMENTATION)) {
461 if (history.contains(CopyType.ADDED_BY_USES)) {
462 bits |= ADDED_BY_USES;
466 flags = flags & ~MASK_HISTORY | bits;
470 public FlagsBuilder setMandatory(final boolean mandatory) {
479 public FlagsBuilder setPresence(final boolean presence) {
488 public FlagsBuilder setStatus(final Status status) {
492 bits = STATUS_CURRENT;
495 bits = STATUS_DEPRECATED;
498 bits = STATUS_OBSOLETE;
501 throw new IllegalStateException("Unhandled status " + status);
504 flags = flags & ~MASK_STATUS | bits;
508 public FlagsBuilder setUserOrdered(final boolean userOrdered) {
510 flags |= USER_ORDERED;
512 flags &= ~USER_ORDERED;
517 public int toFlags() {
523 private EffectiveStatementMixins() {
526 static ContainerSchemaNode findAsContainer(final EffectiveStatement<?, ?> stmt,
527 final Class<? extends EffectiveStatement<QName, ?>> type) {
528 final EffectiveStatement<?, ?> statement = stmt.findFirstEffectiveSubstatement(type).get();
529 verify(statement instanceof ContainerSchemaNode, "Child statement %s is not a ContainerSchemaNode",
531 return (ContainerSchemaNode) statement;
534 static Collection<? extends TypeDefinition<?>> filterTypeDefinitions(final Mixin<?, ?> stmt) {
535 return Collections2.transform(stmt.filterEffectiveStatements(TypedefEffectiveStatement.class),
536 TypedefEffectiveStatement::getTypeDefinition);