2 * Copyright (c) 2014 Cisco Systems, Inc. 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.controller.md.sal.common.impl.util.compat;
10 import com.google.common.base.Optional;
11 import com.google.common.collect.ImmutableMap;
12 import com.google.common.collect.ImmutableSet;
13 import com.google.common.collect.Iterables;
14 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
15 import java.util.Collections;
16 import java.util.HashSet;
17 import java.util.List;
19 import java.util.Map.Entry;
21 import java.util.concurrent.ConcurrentHashMap;
22 import org.eclipse.jdt.annotation.Nullable;
23 import org.gaul.modernizer_maven_annotations.SuppressModernizer;
24 import org.opendaylight.yangtools.concepts.Identifiable;
25 import org.opendaylight.yangtools.yang.common.QName;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
31 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
33 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
34 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
35 import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
38 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
40 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
41 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
42 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
46 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
47 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
48 import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
51 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
53 private final T identifier;
54 private final DataSchemaNode dataSchemaNode;
57 public T getIdentifier() {
61 protected DataNormalizationOperation(final T identifier, final SchemaNode schema) {
62 this.identifier = identifier;
63 dataSchemaNode = schema instanceof DataSchemaNode ? (DataSchemaNode)schema : null;
66 public boolean isMixin() {
71 public boolean isKeyedEntry() {
75 protected Set<QName> getQNameIdentifiers() {
76 return Collections.singleton(identifier.getNodeType());
79 public abstract DataNormalizationOperation<?> getChild(PathArgument child) throws DataNormalizationException;
81 public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
83 public abstract boolean isLeaf();
86 public Optional<DataSchemaNode> getDataSchemaNode() {
87 return Optional.fromNullable(dataSchemaNode);
90 private abstract static class SimpleTypeNormalization<T extends PathArgument>
91 extends DataNormalizationOperation<T> {
92 SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
93 super(identifier,potential);
97 public DataNormalizationOperation<?> getChild(final PathArgument child) {
102 public DataNormalizationOperation<?> getChild(final QName child) {
107 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
112 public boolean isLeaf() {
117 private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
118 LeafNormalization(final LeafSchemaNode potential) {
119 super(new NodeIdentifier(potential.getQName()),potential);
123 private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
124 LeafListEntryNormalization(final LeafListSchemaNode potential) {
125 super(new NodeWithValue(potential.getQName(), null),potential);
129 public boolean isKeyedEntry() {
134 private abstract static class CompositeNodeNormalizationOperation<T extends PathArgument>
135 extends DataNormalizationOperation<T> {
136 CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
137 super(identifier,schema);
141 public boolean isLeaf() {
146 private abstract static class DataContainerNormalizationOperation<T extends PathArgument>
147 extends CompositeNodeNormalizationOperation<T> {
148 private final DataNodeContainer schema;
149 private final Map<QName, DataNormalizationOperation<?>> byQName;
150 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
152 DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema,
153 final DataSchemaNode node) {
154 super(identifier,node);
155 this.schema = schema;
156 this.byArg = new ConcurrentHashMap<>();
157 this.byQName = new ConcurrentHashMap<>();
161 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
162 DataNormalizationOperation<?> potential = byArg.get(child);
163 if (potential != null) {
166 potential = fromLocalSchema(child);
167 return register(potential);
171 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
172 DataNormalizationOperation<?> potential = byQName.get(child);
173 if (potential != null) {
176 potential = fromLocalSchemaAndQName(schema, child);
177 return register(potential);
180 private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child)
181 throws DataNormalizationException {
182 if (child instanceof AugmentationIdentifier) {
183 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
186 return fromSchemaAndQNameChecked(schema, child.getNodeType());
189 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2,
190 final QName child) throws DataNormalizationException {
191 return fromSchemaAndQNameChecked(schema2, child);
194 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
195 if (potential != null) {
196 byArg.put(potential.getIdentifier(), potential);
197 for (final QName qname : potential.getQNameIdentifiers()) {
198 byQName.put(qname, potential);
204 private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
205 final QName child) throws DataNormalizationException {
207 final DataSchemaNode result = findChildSchemaNode(schema, child);
208 if (result == null) {
209 throw new DataNormalizationException(String.format(
210 "Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child,
211 schema,schema.getChildNodes()));
214 // We try to look up if this node was added by augmentation
215 if (schema instanceof DataSchemaNode && result.isAugmenting()) {
216 return fromAugmentation(schema, (AugmentationTarget) schema, result);
218 return fromDataSchemaNode(result);
222 private static final class ListItemNormalization extends
223 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
224 ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
225 super(identifier, schema, schema);
229 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
230 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
231 final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
232 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
233 for (final Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).entrySet()) {
234 builder.addChild(Builders.leafBuilder()
236 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
239 return builder.build();
243 public boolean isKeyedEntry() {
248 private static final class UnkeyedListItemNormalization
249 extends DataContainerNormalizationOperation<NodeIdentifier> {
250 UnkeyedListItemNormalization(final ListSchemaNode schema) {
251 super(new NodeIdentifier(schema.getQName()), schema,schema);
255 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
256 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
257 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
261 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
262 ContainerNormalization(final ContainerSchemaNode schema) {
263 super(new NodeIdentifier(schema.getQName()),schema, schema);
267 @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
268 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
269 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
273 private abstract static class MixinNormalizationOp<T extends PathArgument>
274 extends CompositeNodeNormalizationOperation<T> {
276 MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
277 super(identifier,schema);
281 public final boolean isMixin() {
286 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
287 OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
292 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
293 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
297 private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
299 private final DataNormalizationOperation<?> innerOp;
301 UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
302 super(new NodeIdentifier(potential.getQName()),potential);
303 innerOp = new LeafListEntryNormalization(potential);
307 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
308 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
312 public DataNormalizationOperation<?> getChild(final PathArgument child) {
313 if (child instanceof NodeWithValue) {
320 public DataNormalizationOperation<?> getChild(final QName child) {
321 if (getIdentifier().getNodeType().equals(child)) {
328 private static final class AugmentationNormalization
329 extends DataContainerNormalizationOperation<AugmentationIdentifier> {
331 AugmentationNormalization(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
332 super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
335 private static DataNodeContainer augmentationProxy(final AugmentationSchemaNode augmentation,
336 final DataNodeContainer schema) {
337 final Set<DataSchemaNode> children = new HashSet<>();
338 for (final DataSchemaNode augNode : augmentation.getChildNodes()) {
339 children.add(schema.getDataChildByName(augNode.getQName()));
341 return new EffectiveAugmentationSchema(augmentation, children);
345 public boolean isMixin() {
350 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema,
352 final DataSchemaNode result = findChildSchemaNode(schema, child);
353 if (result == null) {
357 // We try to look up if this node was added by augmentation
358 if (schema instanceof DataSchemaNode && result.isAugmenting()) {
359 return fromAugmentation(schema, (AugmentationTarget) schema, result);
361 return fromDataSchemaNode(result);
365 protected Set<QName> getQNameIdentifiers() {
366 return getIdentifier().getPossibleChildNames();
370 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
371 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
375 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
376 private final ListItemNormalization innerNode;
378 UnorderedMapMixinNormalization(final ListSchemaNode list) {
379 super(new NodeIdentifier(list.getQName()),list);
380 this.innerNode = new ListItemNormalization(NodeIdentifierWithPredicates.of(list.getQName(),
381 Collections.<QName, Object>emptyMap()), list);
385 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
386 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
390 public DataNormalizationOperation<?> getChild(final PathArgument child) {
391 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
398 public DataNormalizationOperation<?> getChild(final QName child) {
399 if (getIdentifier().getNodeType().equals(child)) {
406 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
407 private final UnkeyedListItemNormalization innerNode;
409 UnkeyedListMixinNormalization(final ListSchemaNode list) {
410 super(new NodeIdentifier(list.getQName()),list);
411 this.innerNode = new UnkeyedListItemNormalization(list);
415 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
416 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
420 public DataNormalizationOperation<?> getChild(final PathArgument child) {
421 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
428 public DataNormalizationOperation<?> getChild(final QName child) {
429 if (getIdentifier().getNodeType().equals(child)) {
436 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
437 OrderedMapMixinNormalization(final ListSchemaNode list) {
442 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
443 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
447 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
448 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
449 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
451 ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
452 super(new NodeIdentifier(schema.getQName()),schema);
453 final ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
454 final ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder =
455 ImmutableMap.builder();
457 for (final CaseSchemaNode caze : schema.getCases().values()) {
458 for (final DataSchemaNode cazeChild : caze.getChildNodes()) {
459 final DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
460 byArgBuilder.put(childOp.getIdentifier(), childOp);
461 for (final QName qname : childOp.getQNameIdentifiers()) {
462 byQNameBuilder.put(qname, childOp);
466 byQName = byQNameBuilder.build();
467 byArg = byArgBuilder.build();
471 public DataNormalizationOperation<?> getChild(final PathArgument child) {
472 return byArg.get(child);
476 public DataNormalizationOperation<?> getChild(final QName child) {
477 return byQName.get(child);
481 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
482 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
486 private static class AnyxmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
487 AnyxmlNormalization(final AnyxmlSchemaNode schema) {
488 super(new NodeIdentifier(schema.getQName()), schema);
492 public DataNormalizationOperation<?> getChild(final PathArgument child) {
497 public DataNormalizationOperation<?> getChild(final QName child) {
502 public boolean isLeaf() {
507 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
512 private static @Nullable DataSchemaNode findChildSchemaNode(final DataNodeContainer parent, final QName child) {
513 final DataSchemaNode potential = parent.getDataChildByName(child);
514 return potential != null ? potential : findChoice(parent, child);
517 private static @Nullable ChoiceSchemaNode findChoice(final DataNodeContainer parent, final QName child) {
518 for (final ChoiceSchemaNode choice : Iterables.filter(parent.getChildNodes(), ChoiceSchemaNode.class)) {
519 for (final CaseSchemaNode caze : choice.getCases().values()) {
520 if (findChildSchemaNode(caze, child) != null) {
528 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchemaNode augmentation) {
529 final ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
530 for (final DataSchemaNode child : augmentation.getChildNodes()) {
531 potentialChildren.add(child.getQName());
533 return new AugmentationIdentifier(potentialChildren.build());
537 * Returns a DataNormalizationOperation for provided child node.
540 * If supplied child is added by Augmentation this operation returns
541 * a DataNormalizationOperation for augmentation,
542 * otherwise returns a DataNormalizationOperation for child as
543 * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
545 @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD",
546 justification = "https://github.com/spotbugs/spotbugs/issues/811")
547 private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
548 final AugmentationTarget parentAug, final DataSchemaNode child) {
549 AugmentationSchemaNode augmentation = null;
550 for (final AugmentationSchemaNode aug : parentAug.getAvailableAugmentations()) {
551 final DataSchemaNode potential = aug.getDataChildByName(child.getQName());
552 if (potential != null) {
558 if (augmentation != null) {
559 return new AugmentationNormalization(augmentation, parent);
561 return fromDataSchemaNode(child);
565 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
566 if (potential instanceof ContainerSchemaNode) {
567 return new ContainerNormalization((ContainerSchemaNode) potential);
568 } else if (potential instanceof ListSchemaNode) {
570 return fromListSchemaNode((ListSchemaNode) potential);
571 } else if (potential instanceof LeafSchemaNode) {
572 return new LeafNormalization((LeafSchemaNode) potential);
573 } else if (potential instanceof ChoiceSchemaNode) {
574 return new ChoiceNodeNormalization((ChoiceSchemaNode) potential);
575 } else if (potential instanceof LeafListSchemaNode) {
576 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
577 } else if (potential instanceof AnyxmlSchemaNode) {
578 return new AnyxmlNormalization((AnyxmlSchemaNode) potential);
583 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
584 final List<QName> keyDefinition = potential.getKeyDefinition();
585 if (keyDefinition == null || keyDefinition.isEmpty()) {
586 return new UnkeyedListMixinNormalization(potential);
588 if (potential.isUserOrdered()) {
589 return new OrderedMapMixinNormalization(potential);
591 return new UnorderedMapMixinNormalization(potential);
594 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
595 if (potential.isUserOrdered()) {
596 return new OrderedLeafListMixinNormalization(potential);
598 return new UnorderedLeafListMixinNormalization(potential);
602 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
603 return new ContainerNormalization(ctx);
606 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);