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;
17 import java.util.Collections;
18 import java.util.HashSet;
19 import java.util.List;
21 import java.util.Map.Entry;
23 import java.util.concurrent.ConcurrentHashMap;
24 import org.opendaylight.yangtools.concepts.Identifiable;
25 import org.opendaylight.yangtools.yang.common.QName;
26 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
27 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
28 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
29 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
30 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
31 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
32 import org.opendaylight.yangtools.yang.data.api.Node;
33 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
35 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
36 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
37 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
38 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
39 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
40 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
41 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
42 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
44 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
45 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
46 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
47 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
48 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
50 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
51 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
52 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
54 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
56 private final T identifier;
59 public T getIdentifier() {
63 protected DataNormalizationOperation(final T identifier) {
65 this.identifier = identifier;
68 public boolean isMixin() {
73 public boolean isKeyedEntry() {
77 protected Set<QName> getQNameIdentifiers() {
78 return Collections.singleton(identifier.getNodeType());
81 public abstract DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException;
83 public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
85 public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
87 public abstract boolean isLeaf();
89 private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
91 protected SimpleTypeNormalization(final T identifier) {
96 public NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
97 checkArgument(legacyData != null);
98 checkArgument(legacyData instanceof SimpleNode<?>);
99 return normalizeImpl((SimpleNode<?>) legacyData);
102 protected abstract NormalizedNode<?, ?> normalizeImpl(SimpleNode<?> node);
105 public DataNormalizationOperation<?> getChild(final PathArgument child) {
110 public DataNormalizationOperation<?> getChild(final QName child) {
115 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
120 public boolean isLeaf() {
126 private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
128 protected LeafNormalization(final NodeIdentifier identifier) {
133 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
134 return ImmutableNodes.leafNode(node.getNodeType(), node.getValue());
139 private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
141 public LeafListEntryNormalization(final LeafListSchemaNode potential) {
142 super(new NodeWithValue(potential.getQName(), null));
146 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
147 NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue());
148 return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build();
153 public boolean isKeyedEntry() {
158 private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
159 DataNormalizationOperation<T> {
161 protected CompositeNodeNormalizationOperation(final T identifier) {
165 @SuppressWarnings({ "rawtypes", "unchecked" })
167 public final NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
168 checkArgument(legacyData != null);
169 if (!isMixin() && getIdentifier().getNodeType() != null) {
170 checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
171 "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
173 checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData);
174 CompositeNode compositeNode = (CompositeNode) legacyData;
175 NormalizedNodeContainerBuilder builder = createBuilder(compositeNode);
177 Set<DataNormalizationOperation<?>> usedMixins = new HashSet<>();
178 for (Node<?> childLegacy : compositeNode.getValue()) {
179 final DataNormalizationOperation childOp;
182 childOp = getChild(childLegacy.getNodeType());
183 } catch (DataNormalizationException e) {
184 throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e);
187 // We skip unknown nodes if this node is mixin since
188 // it's nodes and parent nodes are interleaved
189 if (childOp == null && isMixin()) {
193 checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(),
195 if (childOp.isMixin()) {
196 if (usedMixins.contains(childOp)) {
197 // We already run / processed that mixin, so to avoid
198 // duplicity we are skipping next nodes.
201 builder.addChild(childOp.normalize(compositeNode));
202 usedMixins.add(childOp);
204 builder.addChild(childOp.normalize(childLegacy));
207 return builder.build();
211 public boolean isLeaf() {
215 @SuppressWarnings("rawtypes")
216 protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
220 private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
221 CompositeNodeNormalizationOperation<T> {
223 private final DataNodeContainer schema;
224 private final Map<QName, DataNormalizationOperation<?>> byQName;
225 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
227 protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
229 this.schema = schema;
230 this.byArg = new ConcurrentHashMap<>();
231 this.byQName = new ConcurrentHashMap<>();
235 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
236 DataNormalizationOperation<?> potential = byArg.get(child);
237 if (potential != null) {
240 potential = fromLocalSchema(child);
241 return register(potential);
244 private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child) throws DataNormalizationException {
245 if (child instanceof AugmentationIdentifier) {
246 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
249 return fromSchemaAndQNameChecked(schema, child.getNodeType());
253 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
254 DataNormalizationOperation<?> potential = byQName.get(child);
255 if (potential != null) {
258 potential = fromLocalSchemaAndQName(schema, child);
259 return register(potential);
262 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException {
263 return fromSchemaAndQNameChecked(schema2, child);
266 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
267 if (potential != null) {
268 byArg.put(potential.getIdentifier(), potential);
269 for (QName qName : potential.getQNameIdentifiers()) {
270 byQName.put(qName, potential);
278 private static final class ListItemNormalization extends
279 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
281 private final List<QName> keyDefinition;
283 protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
284 super(identifier, schema);
285 keyDefinition = schema.getKeyDefinition();
289 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
290 ImmutableMap.Builder<QName, Object> keys = ImmutableMap.builder();
291 for (QName key : keyDefinition) {
293 SimpleNode<?> valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key),
294 "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key);
295 keys.put(key, valueNode.getValue());
298 return Builders.mapEntryBuilder().withNodeIdentifier(
299 new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build()));
303 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
304 DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
305 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
306 for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
307 builder.addChild(Builders.leafBuilder()
309 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
312 return builder.build();
317 public boolean isKeyedEntry() {
322 private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
324 protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
325 super(new NodeIdentifier(schema.getQName()), schema);
329 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
330 return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
334 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
335 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
340 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
342 protected ContainerNormalization(final ContainerSchemaNode schema) {
343 super(new NodeIdentifier(schema.getQName()), schema);
347 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
348 return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
352 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
353 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
358 private static abstract class MixinNormalizationOp<T extends PathArgument> extends
359 CompositeNodeNormalizationOperation<T> {
361 protected MixinNormalizationOp(final T identifier) {
366 public final boolean isMixin() {
373 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
376 public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
381 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
382 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
386 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
387 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
391 private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
393 private final DataNormalizationOperation<?> innerOp;
395 public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
396 super(new NodeIdentifier(potential.getQName()));
397 innerOp = new LeafListEntryNormalization(potential);
401 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
402 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
406 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
407 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
411 public DataNormalizationOperation<?> getChild(final PathArgument child) {
412 if (child instanceof NodeWithValue) {
419 public DataNormalizationOperation<?> getChild(final QName child) {
420 if (getIdentifier().getNodeType().equals(child)) {
427 private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
429 public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
431 super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema));
435 public boolean isMixin() {
442 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child)
443 throws DataNormalizationException {
444 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
445 if (!potential.isPresent()) {
449 DataSchemaNode result = potential.get();
450 // We try to look up if this node was added by augmentation
451 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
452 return fromAugmentation(schema, (AugmentationTarget) schema, result);
454 return fromDataSchemaNode(result);
458 protected Set<QName> getQNameIdentifiers() {
459 return getIdentifier().getPossibleChildNames();
462 @SuppressWarnings("rawtypes")
464 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
465 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
469 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
470 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
475 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
477 private final ListItemNormalization innerNode;
479 public UnorderedMapMixinNormalization(final ListSchemaNode list) {
480 super(new NodeIdentifier(list.getQName()));
481 this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
482 Collections.<QName, Object> emptyMap()), list);
485 @SuppressWarnings("rawtypes")
487 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
488 return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
492 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
493 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
497 public DataNormalizationOperation<?> getChild(final PathArgument child) {
498 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
505 public DataNormalizationOperation<?> getChild(final QName child) {
506 if (getIdentifier().getNodeType().equals(child)) {
515 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
517 private final UnkeyedListItemNormalization innerNode;
519 public UnkeyedListMixinNormalization(final ListSchemaNode list) {
520 super(new NodeIdentifier(list.getQName()));
521 this.innerNode = new UnkeyedListItemNormalization(list);
524 @SuppressWarnings("rawtypes")
526 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
527 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
531 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
532 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
536 public DataNormalizationOperation<?> getChild(final PathArgument child) {
537 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
544 public DataNormalizationOperation<?> getChild(final QName child) {
545 if (getIdentifier().getNodeType().equals(child)) {
553 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
555 public OrderedMapMixinNormalization(final ListSchemaNode list) {
559 @SuppressWarnings("rawtypes")
561 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
562 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
566 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
567 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
572 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
574 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
575 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
577 protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
578 super(new NodeIdentifier(schema.getQName()));
579 ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
580 ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
582 for (ChoiceCaseNode caze : schema.getCases()) {
583 for (DataSchemaNode cazeChild : caze.getChildNodes()) {
584 DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
585 byArgBuilder.put(childOp.getIdentifier(), childOp);
586 for (QName qname : childOp.getQNameIdentifiers()) {
587 byQNameBuilder.put(qname, childOp);
591 byQName = byQNameBuilder.build();
592 byArg = byArgBuilder.build();
596 public DataNormalizationOperation<?> getChild(final PathArgument child) {
597 return byArg.get(child);
601 public DataNormalizationOperation<?> getChild(final QName child) {
602 return byQName.get(child);
606 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
607 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
611 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
612 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
616 private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
618 protected AnyXmlNormalization( NodeIdentifier identifier ) {
623 public DataNormalizationOperation<?> getChild( PathArgument child ) throws DataNormalizationException {
628 public DataNormalizationOperation<?> getChild( QName child ) throws DataNormalizationException {
633 public NormalizedNode<?, ?> normalize( Node<?> legacyData ) {
634 NormalizedNodeAttrBuilder<NodeIdentifier, Node<?>, AnyXmlNode> builder =
635 Builders.anyXmlBuilder().withNodeIdentifier(
636 new NodeIdentifier( legacyData.getNodeType() ) );
637 builder.withValue(legacyData);
638 return builder.build();
642 public boolean isLeaf() {
647 public NormalizedNode<?, ?> createDefault( PathArgument currentArg ) {
652 private static final Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,final QName child) {
653 DataSchemaNode potential = parent.getDataChildByName(child);
654 if (potential == null) {
655 Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices = FluentIterable.from(
656 parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class);
657 potential = findChoice(choices, child);
659 return Optional.fromNullable(potential);
662 private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
663 final QName child) throws DataNormalizationException {
665 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
666 if (!potential.isPresent()) {
667 throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
670 DataSchemaNode result = potential.get();
671 // We try to look up if this node was added by augmentation
672 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
673 return fromAugmentation(schema, (AugmentationTarget) schema, result);
675 return fromDataSchemaNode(result);
678 private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice(
679 final Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices, final QName child) {
680 org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null;
681 choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) {
682 for (ChoiceCaseNode caze : choice.getCases()) {
683 if (findChildSchemaNode(caze, child).isPresent()) {
684 foundChoice = choice;
692 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
693 ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
694 for (DataSchemaNode child : augmentation.getChildNodes()) {
695 potentialChildren.add(child.getQName());
697 return new AugmentationIdentifier(null, potentialChildren.build());
700 private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
701 Set<DataSchemaNode> children = new HashSet<>();
702 for (DataSchemaNode augNode : augmentation.getChildNodes()) {
703 children.add(schema.getDataChildByName(augNode.getQName()));
705 return new DataSchemaContainerProxy(children);
709 * Returns a DataNormalizationOperation for provided child node
711 * If supplied child is added by Augmentation this operation returns
712 * a DataNormalizationOperation for augmentation,
713 * otherwise returns a DataNormalizationOperation for child as
714 * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
722 private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
723 final AugmentationTarget parentAug, final DataSchemaNode child) {
724 AugmentationSchema augmentation = null;
725 for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
726 DataSchemaNode potential = aug.getDataChildByName(child.getQName());
727 if (potential != null) {
733 if (augmentation != null) {
734 return new AugmentationNormalization(augmentation, parent);
736 return fromDataSchemaNode(child);
740 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
741 if (potential instanceof ContainerSchemaNode) {
742 return new ContainerNormalization((ContainerSchemaNode) potential);
743 } else if (potential instanceof ListSchemaNode) {
745 return fromListSchemaNode((ListSchemaNode) potential);
746 } else if (potential instanceof LeafSchemaNode) {
747 return new LeafNormalization(new NodeIdentifier(potential.getQName()));
748 } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
749 return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential);
750 } else if (potential instanceof LeafListSchemaNode) {
751 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
752 } else if (potential instanceof AnyXmlSchemaNode) {
753 return new AnyXmlNormalization( new NodeIdentifier(potential.getQName() ) );
758 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
759 List<QName> keyDefinition = potential.getKeyDefinition();
760 if(keyDefinition == null || keyDefinition.isEmpty()) {
761 return new UnkeyedListMixinNormalization(potential);
763 if(potential.isUserOrdered()) {
764 return new OrderedMapMixinNormalization(potential);
766 return new UnorderedMapMixinNormalization(potential);
769 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
770 if(potential.isUserOrdered()) {
771 return new OrderedLeafListMixinNormalization(potential);
773 return new UnorderedLeafListMixinNormalization(potential);
777 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
778 return new ContainerNormalization(ctx);
781 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);