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.collect.Collections2;
13 import com.google.common.collect.ImmutableSet;
14 import java.util.Collection;
15 import java.util.Optional;
16 import org.eclipse.jdt.annotation.NonNull;
17 import org.eclipse.jdt.annotation.NonNullByDefault;
18 import org.opendaylight.yangtools.concepts.Mutable;
19 import org.opendaylight.yangtools.yang.common.QName;
20 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
21 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
22 import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
23 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
24 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
25 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
26 import org.opendaylight.yangtools.yang.model.api.CopyableNode;
27 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
28 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
29 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
30 import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
31 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
32 import org.opendaylight.yangtools.yang.model.api.MandatoryAware;
33 import org.opendaylight.yangtools.yang.model.api.MustConstraintAware;
34 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
35 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
36 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
37 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
38 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.Status;
40 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
41 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.UsesNode;
43 import org.opendaylight.yangtools.yang.model.api.WhenConditionAware;
44 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
45 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
46 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
47 import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
48 import org.opendaylight.yangtools.yang.model.api.stmt.TypedefEffectiveStatement;
49 import org.opendaylight.yangtools.yang.model.api.stmt.WhenEffectiveStatement;
50 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
51 import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
54 * Mix-in interfaces providing services required by SchemaNode et al. These interfaces provide implementations, or
55 * implementation helpers based on default methods, so the correct behavior can be logically centralized.
58 public final class EffectiveStatementMixins {
59 // Marker interface requiring all mixins to be derived from EffectiveStatement.
60 private interface Mixin<A, D extends DeclaredStatement<A>> extends EffectiveStatement<A, D> {
61 @SuppressWarnings("unchecked")
62 default <T> Collection<? extends T> filterEffectiveStatements(final Class<T> type) {
63 // Yeah, this is not nice, but saves one transformation
64 return (Collection<? extends T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
69 * Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
71 * @param <A> Argument type ({@link Void} if statement does not have argument.)
72 * @param <D> Class representing declared version of this statement.
74 public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
75 extends Mixin<A, D>, AugmentationTarget {
77 default Collection<? extends AugmentationSchemaNode> getAvailableAugmentations() {
78 return filterEffectiveStatements(AugmentationSchemaNode.class);
83 * Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
85 * @param <A> Argument type ({@link Void} if statement does not have argument.)
86 * @param <D> Class representing declared version of this statement.
88 public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
89 extends EffectiveStatementWithFlags<A, D>, AddedByUsesAware {
91 default boolean isAddedByUses() {
92 return (flags() & FlagsBuilder.ADDED_BY_USES) != 0;
97 * Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
99 * @param <A> Argument type ({@link Void} if statement does not have argument.)
100 * @param <D> Class representing declared version of this statement.
102 public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
103 extends Mixin<A, D>, ActionNodeContainer {
105 default Collection<? extends ActionDefinition> getActions() {
106 return filterEffectiveStatements(ActionDefinition.class);
111 * Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
113 * @param <A> Argument type ({@link Void} if statement does not have argument.)
114 * @param <D> Class representing declared version of this statement.
116 public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
117 extends Mixin<A, D>, NotificationNodeContainer {
119 default Collection<? extends NotificationDefinition> getNotifications() {
120 return filterEffectiveStatements(NotificationDefinition.class);
125 * Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
127 * @param <A> Argument type ({@link Void} if statement does not have argument.)
128 * @param <D> Class representing declared version of this statement.
130 public interface MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
132 default Collection<? extends MustDefinition> getMustConstraints() {
133 return filterEffectiveStatements(MustDefinition.class);
138 * Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
140 * @param <A> Argument type ({@link Void} if statement does not have argument.)
141 * @param <D> Class representing declared version of this statement.
143 public interface CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
145 default boolean isAugmenting() {
146 return (flags() & FlagsBuilder.AUGMENTING) != 0;
151 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
153 * @param <A> Argument type ({@link Void} if statement does not have argument.)
154 * @param <D> Class representing declared version of this statement.
156 public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
158 default Collection<? extends TypeDefinition<?>> getTypeDefinitions() {
159 // TODO: the cast here is needed to work around Java 11 javac type inference issue
160 return Collections2.transform(filterEffectiveStatements(TypedefEffectiveStatement.class),
161 TypedefEffectiveStatement::getTypeDefinition);
165 default Collection<? extends DataSchemaNode> getChildNodes() {
166 return filterEffectiveStatements(DataSchemaNode.class);
170 default Collection<? extends GroupingDefinition> getGroupings() {
171 return filterEffectiveStatements(GroupingDefinition.class);
175 default Collection<? extends UsesNode> getUses() {
176 return filterEffectiveStatements(UsesNode.class);
181 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
183 * @param <A> Argument type ({@link Void} if statement does not have argument.)
184 * @param <D> Class representing declared version of this statement.
186 public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
187 extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
189 default boolean isConfiguration() {
190 return (flags() & FlagsBuilder.CONFIGURATION) != 0;
195 * Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
197 * @param <A> Argument type ({@link Void} if statement does not have argument.)
198 * @param <D> Class representing declared version of this statement.
200 public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
202 * Bridge between {@link EffectiveStatementWithFlags} and
203 * {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
205 * @param <A> Argument type ({@link Void} if statement does not have argument.)
206 * @param <D> Class representing declared version of this statement.
208 interface WithStatus<A, D extends DeclaredStatement<A>>
209 extends EffectiveStatementWithFlags<A, D>, DocumentedNodeMixin<A, D>, DocumentedNode.WithStatus {
211 default Status getStatus() {
212 final int status = flags() & FlagsBuilder.MASK_STATUS;
214 case FlagsBuilder.STATUS_CURRENT:
215 return Status.CURRENT;
216 case FlagsBuilder.STATUS_DEPRECATED:
217 return Status.DEPRECATED;
218 case FlagsBuilder.STATUS_OBSOLETE:
219 return Status.OBSOLETE;
221 throw new IllegalStateException("Illegal status " + status);
227 default Optional<String> getDescription() {
228 return findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class);
232 default Optional<String> getReference() {
233 return findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class);
237 default Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
238 return filterEffectiveStatements(UnknownSchemaNode.class);
243 * Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
245 * @param <A> Argument type ({@link Void} if statement does not have argument.)
246 * @param <D> Class representing declared version of this statement.
248 public interface MandatoryMixin<A, D extends DeclaredStatement<A>>
249 extends EffectiveStatementWithFlags<A, D>, MandatoryAware {
251 default boolean isMandatory() {
252 return (flags() & FlagsBuilder.MANDATORY) != 0;
257 * Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
259 * @param <A> Argument type ({@link Void} if statement does not have argument.)
260 * @param <D> Class representing declared version of this statement.
262 public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
263 default boolean presence() {
264 return (flags() & FlagsBuilder.PRESENCE) != 0;
269 * Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
271 * @param <A> Argument type ({@link Void} if statement does not have argument.)
272 * @param <D> Class representing declared version of this statement.
274 public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
275 extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
277 default QName getQName() {
278 return getPath().getLastComponent();
283 * Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
285 * @param <A> Argument type ({@link Void} if statement does not have argument.)
286 * @param <D> Class representing declared version of this statement.
288 public interface UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
289 default boolean userOrdered() {
290 return (flags() & FlagsBuilder.USER_ORDERED) != 0;
295 * Helper used to locate the effective {@code when} statement and exposing its argument as per
296 * {@link WhenConditionAware}.
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 WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
303 default Optional<RevisionAwareXPath> getWhenCondition() {
304 return findFirstEffectiveSubstatementArgument(WhenEffectiveStatement.class);
309 * Helper bridge for operation containers ({@code input} and {@code output}).
311 * @param <D> Class representing declared version of this statement.
313 public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
314 extends ContainerSchemaNode, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
315 MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
316 CopyableMixin<QName, D> {
318 default @NonNull QName argument() {
319 return getPath().getLastComponent();
323 default QName getQName() {
328 default Optional<ActionDefinition> findAction(final QName qname) {
329 return Optional.empty();
333 default Optional<NotificationDefinition> findNotification(final QName qname) {
334 return Optional.empty();
338 default Collection<? extends ActionDefinition> getActions() {
339 return ImmutableSet.of();
343 default Collection<? extends NotificationDefinition> getNotifications() {
344 return ImmutableSet.of();
348 default boolean isConfiguration() {
353 default boolean isPresenceContainer() {
354 // FIXME: this should not really be here
358 default String defaultToString() {
359 return MoreObjects.toStringHelper(this).add("path", getPath()).toString();
364 * Helper bridge for {@code anydata} and {@code anyxml} opaque data..
366 * @param <D> Class representing declared version of this statement.
368 public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
369 extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
370 MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
372 default @NonNull QName argument() {
373 return getPath().getLastComponent();
377 default QName getQName() {
383 * Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
384 * globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
386 * @param <A> Argument type ({@link Void} if statement does not have argument.)
387 * @param <D> Class representing declared version of this statement.
389 public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {
391 * Return flags assicated with this statements. Flags can be built using {@link FlagsBuilder}.
393 * @return Flag field value (32 bits).
398 final class FlagsBuilder implements Mutable {
399 // We still have 24 flags remaining
400 static final int STATUS_CURRENT = 0x0001;
401 static final int STATUS_DEPRECATED = 0x0002;
402 static final int STATUS_OBSOLETE = 0x0003;
403 static final int MASK_STATUS = 0x0003;
405 static final int CONFIGURATION = 0x0004;
406 static final int MANDATORY = 0x0008;
408 static final int AUGMENTING = 0x0010;
409 static final int ADDED_BY_USES = 0x0020;
410 private static final int MASK_HISTORY = 0x0030;
412 static final int USER_ORDERED = 0x0040;
413 static final int PRESENCE = 0x0080;
417 public FlagsBuilder setConfiguration(final boolean config) {
419 flags |= CONFIGURATION;
421 flags &= ~CONFIGURATION;
426 public FlagsBuilder setHistory(final CopyHistory history) {
428 if (history.contains(CopyType.ADDED_BY_USES_AUGMENTATION)) {
429 bits = AUGMENTING | ADDED_BY_USES;
432 if (history.contains(CopyType.ADDED_BY_AUGMENTATION)) {
435 if (history.contains(CopyType.ADDED_BY_USES)) {
436 bits |= ADDED_BY_USES;
440 flags = flags & ~MASK_HISTORY | bits;
444 public FlagsBuilder setMandatory(final boolean mandatory) {
453 public FlagsBuilder setPresence(final boolean presence) {
462 public FlagsBuilder setStatus(final Status status) {
466 bits = STATUS_CURRENT;
469 bits = STATUS_DEPRECATED;
472 bits = STATUS_OBSOLETE;
475 throw new IllegalStateException("Unhandled status " + status);
478 flags = flags & ~MASK_STATUS | bits;
482 public FlagsBuilder setUserOrdered(final boolean userOrdered) {
484 flags |= USER_ORDERED;
486 flags &= ~USER_ORDERED;
491 public int toFlags() {