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.ImmutableList;
16 import com.google.common.collect.ImmutableSet;
17 import java.util.Collection;
18 import java.util.List;
19 import java.util.Optional;
21 import org.eclipse.jdt.annotation.NonNull;
22 import org.eclipse.jdt.annotation.NonNullByDefault;
23 import org.opendaylight.yangtools.concepts.Mutable;
24 import org.opendaylight.yangtools.yang.common.QName;
25 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
26 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
27 import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware;
28 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
29 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
30 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
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.MandatoryAware;
38 import org.opendaylight.yangtools.yang.model.api.MustConstraintAware;
39 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
40 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
41 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
42 import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
43 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
44 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.Status;
46 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
47 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
48 import org.opendaylight.yangtools.yang.model.api.UsesNode;
49 import org.opendaylight.yangtools.yang.model.api.WhenConditionAware;
50 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
51 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
52 import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
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.parser.spi.meta.CopyType;
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> Collection<T> filterEffectiveStatements(final Class<T> type) {
71 // Yeah, this is not nice, but saves one transformation
72 return (Collection<T>) Collections2.filter(effectiveSubstatements(), type::isInstance);
75 // FIXME: YANGTOOLS-1068: eliminate this once we can return collections
76 default <T> List<T> filterEffectiveStatementsList(final Class<T> type) {
77 return ImmutableList.copyOf(filterEffectiveStatements(type));
80 // FIXME: YANGTOOLS-1068: eliminate this once we can return collections
81 default <T> Set<T> filterEffectiveStatementsSet(final Class<T> type) {
82 return ImmutableSet.copyOf(filterEffectiveStatements(type));
87 * Bridge between {@link EffectiveStatement} and {@link AugmentationTarget}.
89 * @param <A> Argument type ({@link Void} if statement does not have argument.)
90 * @param <D> Class representing declared version of this statement.
92 public interface AugmentationTargetMixin<A, D extends DeclaredStatement<A>>
93 extends Mixin<A, D>, AugmentationTarget {
95 default Set<AugmentationSchemaNode> getAvailableAugmentations() {
96 return filterEffectiveStatementsSet(AugmentationSchemaNode.class);
101 * Bridge between {@link EffectiveStatementWithFlags} and {@link AddedByUsesAware}.
103 * @param <A> Argument type ({@link Void} if statement does not have argument.)
104 * @param <D> Class representing declared version of this statement.
106 public interface AddedByUsesMixin<A, D extends DeclaredStatement<A>>
107 extends EffectiveStatementWithFlags<A, D>, AddedByUsesAware {
109 default boolean isAddedByUses() {
110 return (flags() & FlagsBuilder.ADDED_BY_USES) != 0;
115 * Bridge between {@link EffectiveStatementWithFlags} and {@link ActionNodeContainer}.
117 * @param <A> Argument type ({@link Void} if statement does not have argument.)
118 * @param <D> Class representing declared version of this statement.
120 public interface ActionNodeContainerMixin<A, D extends DeclaredStatement<A>>
121 extends Mixin<A, D>, ActionNodeContainer {
123 default Set<ActionDefinition> getActions() {
124 return filterEffectiveStatementsSet(ActionDefinition.class);
129 * Bridge between {@link EffectiveStatementWithFlags} and {@link NotificationNodeContainer}.
131 * @param <A> Argument type ({@link Void} if statement does not have argument.)
132 * @param <D> Class representing declared version of this statement.
134 public interface NotificationNodeContainerMixin<A, D extends DeclaredStatement<A>>
135 extends Mixin<A, D>, NotificationNodeContainer {
137 default Set<NotificationDefinition> getNotifications() {
138 return filterEffectiveStatementsSet(NotificationDefinition.class);
143 * Bridge between {@link EffectiveStatementWithFlags} and {@link MustConstraintAware}.
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 MustConstraintMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, MustConstraintAware {
150 default Collection<MustDefinition> getMustConstraints() {
151 return filterEffectiveStatements(MustDefinition.class);
156 * Bridge between {@link EffectiveStatementWithFlags} and {@link CopyableNode}.
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 CopyableMixin<A, D extends DeclaredStatement<A>> extends AddedByUsesMixin<A, D>, CopyableNode {
163 default boolean isAugmenting() {
164 return (flags() & FlagsBuilder.AUGMENTING) != 0;
169 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataNodeContainer}.
171 * @param <A> Argument type ({@link Void} if statement does not have argument.)
172 * @param <D> Class representing declared version of this statement.
174 public interface DataNodeContainerMixin<A, D extends DeclaredStatement<A>> extends DataNodeContainer, Mixin<A, D> {
176 default Set<TypeDefinition<?>> getTypeDefinitions() {
177 return filterTypeDefinitions(this);
181 default Collection<DataSchemaNode> getChildNodes() {
182 return filterEffectiveStatements(DataSchemaNode.class);
186 default Set<GroupingDefinition> getGroupings() {
187 return filterEffectiveStatementsSet(GroupingDefinition.class);
191 default Set<UsesNode> getUses() {
192 return filterEffectiveStatementsSet(UsesNode.class);
197 * Bridge between {@link EffectiveStatementWithFlags} and {@link DataSchemaNode}.
199 * @param <A> Argument type ({@link Void} if statement does not have argument.)
200 * @param <D> Class representing declared version of this statement.
202 public interface DataSchemaNodeMixin<A, D extends DeclaredStatement<A>>
203 extends DataSchemaNode, CopyableMixin<A, D>, SchemaNodeMixin<A, D>, WhenConditionMixin<A, D> {
205 default boolean isConfiguration() {
206 return (flags() & FlagsBuilder.CONFIGURATION) != 0;
211 * Bridge between {@link EffectiveStatementWithFlags} and {@link DocumentedNode}.
213 * @param <A> Argument type ({@link Void} if statement does not have argument.)
214 * @param <D> Class representing declared version of this statement.
216 public interface DocumentedNodeMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, DocumentedNode {
218 * Bridge between {@link EffectiveStatementWithFlags} and
219 * {@link org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus}.
221 * @param <A> Argument type ({@link Void} if statement does not have argument.)
222 * @param <D> Class representing declared version of this statement.
224 interface WithStatus<A, D extends DeclaredStatement<A>>
225 extends EffectiveStatementWithFlags<A, D>, DocumentedNodeMixin<A, D>, DocumentedNode.WithStatus {
227 default Status getStatus() {
228 final int status = flags() & FlagsBuilder.MASK_STATUS;
230 case FlagsBuilder.STATUS_CURRENT:
231 return Status.CURRENT;
232 case FlagsBuilder.STATUS_DEPRECATED:
233 return Status.DEPRECATED;
234 case FlagsBuilder.STATUS_OBSOLETE:
235 return Status.OBSOLETE;
237 throw new IllegalStateException("Illegal status " + status);
243 default Optional<String> getDescription() {
244 return findFirstEffectiveSubstatementArgument(DescriptionEffectiveStatement.class);
248 default Optional<String> getReference() {
249 return findFirstEffectiveSubstatementArgument(ReferenceEffectiveStatement.class);
253 default List<UnknownSchemaNode> getUnknownSchemaNodes() {
254 return filterEffectiveStatementsList(UnknownSchemaNode.class);
259 * Bridge between {@link EffectiveStatementWithFlags} and {@link MandatoryAware}.
261 * @param <A> Argument type ({@link Void} if statement does not have argument.)
262 * @param <D> Class representing declared version of this statement.
264 public interface MandatoryMixin<A, D extends DeclaredStatement<A>>
265 extends EffectiveStatementWithFlags<A, D>, MandatoryAware {
267 default boolean isMandatory() {
268 return (flags() & FlagsBuilder.MANDATORY) != 0;
273 * Bridge between {@link EffectiveStatementWithFlags} and {@code presence} statement.
275 * @param <A> Argument type ({@link Void} if statement does not have argument.)
276 * @param <D> Class representing declared version of this statement.
278 public interface PresenceMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
279 default boolean presence() {
280 return (flags() & FlagsBuilder.PRESENCE) != 0;
285 * Bridge between {@link EffectiveStatementWithFlags} and {@link SchemaNode}.
287 * @param <A> Argument type ({@link Void} if statement does not have argument.)
288 * @param <D> Class representing declared version of this statement.
290 public interface SchemaNodeMixin<A, D extends DeclaredStatement<A>>
291 extends DocumentedNodeMixin.WithStatus<A, D>, SchemaNode {
293 default QName getQName() {
294 return getPath().getLastComponent();
299 * Bridge between {@link EffectiveStatementWithFlags} and {@code ordered-by} statement.
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 UserOrderedMixin<A, D extends DeclaredStatement<A>> extends EffectiveStatementWithFlags<A, D> {
305 default boolean userOrdered() {
306 return (flags() & FlagsBuilder.USER_ORDERED) != 0;
311 * Helper used to locate the effective {@code when} statement and exposing its argument as per
312 * {@link WhenConditionAware}.
314 * @param <A> Argument type ({@link Void} if statement does not have argument.)
315 * @param <D> Class representing declared version of this statement.
317 public interface WhenConditionMixin<A, D extends DeclaredStatement<A>> extends Mixin<A, D>, WhenConditionAware {
319 default Optional<RevisionAwareXPath> getWhenCondition() {
320 return findFirstEffectiveSubstatementArgument(WhenEffectiveStatement.class);
325 * Helper bridge for operation containers ({@code input} and {@code output}).
327 * @param <D> Class representing declared version of this statement.
329 public interface OperationContainerMixin<D extends DeclaredStatement<QName>>
330 extends ContainerSchemaNode, DocumentedNodeMixin.WithStatus<QName, D>, DataNodeContainerMixin<QName, D>,
331 MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D>, AugmentationTargetMixin<QName, D>,
332 CopyableMixin<QName, D> {
334 default @NonNull QName argument() {
335 return getPath().getLastComponent();
339 default QName getQName() {
344 default Optional<ActionDefinition> findAction(final QName qname) {
345 return Optional.empty();
349 default Optional<NotificationDefinition> findNotification(final QName qname) {
350 return Optional.empty();
354 default Set<ActionDefinition> getActions() {
355 return ImmutableSet.of();
359 default Set<NotificationDefinition> getNotifications() {
360 return ImmutableSet.of();
364 default boolean isConfiguration() {
369 default boolean isPresenceContainer() {
370 // FIXME: this should not really be here
374 default String defaultToString() {
375 return MoreObjects.toStringHelper(this).add("path", getPath()).toString();
380 * Helper bridge for {@code anydata} and {@code anyxml} opaque data.
382 * @param <D> Class representing declared version of this statement.
384 public interface OpaqueDataSchemaNodeMixin<D extends DeclaredStatement<QName>>
385 extends DerivableSchemaNode, DataSchemaNodeMixin<QName, D>, DocumentedNodeMixin.WithStatus<QName, D>,
386 MandatoryMixin<QName, D>, MustConstraintMixin<QName, D>, WhenConditionMixin<QName, D> {
388 default @NonNull QName argument() {
389 return getPath().getLastComponent();
393 default QName getQName() {
399 * Helper bridge for {@code rpc} and {@code action} operations.
401 * @param <D> Class representing declared version of this statement.
403 public interface OperationDefinitionMixin<D extends DeclaredStatement<QName>>
404 extends SchemaNodeMixin<QName, D>, OperationDefinition {
406 default @NonNull QName argument() {
407 return getPath().getLastComponent();
411 default QName getQName() {
416 default Set<TypeDefinition<?>> getTypeDefinitions() {
417 return filterTypeDefinitions(this);
421 default Set<GroupingDefinition> getGroupings() {
422 return filterEffectiveStatementsSet(GroupingDefinition.class);
426 default ContainerSchemaNode getInput() {
427 return findAsContainer(this, InputEffectiveStatement.class);
431 default ContainerSchemaNode getOutput() {
432 return findAsContainer(this, OutputEffectiveStatement.class);
437 * Support interface for various mixins. Implementations are required to store 32bits worth of flags, which are
438 * globally assigned to sub-interfaces -- thus providing storage for many low-cardinality properties.
440 * @param <A> Argument type ({@link Void} if statement does not have argument.)
441 * @param <D> Class representing declared version of this statement.
443 public interface EffectiveStatementWithFlags<A, D extends DeclaredStatement<A>> extends Mixin<A, D> {
445 * Return flags assicated with this statements. Flags can be built using {@link FlagsBuilder}.
447 * @return Flag field value (32 bits).
452 final class FlagsBuilder implements Mutable {
453 // We still have 24 flags remaining
454 static final int STATUS_CURRENT = 0x0001;
455 static final int STATUS_DEPRECATED = 0x0002;
456 static final int STATUS_OBSOLETE = 0x0003;
457 static final int MASK_STATUS = 0x0003;
459 static final int CONFIGURATION = 0x0004;
460 static final int MANDATORY = 0x0008;
462 static final int AUGMENTING = 0x0010;
463 static final int ADDED_BY_USES = 0x0020;
464 private static final int MASK_HISTORY = 0x0030;
466 static final int USER_ORDERED = 0x0040;
467 static final int PRESENCE = 0x0080;
471 public FlagsBuilder setConfiguration(final boolean config) {
473 flags |= CONFIGURATION;
475 flags &= ~CONFIGURATION;
480 public FlagsBuilder setHistory(final CopyHistory history) {
482 if (history.contains(CopyType.ADDED_BY_USES_AUGMENTATION)) {
483 bits = AUGMENTING | ADDED_BY_USES;
486 if (history.contains(CopyType.ADDED_BY_AUGMENTATION)) {
489 if (history.contains(CopyType.ADDED_BY_USES)) {
490 bits |= ADDED_BY_USES;
494 flags = flags & ~MASK_HISTORY | bits;
498 public FlagsBuilder setMandatory(final boolean mandatory) {
507 public FlagsBuilder setPresence(final boolean presence) {
516 public FlagsBuilder setStatus(final Status status) {
520 bits = STATUS_CURRENT;
523 bits = STATUS_DEPRECATED;
526 bits = STATUS_OBSOLETE;
529 throw new IllegalStateException("Unhandled status " + status);
532 flags = flags & ~MASK_STATUS | bits;
536 public FlagsBuilder setUserOrdered(final boolean userOrdered) {
538 flags |= USER_ORDERED;
540 flags &= ~USER_ORDERED;
545 public int toFlags() {
551 private EffectiveStatementMixins() {
554 static ContainerSchemaNode findAsContainer(final EffectiveStatement<?, ?> stmt,
555 final Class<? extends EffectiveStatement<QName, ?>> type) {
556 final EffectiveStatement<?, ?> statement = stmt.findFirstEffectiveSubstatement(type).get();
557 verify(statement instanceof ContainerSchemaNode, "Child statement %s is not a ContainerSchemaNode",
559 return (ContainerSchemaNode) statement;
562 static Set<TypeDefinition<?>> filterTypeDefinitions(final Mixin<?, ?> stmt) {
563 // TODO: the cast here is needed to work around Java 11 javac type inference issue
564 return (Set) stmt.effectiveSubstatements().stream()
565 .filter(TypedefEffectiveStatement.class::isInstance)
566 .map(typedef -> ((TypedefEffectiveStatement) typedef).getTypeDefinition())
567 .collect(ImmutableSet.toImmutableSet());