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.eclipse.jdt.annotation.Nullable;
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.ConstraintMetaDefinition;
28 import org.opendaylight.yangtools.yang.model.api.ContainerLike;
29 import org.opendaylight.yangtools.yang.model.api.CopyableNode;
30 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
31 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
32 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
34 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
35 import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.MandatoryAware;
37 import org.opendaylight.yangtools.yang.model.api.MustConstraintAware;
38 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
39 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
40 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
41 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
42 import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.Status;
45 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
46 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
47 import org.opendaylight.yangtools.yang.model.api.UsesNode;
48 import org.opendaylight.yangtools.yang.model.api.WhenConditionAware;
49 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
50 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
51 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
52 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
53 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
54 import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
55 import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
56 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
57 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
58 import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
59 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
60 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
61 import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
64 * Mix-in interfaces providing services required by SchemaNode et al. These interfaces provide implementations, or
65 * implementation helpers based on default methods, so the correct behavior can be logically centralized.
68 public final class EffectiveStatementMixins {
69 // Marker interface requiring all mixins to be derived from EffectiveStatement.
70 private interface Mixin<A, D extends DeclaredStatement<A>> extends EffectiveStatement<A, D> {
71 @SuppressWarnings("unchecked")
72 default <T> @NonNull Collection<? extends @NonNull T> filterEffectiveStatements(final Class<T> type) {
73 // Yeah, this is not nice, but saves one transformation
74 return (Collection<? extends T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
79 * Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
81 * @param <A> Argument type ({@link Void} if statement does not have argument.)
82 * @param <D> Class representing declared version of this statement.
84 public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
85 extends Mixin<A, D>, AugmentationTarget {
87 default Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
88 return filterEffectiveStatements(AugmentationSchemaNode.class);
93 * Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
95 * @param <A> Argument type ({@link Void} if statement does not have argument.)
96 * @param <D> Class representing declared version of this statement.
98 public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
99 extends EffectiveStatementWithFlags<A, D>, AddedByUsesAware {
102 default boolean isAddedByUses() {
103 return (flags() & FlagsBuilder.ADDED_BY_USES) != 0;
108 * Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
110 * @param <A> Argument type ({@link Void} if statement does not have argument.)
111 * @param <D> Class representing declared version of this statement.
113 public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
114 extends Mixin<A, D>, ActionNodeContainer {
116 default Collection<? extends ActionDefinition> getActions() {
117 return filterEffectiveStatements(ActionDefinition.class);
122 * Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
124 * @param <A> Argument type ({@link Void} if statement does not have argument.)
125 * @param <D> Class representing declared version of this statement.
127 public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
128 extends Mixin<A, D>, NotificationNodeContainer {
130 default Collection<? extends NotificationDefinition> getNotifications() {
131 return filterEffectiveStatements(NotificationDefinition.class);
136 * Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
138 * @param <A> Argument type ({@link Void} if statement does not have argument.)
139 * @param <D> Class representing declared version of this statement.
141 public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
143 default Collection<? extends @NonNull MustDefinition> getMustConstraints() {
144 return filterEffectiveStatements(MustDefinition.class);
149 * Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
151 * @param <A> Argument type ({@link Void} if statement does not have argument.)
152 * @param <D> Class representing declared version of this statement.
154 public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
157 default boolean isAugmenting() {
158 return (flags() & FlagsBuilder.AUGMENTING) != 0;
163 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
165 * @param <A> Argument type ({@link Void} if statement does not have argument.)
166 * @param <D> Class representing declared version of this statement.
168 public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
170 default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
171 return filterTypeDefinitions(this);
175 default Collection<? extends DataSchemaNode> getChildNodes() {
176 return filterEffectiveStatements(DataSchemaNode.class);
180 default Collection<? extends GroupingDefinition> getGroupings() {
181 return filterEffectiveStatements(GroupingDefinition.class);
185 default Collection<? extends UsesNode> getUses() {
186 return filterEffectiveStatements(UsesNode.class);
191 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
193 * @param <A> Argument type ({@link Void} if statement does not have argument.)
194 * @param <D> Class representing declared version of this statement.
196 public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
197 extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
199 default Optional<Boolean> effectiveConfig() {
200 final int fl = flags() & FlagsBuilder.MASK_CONFIG;
202 case FlagsBuilder.CONFIG_FALSE:
203 return Optional.of(Boolean.FALSE);
204 case FlagsBuilder.CONFIG_TRUE:
205 return Optional.of(Boolean.TRUE);
206 case FlagsBuilder.CONFIG_UNDEF:
207 return Optional.empty();
209 throw new IllegalStateException("Unhandled effective config flags " + fl);
215 * Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
217 * @param <A> Argument type ({@link Void} if statement does not have argument.)
218 * @param <D> Class representing declared version of this statement.
220 public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
222 * Bridge between {@link EffectiveStatementWithFlags} and
223 * {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
225 * @param <A> Argument type ({@link Void} if statement does not have argument.)
226 * @param <D> Class representing declared version of this statement.
228 interface WithStatus<A, D extends DeclaredStatement<A>>
229 extends EffectiveStatementWithFlags<A, D>, DocumentedNodeMixin<A, D>, DocumentedNode.WithStatus {
231 default Status getStatus() {
232 final int status = flags() & FlagsBuilder.MASK_STATUS;
234 case FlagsBuilder.STATUS_CURRENT:
235 return Status.CURRENT;
236 case FlagsBuilder.STATUS_DEPRECATED:
237 return Status.DEPRECATED;
238 case FlagsBuilder.STATUS_OBSOLETE:
239 return Status.OBSOLETE;
241 throw new IllegalStateException("Illegal status " + status);
247 default Optional<String> getDescription() {
248 return findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class);
252 default Optional<String> getReference() {
253 return findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class);
257 default Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
258 return filterEffectiveStatements(UnknownSchemaNode.class);
263 * Bridge between {@link EffectiveStatementWithFlags} and {@link ConstraintMetaDefinition}.
265 * @param <A> Argument type ({@link Void} if statement does not have argument.)
266 * @param <D> Class representing declared version of this statement.
268 public interface ConstraintMetaDefinitionMixin<A, D extends DeclaredStatement<A>> extends DocumentedNodeMixin<A, D>,
269 ConstraintMetaDefinition {
271 default Optional<String> getErrorAppTag() {
272 return findFirstEffectiveSubstatementArgument(ErrorAppTagEffectiveStatement.class);
276 default Optional<String> getErrorMessage() {
277 return findFirstEffectiveSubstatementArgument(ErrorMessageEffectiveStatement.class);
282 * Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
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 MandatoryMixin<A, D extends DeclaredStatement<A>>
288 extends EffectiveStatementWithFlags<A, D>, MandatoryAware {
290 default boolean isMandatory() {
291 return (flags() & FlagsBuilder.MANDATORY) != 0;
296 * Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
298 * @param <A> Argument type ({@link Void} if statement does not have argument.)
299 * @param <D> Class representing declared version of this statement.
301 public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
302 default boolean presence() {
303 return (flags() & FlagsBuilder.PRESENCE) != 0;
308 * Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
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 SchemaNodeMixin<A, D extends DeclaredStatement<A>>
314 extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
316 default QName getQName() {
317 return getPath().getLastComponent();
322 * Bridge between {@link EffectiveStatementWithFlags} and {@link UnknownSchemaNode}.
324 * @param <A> Argument type ({@link Void} if statement does not have argument.)
325 * @param <D> Class representing declared version of this statement.
327 public interface UnknownSchemaNodeMixin<A, D extends DeclaredStatement<A>>
328 extends SchemaNodeMixin<A, D>, CopyableMixin<A, D>, UnknownSchemaNode {
331 default String getNodeParameter() {
332 return Strings.nullToEmpty(getDeclared().rawArgument());
337 * Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
339 * @param <A> Argument type ({@link Void} if statement does not have argument.)
340 * @param <D> Class representing declared version of this statement.
342 public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
343 default boolean userOrdered() {
344 return (flags() & FlagsBuilder.USER_ORDERED) != 0;
349 * Helper used to locate the effective {@code when} statement and exposing its argument as per
350 * {@link WhenConditionAware}.
352 * @param <A> Argument type ({@link Void} if statement does not have argument.)
353 * @param <D> Class representing declared version of this statement.
355 public interface WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
357 default Optional<QualifiedBound> getWhenCondition() {
358 return findFirstEffectiveSubstatementArgument(WhenEffectiveStatement.class);
363 * Helper bridge for operation containers ({@code input} and {@code output}).
365 * @param <D> Class representing declared version of this statement.
367 public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
368 extends ContainerLike, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
369 MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
370 SchemaNodeMixin<QName, D>, CopyableMixin<QName, D> {
372 default @NonNull QName argument() {
377 default Optional<ActionDefinition> findAction(final QName qname) {
378 return Optional.empty();
382 default Optional<NotificationDefinition> findNotification(final QName qname) {
383 return Optional.empty();
387 default Collection<? extends ActionDefinition> getActions() {
388 return ImmutableSet.of();
392 default Collection<? extends NotificationDefinition> getNotifications() {
393 return ImmutableSet.of();
397 default Optional<Boolean> effectiveConfig() {
398 return Optional.empty();
401 default String defaultToString() {
402 return MoreObjects.toStringHelper(this).add("path", getPath()).toString();
407 * Helper bridge for {@code anydata} and {@code anyxml} opaque data.
409 * @param <D> Class representing declared version of this statement.
411 public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
412 extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
413 MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
415 default @NonNull QName argument() {
421 * Helper bridge for {@code rpc} and {@code action} operations.
423 * @param <D> Class representing declared version of this statement.
425 public interface OperationDefinitionMixin<D extends DeclaredStatement<QName>>
426 extends SchemaNodeMixin<QName, D>, OperationDefinition {
428 default @NonNull QName argument() {
433 default Collection<? extends @NonNull TypeDefinition<?>> getTypeDefinitions() {
434 return filterTypeDefinitions(this);
438 default Collection<? extends @NonNull GroupingDefinition> getGroupings() {
439 return filterEffectiveStatements(GroupingDefinition.class);
443 default InputSchemaNode getInput() {
444 return findAsContainer(this, InputEffectiveStatement.class, InputSchemaNode.class);
448 default OutputSchemaNode getOutput() {
449 return findAsContainer(this, OutputEffectiveStatement.class, OutputSchemaNode.class);
454 * Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
455 * globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
457 * @param <A> Argument type ({@link Void} if statement does not have argument.)
458 * @param <D> Class representing declared version of this statement.
460 public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {
462 * Return flags assicated with this statements. Flags can be built using {@link FlagsBuilder}.
464 * @return Flag field value (32 bits).
469 final class FlagsBuilder implements Mutable {
470 // We still have 23 flags remaining
471 static final int STATUS_CURRENT = 0x0001;
472 static final int STATUS_DEPRECATED = 0x0002;
473 static final int STATUS_OBSOLETE = 0x0003;
474 static final int MASK_STATUS = 0x0003;
476 static final int MANDATORY = 0x0004;
478 static final int AUGMENTING = 0x0010;
479 static final int ADDED_BY_USES = 0x0020;
480 private static final int MASK_HISTORY = 0x0030;
482 static final int USER_ORDERED = 0x0040;
483 static final int PRESENCE = 0x0080;
485 static final int CONFIG_UNDEF = 0x0100;
486 static final int CONFIG_FALSE = 0x0200;
487 static final int CONFIG_TRUE = 0x0300;
488 static final int MASK_CONFIG = CONFIG_TRUE;
492 public FlagsBuilder setConfiguration(final @Nullable Boolean config) {
494 if (config != null) {
495 fl = config ? CONFIG_TRUE : CONFIG_FALSE;
499 flags = flags & ~MASK_CONFIG | fl;
503 public FlagsBuilder setHistory(final CopyHistory history) {
505 if (history.contains(CopyType.ADDED_BY_USES_AUGMENTATION)) {
506 bits = AUGMENTING | ADDED_BY_USES;
509 if (history.contains(CopyType.ADDED_BY_AUGMENTATION)) {
512 if (history.contains(CopyType.ADDED_BY_USES)) {
513 bits |= ADDED_BY_USES;
517 flags = flags & ~MASK_HISTORY | bits;
521 public FlagsBuilder setMandatory(final boolean mandatory) {
530 public FlagsBuilder setPresence(final boolean presence) {
539 public FlagsBuilder setStatus(final Status status) {
543 bits = STATUS_CURRENT;
546 bits = STATUS_DEPRECATED;
549 bits = STATUS_OBSOLETE;
552 throw new IllegalStateException("Unhandled status " + status);
555 flags = flags & ~MASK_STATUS | bits;
559 public FlagsBuilder setUserOrdered(final boolean userOrdered) {
561 flags |= USER_ORDERED;
563 flags &= ~USER_ORDERED;
568 public int toFlags() {
574 private EffectiveStatementMixins() {
577 static <T extends ContainerLike> T findAsContainer(final EffectiveStatement<?, ?> stmt,
578 final Class<? extends EffectiveStatement<QName, ?>> type, final Class<T> target) {
579 return target.cast(stmt.findFirstEffectiveSubstatement(type).get());
582 static Collection<? extends @NonNull TypeDefinition<?>> filterTypeDefinitions(final Mixin<?, ?> stmt) {
583 return Collections2.transform(stmt.filterEffectiveStatements(TypedefEffectiveStatement.class),
584 TypedefEffectiveStatement::getTypeDefinition);