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 com.google.common.base.Optional;
14 import com.google.common.collect.FluentIterable;
15 import com.google.common.collect.ImmutableMap;
16 import com.google.common.collect.ImmutableSet;
18 import java.util.Collections;
19 import java.util.HashSet;
20 import java.util.List;
22 import java.util.Map.Entry;
24 import java.util.concurrent.ConcurrentHashMap;
26 import org.opendaylight.yangtools.concepts.Identifiable;
27 import org.opendaylight.yangtools.yang.common.QName;
28 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
29 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
30 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
31 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
32 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
33 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
34 import org.opendaylight.yangtools.yang.data.api.Node;
35 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
36 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
37 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
38 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
39 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
40 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
41 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
42 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
43 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
44 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
46 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
47 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
48 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
50 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
51 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
52 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
53 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
54 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
56 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
58 private final T identifier;
61 public T getIdentifier() {
65 protected DataNormalizationOperation(final T identifier) {
67 this.identifier = identifier;
70 public boolean isMixin() {
75 public boolean isKeyedEntry() {
79 protected Set<QName> getQNameIdentifiers() {
80 return Collections.singleton(identifier.getNodeType());
83 public abstract DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException;
85 public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
87 public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
89 public abstract boolean isLeaf();
91 private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
93 protected SimpleTypeNormalization(final T identifier) {
98 public NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
99 checkArgument(legacyData != null);
100 checkArgument(legacyData instanceof SimpleNode<?>);
101 return normalizeImpl((SimpleNode<?>) legacyData);
104 protected abstract NormalizedNode<?, ?> normalizeImpl(SimpleNode<?> node);
107 public DataNormalizationOperation<?> getChild(final PathArgument child) {
112 public DataNormalizationOperation<?> getChild(final QName child) {
117 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
122 public boolean isLeaf() {
128 private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
130 protected LeafNormalization(final NodeIdentifier identifier) {
135 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
136 return ImmutableNodes.leafNode(node.getNodeType(), node.getValue());
141 private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
143 public LeafListEntryNormalization(final LeafListSchemaNode potential) {
144 super(new NodeWithValue(potential.getQName(), null));
148 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
149 NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue());
150 return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build();
155 public boolean isKeyedEntry() {
160 private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
161 DataNormalizationOperation<T> {
163 protected CompositeNodeNormalizationOperation(final T identifier) {
167 @SuppressWarnings({ "rawtypes", "unchecked" })
169 public final NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
170 checkArgument(legacyData != null);
171 if (!isMixin() && getIdentifier().getNodeType() != null) {
172 checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
173 "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
175 checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData);
176 CompositeNode compositeNode = (CompositeNode) legacyData;
177 NormalizedNodeContainerBuilder builder = createBuilder(compositeNode);
179 Set<DataNormalizationOperation<?>> usedMixins = new HashSet<>();
180 for (Node<?> childLegacy : compositeNode.getValue()) {
181 final DataNormalizationOperation childOp;
184 childOp = getChild(childLegacy.getNodeType());
185 } catch (DataNormalizationException e) {
186 throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e);
189 // We skip unknown nodes if this node is mixin since
190 // it's nodes and parent nodes are interleaved
191 if (childOp == null && isMixin()) {
195 checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(),
197 if (childOp.isMixin()) {
198 if (usedMixins.contains(childOp)) {
199 // We already run / processed that mixin, so to avoid
200 // duplicity we are skipping next nodes.
203 builder.addChild(childOp.normalize(compositeNode));
204 usedMixins.add(childOp);
206 builder.addChild(childOp.normalize(childLegacy));
209 return builder.build();
213 public boolean isLeaf() {
217 @SuppressWarnings("rawtypes")
218 protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
222 private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
223 CompositeNodeNormalizationOperation<T> {
225 private final DataNodeContainer schema;
226 private final Map<QName, DataNormalizationOperation<?>> byQName;
227 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
229 protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
231 this.schema = schema;
232 this.byArg = new ConcurrentHashMap<>();
233 this.byQName = new ConcurrentHashMap<>();
237 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
238 DataNormalizationOperation<?> potential = byArg.get(child);
239 if (potential != null) {
242 potential = fromLocalSchema(child);
243 return register(potential);
246 private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child) throws DataNormalizationException {
247 if (child instanceof AugmentationIdentifier) {
248 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
251 return fromSchemaAndQNameChecked(schema, child.getNodeType());
255 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
256 DataNormalizationOperation<?> potential = byQName.get(child);
257 if (potential != null) {
260 potential = fromLocalSchemaAndQName(schema, child);
261 return register(potential);
264 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException {
265 return fromSchemaAndQNameChecked(schema2, child);
268 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
269 if (potential != null) {
270 byArg.put(potential.getIdentifier(), potential);
271 for (QName qName : potential.getQNameIdentifiers()) {
272 byQName.put(qName, potential);
280 private static final class ListItemNormalization extends
281 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
283 private final List<QName> keyDefinition;
285 protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
286 super(identifier, schema);
287 keyDefinition = schema.getKeyDefinition();
291 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
292 ImmutableMap.Builder<QName, Object> keys = ImmutableMap.builder();
293 for (QName key : keyDefinition) {
295 SimpleNode<?> valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key),
296 "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key);
297 keys.put(key, valueNode.getValue());
300 return Builders.mapEntryBuilder().withNodeIdentifier(
301 new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build()));
305 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
306 DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
307 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
308 for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
309 builder.addChild(Builders.leafBuilder()
311 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
314 return builder.build();
319 public boolean isKeyedEntry() {
324 private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
326 protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
327 super(new NodeIdentifier(schema.getQName()), schema);
331 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
332 return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
336 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
337 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
342 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
344 protected ContainerNormalization(final ContainerSchemaNode schema) {
345 super(new NodeIdentifier(schema.getQName()), schema);
349 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
350 return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
354 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
355 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
360 private static abstract class MixinNormalizationOp<T extends PathArgument> extends
361 CompositeNodeNormalizationOperation<T> {
363 protected MixinNormalizationOp(final T identifier) {
368 public final boolean isMixin() {
375 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
378 public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
383 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
384 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
388 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
389 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
393 private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
395 private final DataNormalizationOperation<?> innerOp;
397 public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
398 super(new NodeIdentifier(potential.getQName()));
399 innerOp = new LeafListEntryNormalization(potential);
403 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
404 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
408 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
409 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
413 public DataNormalizationOperation<?> getChild(final PathArgument child) {
414 if (child instanceof NodeWithValue) {
421 public DataNormalizationOperation<?> getChild(final QName child) {
422 if (getIdentifier().getNodeType().equals(child)) {
429 private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
431 public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
433 super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema));
437 public boolean isMixin() {
444 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child)
445 throws DataNormalizationException {
446 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
447 if (!potential.isPresent()) {
451 DataSchemaNode result = potential.get();
452 // We try to look up if this node was added by augmentation
453 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
454 return fromAugmentation(schema, (AugmentationTarget) schema, result);
456 return fromDataSchemaNode(result);
460 protected Set<QName> getQNameIdentifiers() {
461 return getIdentifier().getPossibleChildNames();
464 @SuppressWarnings("rawtypes")
466 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
467 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
471 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
472 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
477 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
479 private final ListItemNormalization innerNode;
481 public UnorderedMapMixinNormalization(final ListSchemaNode list) {
482 super(new NodeIdentifier(list.getQName()));
483 this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
484 Collections.<QName, Object> emptyMap()), list);
487 @SuppressWarnings("rawtypes")
489 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
490 return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
494 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
495 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
499 public DataNormalizationOperation<?> getChild(final PathArgument child) {
500 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
507 public DataNormalizationOperation<?> getChild(final QName child) {
508 if (getIdentifier().getNodeType().equals(child)) {
517 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
519 private final UnkeyedListItemNormalization innerNode;
521 public UnkeyedListMixinNormalization(final ListSchemaNode list) {
522 super(new NodeIdentifier(list.getQName()));
523 this.innerNode = new UnkeyedListItemNormalization(list);
526 @SuppressWarnings("rawtypes")
528 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
529 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
533 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
534 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
538 public DataNormalizationOperation<?> getChild(final PathArgument child) {
539 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
546 public DataNormalizationOperation<?> getChild(final QName child) {
547 if (getIdentifier().getNodeType().equals(child)) {
555 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
557 public OrderedMapMixinNormalization(final ListSchemaNode list) {
561 @SuppressWarnings("rawtypes")
563 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
564 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
568 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
569 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
574 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
576 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
577 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
579 protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
580 super(new NodeIdentifier(schema.getQName()));
581 ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
582 ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
584 for (ChoiceCaseNode caze : schema.getCases()) {
585 for (DataSchemaNode cazeChild : caze.getChildNodes()) {
586 DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
587 byArgBuilder.put(childOp.getIdentifier(), childOp);
588 for (QName qname : childOp.getQNameIdentifiers()) {
589 byQNameBuilder.put(qname, childOp);
593 byQName = byQNameBuilder.build();
594 byArg = byArgBuilder.build();
598 public DataNormalizationOperation<?> getChild(final PathArgument child) {
599 return byArg.get(child);
603 public DataNormalizationOperation<?> getChild(final QName child) {
604 return byQName.get(child);
608 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
609 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
613 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
614 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
618 private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
620 protected AnyXmlNormalization( final NodeIdentifier identifier ) {
625 public DataNormalizationOperation<?> getChild( final PathArgument child ) throws DataNormalizationException {
630 public DataNormalizationOperation<?> getChild( final QName child ) throws DataNormalizationException {
635 public NormalizedNode<?, ?> normalize( final Node<?> legacyData ) {
636 NormalizedNodeAttrBuilder<NodeIdentifier, Node<?>, AnyXmlNode> builder =
637 Builders.anyXmlBuilder().withNodeIdentifier(
638 new NodeIdentifier( legacyData.getNodeType() ) );
639 builder.withValue(legacyData);
640 return builder.build();
644 public boolean isLeaf() {
649 public NormalizedNode<?, ?> createDefault( final PathArgument currentArg ) {
654 private static final Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,final QName child) {
655 DataSchemaNode potential = parent.getDataChildByName(child);
656 if (potential == null) {
657 Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices = FluentIterable.from(
658 parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class);
659 potential = findChoice(choices, child);
661 return Optional.fromNullable(potential);
664 private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
665 final QName child) throws DataNormalizationException {
667 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
668 if (!potential.isPresent()) {
669 throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
672 DataSchemaNode result = potential.get();
673 // We try to look up if this node was added by augmentation
674 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
675 return fromAugmentation(schema, (AugmentationTarget) schema, result);
677 return fromDataSchemaNode(result);
680 private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice(
681 final Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices, final QName child) {
682 org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null;
683 choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) {
684 for (ChoiceCaseNode caze : choice.getCases()) {
685 if (findChildSchemaNode(caze, child).isPresent()) {
686 foundChoice = choice;
694 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
695 ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
696 for (DataSchemaNode child : augmentation.getChildNodes()) {
697 potentialChildren.add(child.getQName());
699 return new AugmentationIdentifier(potentialChildren.build());
702 private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
703 Set<DataSchemaNode> children = new HashSet<>();
704 for (DataSchemaNode augNode : augmentation.getChildNodes()) {
705 children.add(schema.getDataChildByName(augNode.getQName()));
707 return new DataSchemaContainerProxy(children);
711 * Returns a DataNormalizationOperation for provided child node
713 * If supplied child is added by Augmentation this operation returns
714 * a DataNormalizationOperation for augmentation,
715 * otherwise returns a DataNormalizationOperation for child as
716 * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
724 private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
725 final AugmentationTarget parentAug, final DataSchemaNode child) {
726 AugmentationSchema augmentation = null;
727 for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
728 DataSchemaNode potential = aug.getDataChildByName(child.getQName());
729 if (potential != null) {
735 if (augmentation != null) {
736 return new AugmentationNormalization(augmentation, parent);
738 return fromDataSchemaNode(child);
742 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
743 if (potential instanceof ContainerSchemaNode) {
744 return new ContainerNormalization((ContainerSchemaNode) potential);
745 } else if (potential instanceof ListSchemaNode) {
747 return fromListSchemaNode((ListSchemaNode) potential);
748 } else if (potential instanceof LeafSchemaNode) {
749 return new LeafNormalization(new NodeIdentifier(potential.getQName()));
750 } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
751 return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential);
752 } else if (potential instanceof LeafListSchemaNode) {
753 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
754 } else if (potential instanceof AnyXmlSchemaNode) {
755 return new AnyXmlNormalization( new NodeIdentifier(potential.getQName() ) );
760 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
761 List<QName> keyDefinition = potential.getKeyDefinition();
762 if(keyDefinition == null || keyDefinition.isEmpty()) {
763 return new UnkeyedListMixinNormalization(potential);
765 if(potential.isUserOrdered()) {
766 return new OrderedMapMixinNormalization(potential);
768 return new UnorderedMapMixinNormalization(potential);
771 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
772 if(potential.isUserOrdered()) {
773 return new OrderedLeafListMixinNormalization(potential);
775 return new UnorderedLeafListMixinNormalization(potential);
779 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
780 return new ContainerNormalization(ctx);
783 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);