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.YangInstanceIdentifier.AugmentationIdentifier;
25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.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.AnyXmlNode;
32 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
33 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
34 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
35 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
36 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
37 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
38 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
39 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
40 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
41 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
42 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
43 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
44 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
45 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
46 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
47 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
48 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
50 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
52 import com.google.common.base.Optional;
53 import com.google.common.collect.FluentIterable;
54 import com.google.common.collect.ImmutableMap;
55 import com.google.common.collect.ImmutableSet;
58 * @deprecated This class provides compatibility between {@link CompositeNode} and {@link NormalizedNode}.
59 * Users of this class should use {@link NormalizedNode}s directly.
62 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
64 private final T identifier;
65 private final Optional<DataSchemaNode> dataSchemaNode;
68 public T getIdentifier() {
72 protected DataNormalizationOperation(final T identifier, final SchemaNode schema) {
74 this.identifier = identifier;
75 if(schema instanceof DataSchemaNode) {
76 this.dataSchemaNode = Optional.of((DataSchemaNode) schema);
78 this.dataSchemaNode = Optional.absent();
82 public boolean isMixin() {
87 public boolean isKeyedEntry() {
91 protected Set<QName> getQNameIdentifiers() {
92 return Collections.singleton(identifier.getNodeType());
95 public abstract DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException;
97 public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
99 public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
101 public abstract boolean isLeaf();
103 public Optional<DataSchemaNode> getDataSchemaNode() {
105 return dataSchemaNode;
108 private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
110 protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
111 super(identifier,potential);
115 public NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
116 checkArgument(legacyData != null);
117 checkArgument(legacyData instanceof SimpleNode<?>);
118 return normalizeImpl((SimpleNode<?>) legacyData);
121 protected abstract NormalizedNode<?, ?> normalizeImpl(SimpleNode<?> node);
124 public DataNormalizationOperation<?> getChild(final PathArgument child) {
129 public DataNormalizationOperation<?> getChild(final QName child) {
134 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
139 public boolean isLeaf() {
145 private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
147 protected LeafNormalization(final LeafSchemaNode potential) {
148 super(new NodeIdentifier(potential.getQName()),potential);
152 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
153 return ImmutableNodes.leafNode(node.getNodeType(), node.getValue());
158 private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
160 public LeafListEntryNormalization(final LeafListSchemaNode potential) {
161 super(new NodeWithValue(potential.getQName(), null),potential);
165 protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
166 NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue());
167 return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build();
172 public boolean isKeyedEntry() {
177 private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
178 DataNormalizationOperation<T> {
180 protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
181 super(identifier,schema);
184 @SuppressWarnings({ "rawtypes", "unchecked" })
186 public final NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
187 checkArgument(legacyData != null);
188 if (!isMixin() && getIdentifier().getNodeType() != null) {
189 checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
190 "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
192 checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData);
193 CompositeNode compositeNode = (CompositeNode) legacyData;
194 NormalizedNodeContainerBuilder builder = createBuilder(compositeNode);
196 Set<DataNormalizationOperation<?>> usedMixins = new HashSet<>();
197 for (Node<?> childLegacy : compositeNode.getValue()) {
198 final DataNormalizationOperation childOp;
201 childOp = getChild(childLegacy.getNodeType());
202 } catch (DataNormalizationException e) {
203 throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e);
206 // We skip unknown nodes if this node is mixin since
207 // it's nodes and parent nodes are interleaved
208 if (childOp == null && isMixin()) {
212 checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(),
214 if (childOp.isMixin()) {
215 if (usedMixins.contains(childOp)) {
216 // We already run / processed that mixin, so to avoid
217 // duplicity we are skipping next nodes.
220 builder.addChild(childOp.normalize(compositeNode));
221 usedMixins.add(childOp);
223 builder.addChild(childOp.normalize(childLegacy));
226 return builder.build();
230 public boolean isLeaf() {
234 @SuppressWarnings("rawtypes")
235 protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
239 private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
240 CompositeNodeNormalizationOperation<T> {
242 private final DataNodeContainer schema;
243 private final Map<QName, DataNormalizationOperation<?>> byQName;
244 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
246 protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema, final DataSchemaNode node) {
247 super(identifier,node);
248 this.schema = schema;
249 this.byArg = new ConcurrentHashMap<>();
250 this.byQName = new ConcurrentHashMap<>();
254 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
255 DataNormalizationOperation<?> potential = byArg.get(child);
256 if (potential != null) {
259 potential = fromLocalSchema(child);
260 return register(potential);
263 private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child) throws DataNormalizationException {
264 if (child instanceof AugmentationIdentifier) {
265 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
268 return fromSchemaAndQNameChecked(schema, child.getNodeType());
272 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
273 DataNormalizationOperation<?> potential = byQName.get(child);
274 if (potential != null) {
277 potential = fromLocalSchemaAndQName(schema, child);
278 return register(potential);
281 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException {
282 return fromSchemaAndQNameChecked(schema2, child);
285 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
286 if (potential != null) {
287 byArg.put(potential.getIdentifier(), potential);
288 for (QName qName : potential.getQNameIdentifiers()) {
289 byQName.put(qName, potential);
297 private static final class ListItemNormalization extends
298 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
300 private final List<QName> keyDefinition;
302 protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
303 super(identifier, schema,schema);
304 keyDefinition = schema.getKeyDefinition();
308 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
309 ImmutableMap.Builder<QName, Object> keys = ImmutableMap.builder();
310 for (QName key : keyDefinition) {
312 SimpleNode<?> valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key),
313 "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key);
314 keys.put(key, valueNode.getValue());
317 return Builders.mapEntryBuilder().withNodeIdentifier(
318 new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build()));
322 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
323 DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
324 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
325 for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
326 builder.addChild(Builders.leafBuilder()
328 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
331 return builder.build();
336 public boolean isKeyedEntry() {
341 private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
343 protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
344 super(new NodeIdentifier(schema.getQName()), schema,schema);
348 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
349 return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
353 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
354 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
359 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
361 protected ContainerNormalization(final ContainerSchemaNode schema) {
362 super(new NodeIdentifier(schema.getQName()),schema, schema);
366 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
367 return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
371 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
372 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
377 private static abstract class MixinNormalizationOp<T extends PathArgument> extends
378 CompositeNodeNormalizationOperation<T> {
380 protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
381 super(identifier,schema);
385 public final boolean isMixin() {
392 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
395 public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
400 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
401 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
405 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
406 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
410 private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
412 private final DataNormalizationOperation<?> innerOp;
414 public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
415 super(new NodeIdentifier(potential.getQName()),potential);
416 innerOp = new LeafListEntryNormalization(potential);
420 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
421 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
425 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
426 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
430 public DataNormalizationOperation<?> getChild(final PathArgument child) {
431 if (child instanceof NodeWithValue) {
438 public DataNormalizationOperation<?> getChild(final QName child) {
439 if (getIdentifier().getNodeType().equals(child)) {
446 private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
448 public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
450 super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
454 public boolean isMixin() {
461 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child)
462 throws DataNormalizationException {
463 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
464 if (!potential.isPresent()) {
468 DataSchemaNode result = potential.get();
469 // We try to look up if this node was added by augmentation
470 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
471 return fromAugmentation(schema, (AugmentationTarget) schema, result);
473 return fromDataSchemaNode(result);
477 protected Set<QName> getQNameIdentifiers() {
478 return getIdentifier().getPossibleChildNames();
481 @SuppressWarnings("rawtypes")
483 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
484 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
488 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
489 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
494 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
496 private final ListItemNormalization innerNode;
498 public UnorderedMapMixinNormalization(final ListSchemaNode list) {
499 super(new NodeIdentifier(list.getQName()),list);
500 this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
501 Collections.<QName, Object> emptyMap()), list);
504 @SuppressWarnings("rawtypes")
506 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
507 return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
511 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
512 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
516 public DataNormalizationOperation<?> getChild(final PathArgument child) {
517 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
524 public DataNormalizationOperation<?> getChild(final QName child) {
525 if (getIdentifier().getNodeType().equals(child)) {
534 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
536 private final UnkeyedListItemNormalization innerNode;
538 public UnkeyedListMixinNormalization(final ListSchemaNode list) {
539 super(new NodeIdentifier(list.getQName()),list);
540 this.innerNode = new UnkeyedListItemNormalization(list);
543 @SuppressWarnings("rawtypes")
545 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
546 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
550 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
551 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
555 public DataNormalizationOperation<?> getChild(final PathArgument child) {
556 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
563 public DataNormalizationOperation<?> getChild(final QName child) {
564 if (getIdentifier().getNodeType().equals(child)) {
572 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
574 public OrderedMapMixinNormalization(final ListSchemaNode list) {
578 @SuppressWarnings("rawtypes")
580 protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
581 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
585 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
586 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
591 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
593 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
594 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
596 protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
597 super(new NodeIdentifier(schema.getQName()),schema);
598 ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
599 ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
601 for (ChoiceCaseNode caze : schema.getCases()) {
602 for (DataSchemaNode cazeChild : caze.getChildNodes()) {
603 DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
604 byArgBuilder.put(childOp.getIdentifier(), childOp);
605 for (QName qname : childOp.getQNameIdentifiers()) {
606 byQNameBuilder.put(qname, childOp);
610 byQName = byQNameBuilder.build();
611 byArg = byArgBuilder.build();
615 public DataNormalizationOperation<?> getChild(final PathArgument child) {
616 return byArg.get(child);
620 public DataNormalizationOperation<?> getChild(final QName child) {
621 return byQName.get(child);
625 protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final CompositeNode compositeNode) {
626 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
630 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
631 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
635 private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
637 protected AnyXmlNormalization( final AnyXmlSchemaNode schema) {
638 super( new NodeIdentifier(schema.getQName()), schema);
642 public DataNormalizationOperation<?> getChild( final PathArgument child ) throws DataNormalizationException {
647 public DataNormalizationOperation<?> getChild( final QName child ) throws DataNormalizationException {
652 public NormalizedNode<?, ?> normalize( final Node<?> legacyData ) {
653 NormalizedNodeAttrBuilder<NodeIdentifier, Node<?>, AnyXmlNode> builder =
654 Builders.anyXmlBuilder().withNodeIdentifier(
655 new NodeIdentifier( legacyData.getNodeType() ) );
656 builder.withValue(legacyData);
657 return builder.build();
661 public boolean isLeaf() {
666 public NormalizedNode<?, ?> createDefault( final PathArgument currentArg ) {
671 private static final Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,final QName child) {
672 DataSchemaNode potential = parent.getDataChildByName(child);
673 if (potential == null) {
674 Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices = FluentIterable.from(
675 parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class);
676 potential = findChoice(choices, child);
678 return Optional.fromNullable(potential);
681 private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
682 final QName child) throws DataNormalizationException {
684 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
685 if (!potential.isPresent()) {
686 throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
689 DataSchemaNode result = potential.get();
690 // We try to look up if this node was added by augmentation
691 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
692 return fromAugmentation(schema, (AugmentationTarget) schema, result);
694 return fromDataSchemaNode(result);
697 private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice(
698 final Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices, final QName child) {
699 org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null;
700 choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) {
701 for (ChoiceCaseNode caze : choice.getCases()) {
702 if (findChildSchemaNode(caze, child).isPresent()) {
703 foundChoice = choice;
711 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
712 ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
713 for (DataSchemaNode child : augmentation.getChildNodes()) {
714 potentialChildren.add(child.getQName());
716 return new AugmentationIdentifier(potentialChildren.build());
719 private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
720 Set<DataSchemaNode> children = new HashSet<>();
721 for (DataSchemaNode augNode : augmentation.getChildNodes()) {
722 children.add(schema.getDataChildByName(augNode.getQName()));
724 return new DataSchemaContainerProxy(children);
728 * Returns a DataNormalizationOperation for provided child node
730 * If supplied child is added by Augmentation this operation returns
731 * a DataNormalizationOperation for augmentation,
732 * otherwise returns a DataNormalizationOperation for child as
733 * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
741 private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
742 final AugmentationTarget parentAug, final DataSchemaNode child) {
743 AugmentationSchema augmentation = null;
744 for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
745 DataSchemaNode potential = aug.getDataChildByName(child.getQName());
746 if (potential != null) {
752 if (augmentation != null) {
753 return new AugmentationNormalization(augmentation, parent);
755 return fromDataSchemaNode(child);
759 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
760 if (potential instanceof ContainerSchemaNode) {
761 return new ContainerNormalization((ContainerSchemaNode) potential);
762 } else if (potential instanceof ListSchemaNode) {
764 return fromListSchemaNode((ListSchemaNode) potential);
765 } else if (potential instanceof LeafSchemaNode) {
766 return new LeafNormalization((LeafSchemaNode) potential);
767 } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
768 return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential);
769 } else if (potential instanceof LeafListSchemaNode) {
770 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
771 } else if (potential instanceof AnyXmlSchemaNode) {
772 return new AnyXmlNormalization( (AnyXmlSchemaNode) potential);
777 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
778 List<QName> keyDefinition = potential.getKeyDefinition();
779 if(keyDefinition == null || keyDefinition.isEmpty()) {
780 return new UnkeyedListMixinNormalization(potential);
782 if(potential.isUserOrdered()) {
783 return new OrderedMapMixinNormalization(potential);
785 return new UnorderedMapMixinNormalization(potential);
788 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
789 if(potential.isUserOrdered()) {
790 return new OrderedLeafListMixinNormalization(potential);
792 return new UnorderedLeafListMixinNormalization(potential);
796 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
797 return new ContainerNormalization(ctx);
800 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);