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 static com.google.common.base.Preconditions.checkArgument;
11 import static com.google.common.base.Preconditions.checkNotNull;
13 import java.util.Collections;
14 import java.util.HashSet;
15 import java.util.List;
17 import java.util.Map.Entry;
19 import java.util.concurrent.ConcurrentHashMap;
21 import org.opendaylight.yangtools.concepts.Identifiable;
22 import org.opendaylight.yangtools.yang.common.QName;
23 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
24 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
25 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
26 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
27 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
28 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
29 import org.opendaylight.yangtools.yang.data.api.Node;
30 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
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.ImmutableNodes;
35 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
36 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
37 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
38 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
39 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
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;
48 import com.google.common.collect.FluentIterable;
49 import com.google.common.collect.ImmutableMap;
50 import com.google.common.collect.ImmutableSet;
52 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
54 private final T identifier;
57 public T getIdentifier() {
61 protected DataNormalizationOperation(final T identifier) {
63 this.identifier = identifier;
66 public boolean isMixin() {
71 public boolean isKeyedEntry() {
75 protected Set<QName> getQNameIdentifiers() {
76 return Collections.singleton(identifier.getNodeType());
79 public abstract DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException;
81 public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
83 public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
85 private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
87 protected SimpleTypeNormalization(final T identifier) {
92 public NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
93 checkArgument(legacyData != null);
94 checkArgument(legacyData instanceof SimpleNode<?>);
95 return normalizeImpl((SimpleNode<?>) legacyData);
98 protected abstract NormalizedNode<?, ?> normalizeImpl(SimpleNode<?> node);
101 public DataNormalizationOperation<?> getChild(final PathArgument child) {
106 public DataNormalizationOperation<?> getChild(final QName child) {
111 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
117 private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
119 protected LeafNormalization(final NodeIdentifier identifier) {
124 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
125 return ImmutableNodes.leafNode(node.getNodeType(), node.getValue());
130 private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
132 public LeafListEntryNormalization(final LeafListSchemaNode potential) {
133 super(new NodeWithValue(potential.getQName(), null));
137 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
138 NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue());
139 return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build();
144 public boolean isKeyedEntry() {
149 private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
150 DataNormalizationOperation<T> {
152 protected CompositeNodeNormalizationOperation(final T identifier) {
156 @SuppressWarnings({ "rawtypes", "unchecked" })
158 public final NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
159 checkArgument(legacyData != null);
160 if (!isMixin() && getIdentifier().getNodeType() != null) {
161 checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
162 "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
164 checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData);
165 CompositeNode compositeNode = (CompositeNode) legacyData;
166 NormalizedNodeContainerBuilder builder = createBuilder(compositeNode);
168 Set<DataNormalizationOperation<?>> usedMixins = new HashSet<>();
169 for (Node<?> childLegacy : compositeNode.getValue()) {
170 final DataNormalizationOperation childOp;
173 childOp = getChild(childLegacy.getNodeType());
174 } catch (DataNormalizationException e) {
175 throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e);
178 // We skip unknown nodes if this node is mixin since
179 // it's nodes and parent nodes are interleaved
180 if (childOp == null && isMixin()) {
184 checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(),
186 if (childOp.isMixin()) {
187 if (usedMixins.contains(childOp)) {
188 // We already run / processed that mixin, so to avoid
189 // duplicity we are skipping next nodes.
192 builder.addChild(childOp.normalize(compositeNode));
193 usedMixins.add(childOp);
195 builder.addChild(childOp.normalize(childLegacy));
198 return builder.build();
201 @SuppressWarnings("rawtypes")
202 protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
206 private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
207 CompositeNodeNormalizationOperation<T> {
209 private final DataNodeContainer schema;
210 private final Map<QName, DataNormalizationOperation<?>> byQName;
211 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
213 protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
215 this.schema = schema;
216 this.byArg = new ConcurrentHashMap<>();
217 this.byQName = new ConcurrentHashMap<>();
221 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
222 DataNormalizationOperation<?> potential = byArg.get(child);
223 if (potential != null) {
226 potential = fromSchema(schema, child);
227 return register(potential);
231 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
232 DataNormalizationOperation<?> potential = byQName.get(child);
233 if (potential != null) {
236 potential = fromSchemaAndPathArgument(schema, child);
237 return register(potential);
240 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
241 if (potential != null) {
242 byArg.put(potential.getIdentifier(), potential);
243 for (QName qName : potential.getQNameIdentifiers()) {
244 byQName.put(qName, potential);
252 private static final class ListItemNormalization extends
253 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
255 private final List<QName> keyDefinition;
257 protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
258 super(identifier, schema);
259 keyDefinition = schema.getKeyDefinition();
263 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
264 ImmutableMap.Builder<QName, Object> keys = ImmutableMap.builder();
265 for (QName key : keyDefinition) {
267 SimpleNode<?> valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key),
268 "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key);
269 keys.put(key, valueNode.getValue());
272 return Builders.mapEntryBuilder().withNodeIdentifier(
273 new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build()));
277 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
278 DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
279 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
280 for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
281 builder.addChild(Builders.leafBuilder()
283 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
286 return builder.build();
291 public boolean isKeyedEntry() {
296 private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
298 protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
299 super(new NodeIdentifier(schema.getQName()), schema);
303 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
304 return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
308 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
309 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
314 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
316 protected ContainerNormalization(final ContainerSchemaNode schema) {
317 super(new NodeIdentifier(schema.getQName()), schema);
321 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
322 return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
326 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
327 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
332 private static abstract class MixinNormalizationOp<T extends PathArgument> extends
333 CompositeNodeNormalizationOperation<T> {
335 protected MixinNormalizationOp(final T identifier) {
340 public final boolean isMixin() {
347 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
350 public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
355 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
356 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
360 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
361 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
365 private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
367 private final DataNormalizationOperation<?> innerOp;
369 public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
370 super(new NodeIdentifier(potential.getQName()));
371 innerOp = new LeafListEntryNormalization(potential);
375 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
376 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
380 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
381 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
385 public DataNormalizationOperation<?> getChild(final PathArgument child) {
386 if (child instanceof NodeWithValue) {
393 public DataNormalizationOperation<?> getChild(final QName child) {
394 if (getIdentifier().getNodeType().equals(child)) {
401 private static final class AugmentationNormalization extends MixinNormalizationOp<AugmentationIdentifier> {
403 private final Map<QName, DataNormalizationOperation<?>> byQName;
404 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
406 public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
407 super(augmentationIdentifierFrom(augmentation));
409 ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
410 ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
412 for (DataSchemaNode augNode : augmentation.getChildNodes()) {
413 DataSchemaNode resolvedNode = schema.getDataChildByName(augNode.getQName());
414 DataNormalizationOperation<?> resolvedOp = fromDataSchemaNode(resolvedNode);
415 byArgBuilder.put(resolvedOp.getIdentifier(), resolvedOp);
416 for (QName resQName : resolvedOp.getQNameIdentifiers()) {
417 byQNameBuilder.put(resQName, resolvedOp);
420 byQName = byQNameBuilder.build();
421 byArg = byArgBuilder.build();
426 public DataNormalizationOperation<?> getChild(final PathArgument child) {
427 return byArg.get(child);
431 public DataNormalizationOperation<?> getChild(final QName child) {
432 return byQName.get(child);
436 protected Set<QName> getQNameIdentifiers() {
437 return getIdentifier().getPossibleChildNames();
440 @SuppressWarnings("rawtypes")
442 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
443 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
447 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
448 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
453 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
455 private final ListItemNormalization innerNode;
457 public UnorderedMapMixinNormalization(final ListSchemaNode list) {
458 super(new NodeIdentifier(list.getQName()));
459 this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
460 Collections.<QName, Object> emptyMap()), list);
463 @SuppressWarnings("rawtypes")
465 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
466 return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
470 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
471 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
475 public DataNormalizationOperation<?> getChild(final PathArgument child) {
476 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
483 public DataNormalizationOperation<?> getChild(final QName child) {
484 if (getIdentifier().getNodeType().equals(child)) {
493 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
495 private final UnkeyedListItemNormalization innerNode;
497 public UnkeyedListMixinNormalization(final ListSchemaNode list) {
498 super(new NodeIdentifier(list.getQName()));
499 this.innerNode = new UnkeyedListItemNormalization(list);
502 @SuppressWarnings("rawtypes")
504 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
505 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
509 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
510 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
514 public DataNormalizationOperation<?> getChild(final PathArgument child) {
515 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
522 public DataNormalizationOperation<?> getChild(final QName child) {
523 if (getIdentifier().getNodeType().equals(child)) {
531 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
533 public OrderedMapMixinNormalization(final ListSchemaNode list) {
537 @SuppressWarnings("rawtypes")
539 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
540 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
544 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
545 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
550 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
552 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
553 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
555 protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
556 super(new NodeIdentifier(schema.getQName()));
557 ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
558 ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
560 for (ChoiceCaseNode caze : schema.getCases()) {
561 for (DataSchemaNode cazeChild : caze.getChildNodes()) {
562 DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
563 byArgBuilder.put(childOp.getIdentifier(), childOp);
564 for (QName qname : childOp.getQNameIdentifiers()) {
565 byQNameBuilder.put(qname, childOp);
569 byQName = byQNameBuilder.build();
570 byArg = byArgBuilder.build();
574 public DataNormalizationOperation<?> getChild(final PathArgument child) {
575 return byArg.get(child);
579 public DataNormalizationOperation<?> getChild(final QName child) {
580 return byQName.get(child);
584 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
585 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
589 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
590 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
594 private static DataNormalizationOperation<?> fromSchemaAndPathArgument(final DataNodeContainer schema,
595 final QName child) throws DataNormalizationException {
596 DataSchemaNode potential = schema.getDataChildByName(child);
597 if (potential == null) {
598 Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices = FluentIterable.from(
599 schema.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class);
600 potential = findChoice(choices, child);
603 if (potential == null) {
604 throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
607 if ((schema instanceof DataSchemaNode) && !((DataSchemaNode) schema).isAugmenting() && potential.isAugmenting()) {
608 return fromAugmentation(schema, (AugmentationTarget) schema, potential);
610 return fromDataSchemaNode(potential);
613 private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice(
614 final Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices, final QName child) {
615 org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null;
616 choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) {
617 for (ChoiceCaseNode caze : choice.getCases()) {
618 if (caze.getDataChildByName(child) != null) {
619 foundChoice = choice;
627 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
628 ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
629 for (DataSchemaNode child : augmentation.getChildNodes()) {
630 potentialChildren.add(child.getQName());
632 return new AugmentationIdentifier(null, potentialChildren.build());
635 private static AugmentationNormalization fromAugmentation(final DataNodeContainer schema,
636 final AugmentationTarget augments, final DataSchemaNode potential) {
637 AugmentationSchema augmentation = null;
638 for (AugmentationSchema aug : augments.getAvailableAugmentations()) {
639 DataSchemaNode child = aug.getDataChildByName(potential.getQName());
646 if (augmentation != null) {
647 return new AugmentationNormalization(augmentation, schema);
653 private static DataNormalizationOperation<?> fromSchema(final DataNodeContainer schema, final PathArgument child) throws DataNormalizationException {
654 if (child instanceof AugmentationIdentifier) {
655 return fromSchemaAndPathArgument(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
658 return fromSchemaAndPathArgument(schema, child.getNodeType());
661 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
662 if (potential instanceof ContainerSchemaNode) {
663 return new ContainerNormalization((ContainerSchemaNode) potential);
664 } else if (potential instanceof ListSchemaNode) {
666 return fromListSchemaNode((ListSchemaNode) potential);
667 } else if (potential instanceof LeafSchemaNode) {
668 return new LeafNormalization(new NodeIdentifier(potential.getQName()));
669 } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
670 return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential);
671 } else if (potential instanceof LeafListSchemaNode) {
672 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
677 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
678 List<QName> keyDefinition = potential.getKeyDefinition();
679 if(keyDefinition == null || keyDefinition.isEmpty()) {
680 return new UnkeyedListMixinNormalization(potential);
682 if(potential.isUserOrdered()) {
683 return new OrderedMapMixinNormalization(potential);
685 return new UnorderedMapMixinNormalization(potential);
688 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
689 if(potential.isUserOrdered()) {
690 return new OrderedLeafListMixinNormalization(potential);
692 return new UnorderedLeafListMixinNormalization(potential);
696 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
697 return new ContainerNormalization(ctx);
700 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);