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 com.google.common.base.Optional;
11 import com.google.common.collect.FluentIterable;
12 import com.google.common.collect.ImmutableMap;
13 import com.google.common.collect.ImmutableSet;
14 import java.util.Collections;
15 import java.util.HashSet;
16 import java.util.List;
18 import java.util.Map.Entry;
20 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.YangInstanceIdentifier.AugmentationIdentifier;
24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
28 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
29 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
30 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
31 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
32 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
33 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
35 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
39 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
40 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
41 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
44 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
45 import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
48 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
50 private final T identifier;
51 private final Optional<DataSchemaNode> dataSchemaNode;
54 public T getIdentifier() {
58 protected DataNormalizationOperation(final T identifier, final SchemaNode schema) {
59 this.identifier = identifier;
60 if (schema instanceof DataSchemaNode) {
61 this.dataSchemaNode = Optional.of((DataSchemaNode) schema);
63 this.dataSchemaNode = Optional.absent();
67 public boolean isMixin() {
72 public boolean isKeyedEntry() {
76 protected Set<QName> getQNameIdentifiers() {
77 return Collections.singleton(identifier.getNodeType());
80 public abstract DataNormalizationOperation<?> getChild(PathArgument child) throws DataNormalizationException;
82 public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
85 public abstract boolean isLeaf();
87 public Optional<DataSchemaNode> getDataSchemaNode() {
89 return dataSchemaNode;
92 private abstract static class SimpleTypeNormalization<T extends PathArgument>
93 extends DataNormalizationOperation<T> {
95 protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
96 super(identifier,potential);
100 public DataNormalizationOperation<?> getChild(final PathArgument child) {
105 public DataNormalizationOperation<?> getChild(final QName child) {
110 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
115 public boolean isLeaf() {
120 private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
122 protected LeafNormalization(final LeafSchemaNode potential) {
123 super(new NodeIdentifier(potential.getQName()),potential);
128 private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
130 LeafListEntryNormalization(final LeafListSchemaNode potential) {
131 super(new NodeWithValue(potential.getQName(), null),potential);
135 public boolean isKeyedEntry() {
140 private abstract static class CompositeNodeNormalizationOperation<T extends PathArgument>
141 extends DataNormalizationOperation<T> {
143 protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
144 super(identifier,schema);
148 public boolean isLeaf() {
155 private abstract static class DataContainerNormalizationOperation<T extends PathArgument>
156 extends CompositeNodeNormalizationOperation<T> {
158 private final DataNodeContainer schema;
159 private final Map<QName, DataNormalizationOperation<?>> byQName;
160 private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
162 protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema,
163 final DataSchemaNode node) {
164 super(identifier,node);
165 this.schema = schema;
166 this.byArg = new ConcurrentHashMap<>();
167 this.byQName = new ConcurrentHashMap<>();
171 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
172 DataNormalizationOperation<?> potential = byArg.get(child);
173 if (potential != null) {
176 potential = fromLocalSchema(child);
177 return register(potential);
181 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
182 DataNormalizationOperation<?> potential = byQName.get(child);
183 if (potential != null) {
186 potential = fromLocalSchemaAndQName(schema, child);
187 return register(potential);
190 private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child)
191 throws DataNormalizationException {
192 if (child instanceof AugmentationIdentifier) {
193 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
196 return fromSchemaAndQNameChecked(schema, child.getNodeType());
199 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2,
200 final QName child) throws DataNormalizationException {
201 return fromSchemaAndQNameChecked(schema2, child);
204 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
205 if (potential != null) {
206 byArg.put(potential.getIdentifier(), potential);
207 for (final QName qname : potential.getQNameIdentifiers()) {
208 byQName.put(qname, potential);
216 private static final class ListItemNormalization extends
217 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
219 protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
220 super(identifier, schema, schema);
224 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
225 final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
226 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
227 for (final Entry<QName, Object> keyValue :
228 ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
229 builder.addChild(Builders.leafBuilder()
231 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
234 return builder.build();
239 public boolean isKeyedEntry() {
244 private static final class UnkeyedListItemNormalization
245 extends DataContainerNormalizationOperation<NodeIdentifier> {
247 protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
248 super(new NodeIdentifier(schema.getQName()), schema,schema);
252 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
253 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
258 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
260 protected ContainerNormalization(final ContainerSchemaNode schema) {
261 super(new NodeIdentifier(schema.getQName()),schema, schema);
265 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
266 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
271 private abstract static class MixinNormalizationOp<T extends PathArgument>
272 extends CompositeNodeNormalizationOperation<T> {
274 protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
275 super(identifier,schema);
279 public final boolean isMixin() {
286 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
287 OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
292 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
293 return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
297 private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
299 private final DataNormalizationOperation<?> innerOp;
301 UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
302 super(new NodeIdentifier(potential.getQName()),potential);
303 innerOp = new LeafListEntryNormalization(potential);
307 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
308 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
312 public DataNormalizationOperation<?> getChild(final PathArgument child) {
313 if (child instanceof NodeWithValue) {
320 public DataNormalizationOperation<?> getChild(final QName child) {
321 if (getIdentifier().getNodeType().equals(child)) {
328 private static final class AugmentationNormalization
329 extends DataContainerNormalizationOperation<AugmentationIdentifier> {
331 AugmentationNormalization(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
332 super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
336 public boolean isMixin() {
343 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema,
344 final QName child) throws DataNormalizationException {
345 final Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
346 if (!potential.isPresent()) {
350 final DataSchemaNode result = potential.get();
351 // We try to look up if this node was added by augmentation
352 if (schema instanceof DataSchemaNode && result.isAugmenting()) {
353 return fromAugmentation(schema, (AugmentationTarget) schema, result);
355 return fromDataSchemaNode(result);
359 protected Set<QName> getQNameIdentifiers() {
360 return getIdentifier().getPossibleChildNames();
364 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
365 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
370 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
372 private final ListItemNormalization innerNode;
374 UnorderedMapMixinNormalization(final ListSchemaNode list) {
375 super(new NodeIdentifier(list.getQName()),list);
376 this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
377 Collections.<QName, Object>emptyMap()), list);
381 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
382 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
386 public DataNormalizationOperation<?> getChild(final PathArgument child) {
387 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
394 public DataNormalizationOperation<?> getChild(final QName child) {
395 if (getIdentifier().getNodeType().equals(child)) {
404 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
406 private final UnkeyedListItemNormalization innerNode;
408 UnkeyedListMixinNormalization(final ListSchemaNode list) {
409 super(new NodeIdentifier(list.getQName()),list);
410 this.innerNode = new UnkeyedListItemNormalization(list);
414 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
415 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
419 public DataNormalizationOperation<?> getChild(final PathArgument child) {
420 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
427 public DataNormalizationOperation<?> getChild(final QName child) {
428 if (getIdentifier().getNodeType().equals(child)) {
436 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
438 OrderedMapMixinNormalization(final ListSchemaNode list) {
443 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
444 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
449 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
451 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
452 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
454 protected ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
455 super(new NodeIdentifier(schema.getQName()),schema);
456 final ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
457 final ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder =
458 ImmutableMap.builder();
460 for (final CaseSchemaNode caze : schema.getCases().values()) {
461 for (final DataSchemaNode cazeChild : caze.getChildNodes()) {
462 final DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
463 byArgBuilder.put(childOp.getIdentifier(), childOp);
464 for (final QName qname : childOp.getQNameIdentifiers()) {
465 byQNameBuilder.put(qname, childOp);
469 byQName = byQNameBuilder.build();
470 byArg = byArgBuilder.build();
474 public DataNormalizationOperation<?> getChild(final PathArgument child) {
475 return byArg.get(child);
479 public DataNormalizationOperation<?> getChild(final QName child) {
480 return byQName.get(child);
484 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
485 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
489 private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
491 protected AnyXmlNormalization(final AnyXmlSchemaNode schema) {
492 super(new NodeIdentifier(schema.getQName()), schema);
496 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
501 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
506 public boolean isLeaf() {
511 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
516 private static Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,
518 DataSchemaNode potential = parent.getDataChildByName(child);
519 if (potential == null) {
520 final Iterable<ChoiceSchemaNode> choices = FluentIterable.from(parent.getChildNodes())
521 .filter(ChoiceSchemaNode.class);
522 potential = findChoice(choices, child);
524 return Optional.fromNullable(potential);
527 private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
528 final QName child) throws DataNormalizationException {
530 final Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
531 if (!potential.isPresent()) {
532 throw new DataNormalizationException(String.format(
533 "Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child,
534 schema,schema.getChildNodes()));
537 final DataSchemaNode result = potential.get();
538 // We try to look up if this node was added by augmentation
539 if (schema instanceof DataSchemaNode && result.isAugmenting()) {
540 return fromAugmentation(schema, (AugmentationTarget) schema, result);
542 return fromDataSchemaNode(result);
545 private static ChoiceSchemaNode findChoice(final Iterable<ChoiceSchemaNode> choices, final QName child) {
546 ChoiceSchemaNode foundChoice = null;
547 choiceLoop: for (final ChoiceSchemaNode choice : choices) {
548 for (final CaseSchemaNode caze : choice.getCases().values()) {
549 if (findChildSchemaNode(caze, child).isPresent()) {
550 foundChoice = choice;
558 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchemaNode augmentation) {
559 final ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
560 for (final DataSchemaNode child : augmentation.getChildNodes()) {
561 potentialChildren.add(child.getQName());
563 return new AugmentationIdentifier(potentialChildren.build());
566 private static DataNodeContainer augmentationProxy(final AugmentationSchemaNode augmentation,
567 final DataNodeContainer schema) {
568 final Set<DataSchemaNode> children = new HashSet<>();
569 for (final DataSchemaNode augNode : augmentation.getChildNodes()) {
570 children.add(schema.getDataChildByName(augNode.getQName()));
572 return new EffectiveAugmentationSchema(augmentation, children);
576 * Returns a DataNormalizationOperation for provided child node.
579 * If supplied child is added by Augmentation this operation returns
580 * a DataNormalizationOperation for augmentation,
581 * otherwise returns a DataNormalizationOperation for child as
582 * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
584 private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
585 final AugmentationTarget parentAug, final DataSchemaNode child) {
586 AugmentationSchemaNode augmentation = null;
587 for (final AugmentationSchemaNode aug : parentAug.getAvailableAugmentations()) {
588 final DataSchemaNode potential = aug.getDataChildByName(child.getQName());
589 if (potential != null) {
595 if (augmentation != null) {
596 return new AugmentationNormalization(augmentation, parent);
598 return fromDataSchemaNode(child);
602 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
603 if (potential instanceof ContainerSchemaNode) {
604 return new ContainerNormalization((ContainerSchemaNode) potential);
605 } else if (potential instanceof ListSchemaNode) {
607 return fromListSchemaNode((ListSchemaNode) potential);
608 } else if (potential instanceof LeafSchemaNode) {
609 return new LeafNormalization((LeafSchemaNode) potential);
610 } else if (potential instanceof ChoiceSchemaNode) {
611 return new ChoiceNodeNormalization((ChoiceSchemaNode) potential);
612 } else if (potential instanceof LeafListSchemaNode) {
613 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
614 } else if (potential instanceof AnyXmlSchemaNode) {
615 return new AnyXmlNormalization((AnyXmlSchemaNode) potential);
620 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
621 final List<QName> keyDefinition = potential.getKeyDefinition();
622 if (keyDefinition == null || keyDefinition.isEmpty()) {
623 return new UnkeyedListMixinNormalization(potential);
625 if (potential.isUserOrdered()) {
626 return new OrderedMapMixinNormalization(potential);
628 return new UnorderedMapMixinNormalization(potential);
631 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
632 if (potential.isUserOrdered()) {
633 return new OrderedLeafListMixinNormalization(potential);
635 return new UnorderedLeafListMixinNormalization(potential);
639 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
640 return new ContainerNormalization(ctx);
643 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);