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 javax.xml.transform.dom.DOMSource;
22 import org.opendaylight.yangtools.concepts.Identifiable;
23 import org.opendaylight.yangtools.yang.common.QName;
24 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
30 import org.opendaylight.yangtools.yang.data.api.Node;
31 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
34 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
35 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
36 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
37 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
38 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
39 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
40 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
41 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
42 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
43 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
44 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
45 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
46 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
47 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
48 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
50 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
51 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
53 import com.google.common.base.Optional;
54 import com.google.common.collect.FluentIterable;
55 import com.google.common.collect.ImmutableMap;
56 import com.google.common.collect.ImmutableSet;
59 * @deprecated This class provides compatibility between {@link CompositeNode} and {@link NormalizedNode}.
60 * Users of this class should use {@link NormalizedNode}s directly.
63 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
65 private final T identifier;
66 private final Optional<DataSchemaNode> dataSchemaNode;
69 public T getIdentifier() {
73 protected DataNormalizationOperation(final T identifier, final SchemaNode schema) {
75 this.identifier = identifier;
76 if(schema instanceof DataSchemaNode) {
77 this.dataSchemaNode = Optional.of((DataSchemaNode) schema);
79 this.dataSchemaNode = Optional.absent();
83 public boolean isMixin() {
88 public boolean isKeyedEntry() {
92 protected Set<QName> getQNameIdentifiers() {
93 return Collections.singleton(identifier.getNodeType());
96 public abstract DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException;
98 public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
100 public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
102 public abstract boolean isLeaf();
104 public Optional<DataSchemaNode> getDataSchemaNode() {
106 return dataSchemaNode;
109 private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
111 protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
112 super(identifier,potential);
116 public NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
117 checkArgument(legacyData != null);
118 checkArgument(legacyData instanceof SimpleNode<?>);
119 return normalizeImpl((SimpleNode<?>) legacyData);
122 protected abstract NormalizedNode<?, ?> normalizeImpl(SimpleNode<?> node);
125 public DataNormalizationOperation<?> getChild(final PathArgument child) {
130 public DataNormalizationOperation<?> getChild(final QName child) {
135 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
140 public boolean isLeaf() {
146 private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
148 protected LeafNormalization(final LeafSchemaNode potential) {
149 super(new NodeIdentifier(potential.getQName()),potential);
153 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
154 return ImmutableNodes.leafNode(node.getNodeType(), node.getValue());
159 private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
161 public LeafListEntryNormalization(final LeafListSchemaNode potential) {
162 super(new NodeWithValue(potential.getQName(), null),potential);
166 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
167 NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue());
168 return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build();
173 public boolean isKeyedEntry() {
178 private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
179 DataNormalizationOperation<T> {
181 protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
182 super(identifier,schema);
185 @SuppressWarnings({ "rawtypes", "unchecked" })
187 public final NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
188 checkArgument(legacyData != null);
189 if (!isMixin() && getIdentifier().getNodeType() != null) {
190 checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
191 "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
193 checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData);
194 CompositeNode compositeNode = (CompositeNode) legacyData;
195 NormalizedNodeContainerBuilder builder = createBuilder(compositeNode);
197 Set<DataNormalizationOperation<?>> usedMixins = new HashSet<>();
198 for (Node<?> childLegacy : compositeNode.getValue()) {
199 final DataNormalizationOperation childOp;
202 childOp = getChild(childLegacy.getNodeType());
203 } catch (DataNormalizationException e) {
204 throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e);
207 // We skip unknown nodes if this node is mixin since
208 // it's nodes and parent nodes are interleaved
209 if (childOp == null && isMixin()) {
213 checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(),
215 if (childOp.isMixin()) {
216 if (usedMixins.contains(childOp)) {
217 // We already run / processed that mixin, so to avoid
218 // duplicity we are skipping next nodes.
221 builder.addChild(childOp.normalize(compositeNode));
222 usedMixins.add(childOp);
224 builder.addChild(childOp.normalize(childLegacy));
227 return builder.build();
231 public boolean isLeaf() {
235 @SuppressWarnings("rawtypes")
236 protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
240 private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
241 CompositeNodeNormalizationOperation<T> {
243 private final DataNodeContainer schema;
244 private final Map<QName, DataNormalizationOperation<?>> byQName;
245 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
247 protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema, final DataSchemaNode node) {
248 super(identifier,node);
249 this.schema = schema;
250 this.byArg = new ConcurrentHashMap<>();
251 this.byQName = new ConcurrentHashMap<>();
255 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
256 DataNormalizationOperation<?> potential = byArg.get(child);
257 if (potential != null) {
260 potential = fromLocalSchema(child);
261 return register(potential);
264 private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child) throws DataNormalizationException {
265 if (child instanceof AugmentationIdentifier) {
266 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
269 return fromSchemaAndQNameChecked(schema, child.getNodeType());
273 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
274 DataNormalizationOperation<?> potential = byQName.get(child);
275 if (potential != null) {
278 potential = fromLocalSchemaAndQName(schema, child);
279 return register(potential);
282 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException {
283 return fromSchemaAndQNameChecked(schema2, child);
286 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
287 if (potential != null) {
288 byArg.put(potential.getIdentifier(), potential);
289 for (QName qName : potential.getQNameIdentifiers()) {
290 byQName.put(qName, potential);
298 private static final class ListItemNormalization extends
299 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
301 private final List<QName> keyDefinition;
303 protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
304 super(identifier, schema,schema);
305 keyDefinition = schema.getKeyDefinition();
309 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
310 ImmutableMap.Builder<QName, Object> keys = ImmutableMap.builder();
311 for (QName key : keyDefinition) {
313 SimpleNode<?> valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key),
314 "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key);
315 keys.put(key, valueNode.getValue());
318 return Builders.mapEntryBuilder().withNodeIdentifier(
319 new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build()));
323 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
324 DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
325 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
326 for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
327 builder.addChild(Builders.leafBuilder()
329 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
332 return builder.build();
337 public boolean isKeyedEntry() {
342 private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
344 protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
345 super(new NodeIdentifier(schema.getQName()), schema,schema);
349 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
350 return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
354 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
355 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
360 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
362 protected ContainerNormalization(final ContainerSchemaNode schema) {
363 super(new NodeIdentifier(schema.getQName()),schema, schema);
367 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
368 return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
372 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
373 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
378 private static abstract class MixinNormalizationOp<T extends PathArgument> extends
379 CompositeNodeNormalizationOperation<T> {
381 protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
382 super(identifier,schema);
386 public final boolean isMixin() {
393 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
396 public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
401 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
402 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
406 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
407 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
411 private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
413 private final DataNormalizationOperation<?> innerOp;
415 public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
416 super(new NodeIdentifier(potential.getQName()),potential);
417 innerOp = new LeafListEntryNormalization(potential);
421 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
422 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
426 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
427 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
431 public DataNormalizationOperation<?> getChild(final PathArgument child) {
432 if (child instanceof NodeWithValue) {
439 public DataNormalizationOperation<?> getChild(final QName child) {
440 if (getIdentifier().getNodeType().equals(child)) {
447 private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
449 public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
451 super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
455 public boolean isMixin() {
462 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child)
463 throws DataNormalizationException {
464 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
465 if (!potential.isPresent()) {
469 DataSchemaNode result = potential.get();
470 // We try to look up if this node was added by augmentation
471 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
472 return fromAugmentation(schema, (AugmentationTarget) schema, result);
474 return fromDataSchemaNode(result);
478 protected Set<QName> getQNameIdentifiers() {
479 return getIdentifier().getPossibleChildNames();
482 @SuppressWarnings("rawtypes")
484 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
485 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
489 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
490 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
495 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
497 private final ListItemNormalization innerNode;
499 public UnorderedMapMixinNormalization(final ListSchemaNode list) {
500 super(new NodeIdentifier(list.getQName()),list);
501 this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
502 Collections.<QName, Object> emptyMap()), list);
505 @SuppressWarnings("rawtypes")
507 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
508 return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
512 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
513 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
517 public DataNormalizationOperation<?> getChild(final PathArgument child) {
518 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
525 public DataNormalizationOperation<?> getChild(final QName child) {
526 if (getIdentifier().getNodeType().equals(child)) {
535 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
537 private final UnkeyedListItemNormalization innerNode;
539 public UnkeyedListMixinNormalization(final ListSchemaNode list) {
540 super(new NodeIdentifier(list.getQName()),list);
541 this.innerNode = new UnkeyedListItemNormalization(list);
544 @SuppressWarnings("rawtypes")
546 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
547 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
551 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
552 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
556 public DataNormalizationOperation<?> getChild(final PathArgument child) {
557 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
564 public DataNormalizationOperation<?> getChild(final QName child) {
565 if (getIdentifier().getNodeType().equals(child)) {
573 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
575 public OrderedMapMixinNormalization(final ListSchemaNode list) {
579 @SuppressWarnings("rawtypes")
581 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
582 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
586 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
587 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
592 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
594 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
595 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
597 protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
598 super(new NodeIdentifier(schema.getQName()),schema);
599 ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
600 ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
602 for (ChoiceCaseNode caze : schema.getCases()) {
603 for (DataSchemaNode cazeChild : caze.getChildNodes()) {
604 DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
605 byArgBuilder.put(childOp.getIdentifier(), childOp);
606 for (QName qname : childOp.getQNameIdentifiers()) {
607 byQNameBuilder.put(qname, childOp);
611 byQName = byQNameBuilder.build();
612 byArg = byArgBuilder.build();
616 public DataNormalizationOperation<?> getChild(final PathArgument child) {
617 return byArg.get(child);
621 public DataNormalizationOperation<?> getChild(final QName child) {
622 return byQName.get(child);
626 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
627 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
631 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
632 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
636 private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
638 protected AnyXmlNormalization( final AnyXmlSchemaNode schema) {
639 super( new NodeIdentifier(schema.getQName()), schema);
643 public DataNormalizationOperation<?> getChild( final PathArgument child ) throws DataNormalizationException {
648 public DataNormalizationOperation<?> getChild( final QName child ) throws DataNormalizationException {
653 public NormalizedNode<?, ?> normalize( final Node<?> legacyData ) {
654 NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> builder =
655 Builders.anyXmlBuilder().withNodeIdentifier(
656 new NodeIdentifier( legacyData.getNodeType() ) );
658 // builder.withValue(legacyData);
659 return builder.build();
663 public boolean isLeaf() {
668 public NormalizedNode<?, ?> createDefault( final PathArgument currentArg ) {
673 private static final Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,final QName child) {
674 DataSchemaNode potential = parent.getDataChildByName(child);
675 if (potential == null) {
676 Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices = FluentIterable.from(
677 parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class);
678 potential = findChoice(choices, child);
680 return Optional.fromNullable(potential);
683 private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
684 final QName child) throws DataNormalizationException {
686 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
687 if (!potential.isPresent()) {
688 throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
691 DataSchemaNode result = potential.get();
692 // We try to look up if this node was added by augmentation
693 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
694 return fromAugmentation(schema, (AugmentationTarget) schema, result);
696 return fromDataSchemaNode(result);
699 private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice(
700 final Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices, final QName child) {
701 org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null;
702 choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) {
703 for (ChoiceCaseNode caze : choice.getCases()) {
704 if (findChildSchemaNode(caze, child).isPresent()) {
705 foundChoice = choice;
713 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
714 ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
715 for (DataSchemaNode child : augmentation.getChildNodes()) {
716 potentialChildren.add(child.getQName());
718 return new AugmentationIdentifier(potentialChildren.build());
721 private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
722 Set<DataSchemaNode> children = new HashSet<>();
723 for (DataSchemaNode augNode : augmentation.getChildNodes()) {
724 children.add(schema.getDataChildByName(augNode.getQName()));
726 return new DataSchemaContainerProxy(children);
730 * Returns a DataNormalizationOperation for provided child node
732 * If supplied child is added by Augmentation this operation returns
733 * a DataNormalizationOperation for augmentation,
734 * otherwise returns a DataNormalizationOperation for child as
735 * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
743 private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
744 final AugmentationTarget parentAug, final DataSchemaNode child) {
745 AugmentationSchema augmentation = null;
746 for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
747 DataSchemaNode potential = aug.getDataChildByName(child.getQName());
748 if (potential != null) {
754 if (augmentation != null) {
755 return new AugmentationNormalization(augmentation, parent);
757 return fromDataSchemaNode(child);
761 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
762 if (potential instanceof ContainerSchemaNode) {
763 return new ContainerNormalization((ContainerSchemaNode) potential);
764 } else if (potential instanceof ListSchemaNode) {
766 return fromListSchemaNode((ListSchemaNode) potential);
767 } else if (potential instanceof LeafSchemaNode) {
768 return new LeafNormalization((LeafSchemaNode) potential);
769 } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
770 return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential);
771 } else if (potential instanceof LeafListSchemaNode) {
772 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
773 } else if (potential instanceof AnyXmlSchemaNode) {
774 return new AnyXmlNormalization( (AnyXmlSchemaNode) potential);
779 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
780 List<QName> keyDefinition = potential.getKeyDefinition();
781 if(keyDefinition == null || keyDefinition.isEmpty()) {
782 return new UnkeyedListMixinNormalization(potential);
784 if(potential.isUserOrdered()) {
785 return new OrderedMapMixinNormalization(potential);
787 return new UnorderedMapMixinNormalization(potential);
790 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
791 if(potential.isUserOrdered()) {
792 return new OrderedLeafListMixinNormalization(potential);
794 return new UnorderedLeafListMixinNormalization(potential);
798 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
799 return new ContainerNormalization(ctx);
802 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);