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.model.spi.meta;
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.Immutable;
21 import org.opendaylight.yangtools.concepts.Mutable;
22 import org.opendaylight.yangtools.yang.common.Empty;
23 import org.opendaylight.yangtools.yang.common.QName;
24 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
25 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
26 import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
27 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
28 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
29 import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
30 import org.opendaylight.yangtools.yang.model.api.ContainerLike;
31 import org.opendaylight.yangtools.yang.model.api.CopyableNode;
32 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
33 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
36 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
37 import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.MandatoryAware;
39 import org.opendaylight.yangtools.yang.model.api.MustConstraintAware;
40 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
41 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
42 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
43 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
44 import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
46 import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
47 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
48 import org.opendaylight.yangtools.yang.model.api.Status;
49 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
50 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
51 import org.opendaylight.yangtools.yang.model.api.UsesNode;
52 import org.opendaylight.yangtools.yang.model.api.WhenConditionAware;
53 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
54 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
55 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
56 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
57 import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
58 import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
59 import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
60 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
61 import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
62 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
63 import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
64 import org.opendaylight.yangtools.yang.model.spi.meta.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
65 import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
68 * Mix-in interfaces providing services required by SchemaNode et al. These interfaces provide implementations, or
69 * implementation helpers based on default methods, so the correct behavior can be logically centralized.
72 public final class EffectiveStatementMixins {
73 // Marker interface requiring all mixins to be derived from EffectiveStatement.
74 private interface Mixin<A, D extends DeclaredStatement<A>> extends EffectiveStatement<A, D> {
75 @SuppressWarnings("unchecked")
76 default <T> @NonNull Collection<? extends @NonNull T> filterEffectiveStatements(final Class<T> type) {
77 // Yeah, this is not nice, but saves one transformation
78 return (Collection<? extends T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
83 * Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
85 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
86 * @param <D> Class representing declared version of this statement.
88 public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
89 extends Mixin<A, D>, AugmentationTarget {
91 default Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
92 return filterEffectiveStatements(AugmentationSchemaNode.class);
97 * Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
99 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
100 * @param <D> Class representing declared version of this statement.
101 * @deprecated See deprecation notice in {@link AddedByUsesAware}
103 @Deprecated(since = "7.0.9")
104 public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
105 extends EffectiveStatementWithFlags<A, D>, AddedByUsesAware {
107 @Deprecated(since = "7.0.9")
108 default boolean isAddedByUses() {
109 return (flags() & FlagsBuilder.ADDED_BY_USES) != 0;
114 * Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
116 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
117 * @param <D> Class representing declared version of this statement.
119 public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
120 extends Mixin<A, D>, ActionNodeContainer {
122 default Collection<? extends ActionDefinition> getActions() {
123 return filterEffectiveStatements(ActionDefinition.class);
128 * Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
130 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
131 * @param <D> Class representing declared version of this statement.
133 public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
134 extends Mixin<A, D>, NotificationNodeContainer {
136 default Collection<? extends NotificationDefinition> getNotifications() {
137 return filterEffectiveStatements(NotificationDefinition.class);
142 * Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
144 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
145 * @param <D> Class representing declared version of this statement.
147 public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
149 default Collection<? extends @NonNull MustDefinition> getMustConstraints() {
150 return filterEffectiveStatements(MustDefinition.class);
155 * Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
157 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
158 * @param <D> Class representing declared version of this statement.
160 public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
162 default boolean isAugmenting() {
163 return (flags() & FlagsBuilder.AUGMENTING) != 0;
168 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
170 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
171 * @param <D> Class representing declared version of this statement.
173 public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
175 default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
176 return filterTypeDefinitions(this);
180 default Collection<? extends DataSchemaNode> getChildNodes() {
181 return filterEffectiveStatements(DataSchemaNode.class);
185 default Collection<? extends GroupingDefinition> getGroupings() {
186 return filterEffectiveStatements(GroupingDefinition.class);
190 default Collection<? extends UsesNode> getUses() {
191 return filterEffectiveStatements(UsesNode.class);
196 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
198 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
199 * @param <D> Class representing declared version of this statement.
201 public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
202 extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
204 default Optional<Boolean> effectiveConfig() {
205 final int fl = flags() & FlagsBuilder.MASK_CONFIG;
207 case FlagsBuilder.CONFIG_FALSE:
208 return Optional.of(Boolean.FALSE);
209 case FlagsBuilder.CONFIG_TRUE:
210 return Optional.of(Boolean.TRUE);
211 case FlagsBuilder.CONFIG_UNDEF:
212 return Optional.empty();
214 throw new IllegalStateException("Unhandled effective config flags " + fl);
220 * Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
222 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
223 * @param <D> Class representing declared version of this statement.
225 public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
227 * Bridge between {@link EffectiveStatementWithFlags} and
228 * {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
230 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
231 * @param <D> Class representing declared version of this statement.
233 interface WithStatus<A, D extends DeclaredStatement<A>>
234 extends EffectiveStatementWithFlags<A, D>, DocumentedNodeMixin<A, D>, DocumentedNode.WithStatus {
236 default Status getStatus() {
237 final int status = flags() & FlagsBuilder.MASK_STATUS;
239 case FlagsBuilder.STATUS_CURRENT:
240 return Status.CURRENT;
241 case FlagsBuilder.STATUS_DEPRECATED:
242 return Status.DEPRECATED;
243 case FlagsBuilder.STATUS_OBSOLETE:
244 return Status.OBSOLETE;
246 throw new IllegalStateException("Illegal status " + status);
252 default Optional<String> getDescription() {
253 return findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class);
257 default Optional<String> getReference() {
258 return findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class);
262 default Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
263 return filterEffectiveStatements(UnknownSchemaNode.class);
268 * Bridge between {@link EffectiveStatementWithFlags} and {@link ConstraintMetaDefinition}.
270 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
271 * @param <D> Class representing declared version of this statement.
273 public interface ConstraintMetaDefinitionMixin<A, D extends DeclaredStatement<A>> extends DocumentedNodeMixin<A, D>,
274 ConstraintMetaDefinition {
276 default Optional<String> getErrorAppTag() {
277 return findFirstEffectiveSubstatementArgument(ErrorAppTagEffectiveStatement.class);
281 default Optional<String> getErrorMessage() {
282 return findFirstEffectiveSubstatementArgument(ErrorMessageEffectiveStatement.class);
287 * Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
289 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
290 * @param <D> Class representing declared version of this statement.
292 public interface MandatoryMixin<A, D extends DeclaredStatement<A>>
293 extends EffectiveStatementWithFlags<A, D>, MandatoryAware {
295 default boolean isMandatory() {
296 return (flags() & FlagsBuilder.MANDATORY) != 0;
301 * Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
303 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
304 * @param <D> Class representing declared version of this statement.
306 public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
307 default boolean presence() {
308 return (flags() & FlagsBuilder.PRESENCE) != 0;
313 * Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
315 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
316 * @param <D> Class representing declared version of this statement.
318 public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
319 extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
320 // FIXME: ditch all this complexity once we do not require SchemaPath
322 default QName getQName() {
323 return SchemaNodeDefaults.extractQName(pathObject());
328 default SchemaPath getPath() {
329 return SchemaNodeDefaults.extractPath(this, pathObject());
332 @NonNull Immutable pathObject();
336 * Bridge between {@link EffectiveStatementWithFlags} and {@link UnknownSchemaNode}.
338 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
339 * @param <D> Class representing declared version of this statement.
341 public interface UnknownSchemaNodeMixin<A, D extends DeclaredStatement<A>>
342 extends SchemaNodeMixin<A, D>, CopyableMixin<A, D>, UnknownSchemaNode {
345 default String getNodeParameter() {
346 return Strings.nullToEmpty(getDeclared().rawArgument());
351 * Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
353 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
354 * @param <D> Class representing declared version of this statement.
356 public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
357 default boolean userOrdered() {
358 return (flags() & FlagsBuilder.USER_ORDERED) != 0;
363 * Helper used to locate the effective {@code when} statement and exposing its argument as per
364 * {@link WhenConditionAware}.
366 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
367 * @param <D> Class representing declared version of this statement.
369 public interface WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
371 default Optional<QualifiedBound> getWhenCondition() {
372 return findFirstEffectiveSubstatementArgument(WhenEffectiveStatement.class);
377 * Helper bridge for operation containers ({@code input} and {@code output}).
379 * @param <D> Class representing declared version of this statement.
381 public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
382 extends ContainerLike, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
383 MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
384 SchemaNodeMixin<QName, D>, CopyableMixin<QName, D> {
386 default @NonNull QName argument() {
391 default Optional<ActionDefinition> findAction(final QName qname) {
392 return Optional.empty();
396 default Optional<NotificationDefinition> findNotification(final QName qname) {
397 return Optional.empty();
401 default Collection<? extends ActionDefinition> getActions() {
402 return ImmutableSet.of();
406 default Collection<? extends NotificationDefinition> getNotifications() {
407 return ImmutableSet.of();
411 default Optional<Boolean> effectiveConfig() {
412 return Optional.empty();
415 default String defaultToString() {
416 return MoreObjects.toStringHelper(this).add("qname", getQName()).toString();
421 * Helper bridge for {@code anydata} and {@code anyxml} opaque data.
423 * @param <D> Class representing declared version of this statement.
425 public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
426 extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
427 MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
429 default @NonNull QName argument() {
435 * Helper bridge for {@code rpc} and {@code action} operations.
437 * @param <D> Class representing declared version of this statement.
439 public interface OperationDefinitionMixin<D extends DeclaredStatement<QName>>
440 extends SchemaNodeMixin<QName, D>, OperationDefinition {
442 default @NonNull QName argument() {
447 default Collection<? extends @NonNull TypeDefinition<?>> getTypeDefinitions() {
448 return filterTypeDefinitions(this);
452 default Collection<? extends @NonNull GroupingDefinition> getGroupings() {
453 return filterEffectiveStatements(GroupingDefinition.class);
457 default InputSchemaNode getInput() {
458 return findAsContainer(this, InputEffectiveStatement.class, InputSchemaNode.class);
462 default OutputSchemaNode getOutput() {
463 return findAsContainer(this, OutputEffectiveStatement.class, OutputSchemaNode.class);
468 * Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
469 * globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
471 * @param <A> Argument type ({@link Empty} if statement does not have argument.)
472 * @param <D> Class representing declared version of this statement.
474 public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {
476 * Return flags associated with this statements. Flags can be built using {@link FlagsBuilder}.
478 * @return Flag field value (32 bits).
483 final class FlagsBuilder implements Mutable {
484 // We still have 23 flags remaining
485 static final int STATUS_CURRENT = 0x0001;
486 static final int STATUS_DEPRECATED = 0x0002;
487 static final int STATUS_OBSOLETE = 0x0003;
488 static final int MASK_STATUS = 0x0003;
490 static final int MANDATORY = 0x0004;
492 static final int AUGMENTING = 0x0010;
493 @Deprecated(since = "7.0.9")
494 static final int ADDED_BY_USES = 0x0020;
495 private static final int MASK_HISTORY = 0x0030;
497 static final int USER_ORDERED = 0x0040;
498 static final int PRESENCE = 0x0080;
500 static final int CONFIG_UNDEF = 0x0100;
501 static final int CONFIG_FALSE = 0x0200;
502 static final int CONFIG_TRUE = 0x0300;
503 static final int MASK_CONFIG = CONFIG_TRUE;
507 public FlagsBuilder setConfiguration(final @Nullable Boolean config) {
509 if (config != null) {
510 fl = config ? CONFIG_TRUE : CONFIG_FALSE;
514 flags = flags & ~MASK_CONFIG | fl;
518 public FlagsBuilder setHistory(final CopyableNode history) {
519 flags = flags & ~MASK_HISTORY
520 | (history.isAugmenting() ? AUGMENTING : 0) | (history.isAddedByUses() ? ADDED_BY_USES : 0);
524 public FlagsBuilder setMandatory(final boolean mandatory) {
533 public FlagsBuilder setPresence(final boolean presence) {
542 public FlagsBuilder setStatus(final Status status) {
546 bits = STATUS_CURRENT;
549 bits = STATUS_DEPRECATED;
552 bits = STATUS_OBSOLETE;
555 throw new IllegalStateException("Unhandled status " + status);
558 flags = flags & ~MASK_STATUS | bits;
562 public FlagsBuilder setUserOrdered(final boolean userOrdered) {
564 flags |= USER_ORDERED;
566 flags &= ~USER_ORDERED;
571 public int toFlags() {
577 private EffectiveStatementMixins() {
580 static <T extends ContainerLike> T findAsContainer(final EffectiveStatement<?, ?> stmt,
581 final Class<? extends EffectiveStatement<QName, ?>> type, final Class<T> target) {
582 return target.cast(stmt.findFirstEffectiveSubstatement(type).get());
585 static Collection<? extends @NonNull TypeDefinition<?>> filterTypeDefinitions(final Mixin<?, ?> stmt) {
586 return Collections2.transform(stmt.filterEffectiveStatements(TypedefEffectiveStatement.class),
587 TypedefEffectiveStatement::getTypeDefinition);
590 public static int historyAndStatusFlags(final CopyableNode history,
591 final Collection<? extends EffectiveStatement<?, ?>> substatements) {
592 return new FlagsBuilder()
594 .setStatus(substatements.stream()
595 .filter(StatusEffectiveStatement.class::isInstance)
597 .map(stmt -> ((StatusEffectiveStatement) stmt).argument())
598 .orElse(Status.CURRENT))