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 com.google.common.annotations.Beta;
11 import com.google.common.base.MoreObjects;
12 import com.google.common.base.Strings;
13 import com.google.common.collect.Collections2;
14 import com.google.common.collect.ImmutableSet;
15 import java.util.Collection;
16 import java.util.Optional;
17 import org.eclipse.jdt.annotation.NonNull;
18 import org.eclipse.jdt.annotation.NonNullByDefault;
19 import org.opendaylight.yangtools.concepts.Mutable;
20 import org.opendaylight.yangtools.yang.common.QName;
21 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
22 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
23 import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
24 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
25 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
26 import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
27 import org.opendaylight.yangtools.yang.model.api.ContainerLike;
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.InputSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.MandatoryAware;
36 import org.opendaylight.yangtools.yang.model.api.MustConstraintAware;
37 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
38 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
39 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
40 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
41 import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.Status;
44 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
45 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
46 import org.opendaylight.yangtools.yang.model.api.UsesNode;
47 import org.opendaylight.yangtools.yang.model.api.WhenConditionAware;
48 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
49 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
50 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
51 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
52 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
53 import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
54 import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
55 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
56 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
57 import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
58 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
59 import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
62 * Mix-in interfaces providing services required by SchemaNode et al. These interfaces provide implementations, or
63 * implementation helpers based on default methods, so the correct behavior can be logically centralized.
66 public final class EffectiveStatementMixins {
67 // Marker interface requiring all mixins to be derived from EffectiveStatement.
68 private interface Mixin<A, D extends DeclaredStatement<A>> extends EffectiveStatement<A, D> {
69 @SuppressWarnings("unchecked")
70 default <T> @NonNull Collection<? extends T> filterEffectiveStatements(final Class<T> type) {
71 // Yeah, this is not nice, but saves one transformation
72 return (Collection<? extends T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
77 * Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
79 * @param <A> Argument type ({@link Void} if statement does not have argument.)
80 * @param <D> Class representing declared version of this statement.
82 public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
83 extends Mixin<A, D>, AugmentationTarget {
85 default Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
86 return filterEffectiveStatements(AugmentationSchemaNode.class);
91 * Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
93 * @param <A> Argument type ({@link Void} if statement does not have argument.)
94 * @param <D> Class representing declared version of this statement.
96 public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
97 extends EffectiveStatementWithFlags<A, D>, AddedByUsesAware {
99 default boolean isAddedByUses() {
100 return (flags() & FlagsBuilder.ADDED_BY_USES) != 0;
105 * Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
107 * @param <A> Argument type ({@link Void} if statement does not have argument.)
108 * @param <D> Class representing declared version of this statement.
110 public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
111 extends Mixin<A, D>, ActionNodeContainer {
113 default Collection<? extends ActionDefinition> getActions() {
114 return filterEffectiveStatements(ActionDefinition.class);
119 * Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
121 * @param <A> Argument type ({@link Void} if statement does not have argument.)
122 * @param <D> Class representing declared version of this statement.
124 public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
125 extends Mixin<A, D>, NotificationNodeContainer {
127 default Collection<? extends NotificationDefinition> getNotifications() {
128 return filterEffectiveStatements(NotificationDefinition.class);
133 * Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
135 * @param <A> Argument type ({@link Void} if statement does not have argument.)
136 * @param <D> Class representing declared version of this statement.
138 public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
140 default Collection<? extends MustDefinition> getMustConstraints() {
141 return filterEffectiveStatements(MustDefinition.class);
146 * Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
148 * @param <A> Argument type ({@link Void} if statement does not have argument.)
149 * @param <D> Class representing declared version of this statement.
151 public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
153 default boolean isAugmenting() {
154 return (flags() & FlagsBuilder.AUGMENTING) != 0;
159 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
161 * @param <A> Argument type ({@link Void} if statement does not have argument.)
162 * @param <D> Class representing declared version of this statement.
164 public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
166 default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
167 return filterTypeDefinitions(this);
171 default Collection<? extends DataSchemaNode> getChildNodes() {
172 return filterEffectiveStatements(DataSchemaNode.class);
176 default Collection<? extends GroupingDefinition> getGroupings() {
177 return filterEffectiveStatements(GroupingDefinition.class);
181 default Collection<? extends UsesNode> getUses() {
182 return filterEffectiveStatements(UsesNode.class);
187 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
189 * @param <A> Argument type ({@link Void} if statement does not have argument.)
190 * @param <D> Class representing declared version of this statement.
192 public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
193 extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
195 default boolean isConfiguration() {
196 return (flags() & FlagsBuilder.CONFIGURATION) != 0;
201 * Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
203 * @param <A> Argument type ({@link Void} if statement does not have argument.)
204 * @param <D> Class representing declared version of this statement.
206 public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
208 * Bridge between {@link EffectiveStatementWithFlags} and
209 * {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
211 * @param <A> Argument type ({@link Void} if statement does not have argument.)
212 * @param <D> Class representing declared version of this statement.
214 interface WithStatus<A, D extends DeclaredStatement<A>>
215 extends EffectiveStatementWithFlags<A, D>, DocumentedNodeMixin<A, D>, DocumentedNode.WithStatus {
217 default Status getStatus() {
218 final int status = flags() & FlagsBuilder.MASK_STATUS;
220 case FlagsBuilder.STATUS_CURRENT:
221 return Status.CURRENT;
222 case FlagsBuilder.STATUS_DEPRECATED:
223 return Status.DEPRECATED;
224 case FlagsBuilder.STATUS_OBSOLETE:
225 return Status.OBSOLETE;
227 throw new IllegalStateException("Illegal status " + status);
233 default Optional<String> getDescription() {
234 return findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class);
238 default Optional<String> getReference() {
239 return findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class);
243 default Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
244 return filterEffectiveStatements(UnknownSchemaNode.class);
249 * Bridge between {@link EffectiveStatementWithFlags} and {@link ConstraintMetaDefinition}.
251 * @param <A> Argument type ({@link Void} if statement does not have argument.)
252 * @param <D> Class representing declared version of this statement.
254 public interface ConstraintMetaDefinitionMixin<A, D extends DeclaredStatement<A>> extends DocumentedNodeMixin<A, D>,
255 ConstraintMetaDefinition {
257 default Optional<String> getErrorAppTag() {
258 return findFirstEffectiveSubstatementArgument(ErrorAppTagEffectiveStatement.class);
262 default Optional<String> getErrorMessage() {
263 return findFirstEffectiveSubstatementArgument(ErrorMessageEffectiveStatement.class);
268 * Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
270 * @param <A> Argument type ({@link Void} if statement does not have argument.)
271 * @param <D> Class representing declared version of this statement.
273 public interface MandatoryMixin<A, D extends DeclaredStatement<A>>
274 extends EffectiveStatementWithFlags<A, D>, MandatoryAware {
276 default boolean isMandatory() {
277 return (flags() & FlagsBuilder.MANDATORY) != 0;
282 * Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
284 * @param <A> Argument type ({@link Void} if statement does not have argument.)
285 * @param <D> Class representing declared version of this statement.
287 public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
288 default boolean presence() {
289 return (flags() & FlagsBuilder.PRESENCE) != 0;
294 * Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
296 * @param <A> Argument type ({@link Void} if statement does not have argument.)
297 * @param <D> Class representing declared version of this statement.
299 public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
300 extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
302 default QName getQName() {
303 return getPath().getLastComponent();
308 * Bridge between {@link EffectiveStatementWithFlags} and {@link UnknownSchemaNode}.
310 * @param <A> Argument type ({@link Void} if statement does not have argument.)
311 * @param <D> Class representing declared version of this statement.
313 public interface UnknownSchemaNodeMixin<A, D extends DeclaredStatement<A>>
314 extends SchemaNodeMixin<A, D>, CopyableMixin<A, D>, UnknownSchemaNode {
317 default String getNodeParameter() {
318 return Strings.nullToEmpty(getDeclared().rawArgument());
323 * Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
325 * @param <A> Argument type ({@link Void} if statement does not have argument.)
326 * @param <D> Class representing declared version of this statement.
328 public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
329 default boolean userOrdered() {
330 return (flags() & FlagsBuilder.USER_ORDERED) != 0;
335 * Helper used to locate the effective {@code when} statement and exposing its argument as per
336 * {@link WhenConditionAware}.
338 * @param <A> Argument type ({@link Void} if statement does not have argument.)
339 * @param <D> Class representing declared version of this statement.
341 public interface WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
343 default Optional<QualifiedBound> getWhenCondition() {
344 return findFirstEffectiveSubstatementArgument(WhenEffectiveStatement.class);
349 * Helper bridge for operation containers ({@code input} and {@code output}).
351 * @param <D> Class representing declared version of this statement.
353 public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
354 extends ContainerLike, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
355 MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
356 SchemaNodeMixin<QName, D>, CopyableMixin<QName, D> {
358 default @NonNull QName argument() {
363 default Optional<ActionDefinition> findAction(final QName qname) {
364 return Optional.empty();
368 default Optional<NotificationDefinition> findNotification(final QName qname) {
369 return Optional.empty();
373 default Collection<? extends ActionDefinition> getActions() {
374 return ImmutableSet.of();
378 default Collection<? extends NotificationDefinition> getNotifications() {
379 return ImmutableSet.of();
383 default boolean isConfiguration() {
387 default String defaultToString() {
388 return MoreObjects.toStringHelper(this).add("path", getPath()).toString();
393 * Helper bridge for {@code anydata} and {@code anyxml} opaque data.
395 * @param <D> Class representing declared version of this statement.
397 public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
398 extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
399 MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
401 default @NonNull QName argument() {
407 * Helper bridge for {@code rpc} and {@code action} operations.
409 * @param <D> Class representing declared version of this statement.
411 public interface OperationDefinitionMixin<D extends DeclaredStatement<QName>>
412 extends SchemaNodeMixin<QName, D>, OperationDefinition {
414 default @NonNull QName argument() {
419 default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
420 return filterTypeDefinitions(this);
424 default Collection<? extends GroupingDefinition> getGroupings() {
425 return filterEffectiveStatements(GroupingDefinition.class);
429 default InputSchemaNode getInput() {
430 return findAsContainer(this, InputEffectiveStatement.class, InputSchemaNode.class);
434 default OutputSchemaNode getOutput() {
435 return findAsContainer(this, OutputEffectiveStatement.class, OutputSchemaNode.class);
440 * Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
441 * globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
443 * @param <A> Argument type ({@link Void} if statement does not have argument.)
444 * @param <D> Class representing declared version of this statement.
446 public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {
448 * Return flags assicated with this statements. Flags can be built using {@link FlagsBuilder}.
450 * @return Flag field value (32 bits).
455 final class FlagsBuilder implements Mutable {
456 // We still have 24 flags remaining
457 static final int STATUS_CURRENT = 0x0001;
458 static final int STATUS_DEPRECATED = 0x0002;
459 static final int STATUS_OBSOLETE = 0x0003;
460 static final int MASK_STATUS = 0x0003;
462 static final int CONFIGURATION = 0x0004;
463 static final int MANDATORY = 0x0008;
465 static final int AUGMENTING = 0x0010;
466 static final int ADDED_BY_USES = 0x0020;
467 private static final int MASK_HISTORY = 0x0030;
469 static final int USER_ORDERED = 0x0040;
470 static final int PRESENCE = 0x0080;
474 public FlagsBuilder setConfiguration(final boolean config) {
476 flags |= CONFIGURATION;
478 flags &= ~CONFIGURATION;
483 public FlagsBuilder setHistory(final CopyHistory history) {
484 flags = flags & ~MASK_HISTORY
485 | (history.isAugmenting() ? AUGMENTING : 0) | (history.isAddedByUses() ? ADDED_BY_USES : 0);
489 public FlagsBuilder setMandatory(final boolean mandatory) {
498 public FlagsBuilder setPresence(final boolean presence) {
507 public FlagsBuilder setStatus(final Status status) {
511 bits = STATUS_CURRENT;
514 bits = STATUS_DEPRECATED;
517 bits = STATUS_OBSOLETE;
520 throw new IllegalStateException("Unhandled status " + status);
523 flags = flags & ~MASK_STATUS | bits;
527 public FlagsBuilder setUserOrdered(final boolean userOrdered) {
529 flags |= USER_ORDERED;
531 flags &= ~USER_ORDERED;
536 public int toFlags() {
542 private EffectiveStatementMixins() {
545 static <T extends ContainerLike> T findAsContainer(final EffectiveStatement<?, ?> stmt,
546 final Class<? extends EffectiveStatement<QName, ?>> type, Class<T> target) {
547 return target.cast(stmt.findFirstEffectiveSubstatement(type).get());
550 static Collection<? extends TypeDefinition<?>> filterTypeDefinitions(final Mixin<?, ?> stmt) {
551 return Collections2.transform(stmt.filterEffectiveStatements(TypedefEffectiveStatement.class),
552 TypedefEffectiveStatement::getTypeDefinition);