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.AugmentationSchema;
34 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
35 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
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;
47 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
49 private final T identifier;
50 private final Optional<DataSchemaNode> dataSchemaNode;
53 public T getIdentifier() {
57 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(final 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 static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
94 protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) {
95 super(identifier,potential);
99 public DataNormalizationOperation<?> getChild(final PathArgument child) {
104 public DataNormalizationOperation<?> getChild(final QName child) {
109 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
114 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 public LeafListEntryNormalization(final LeafListSchemaNode potential) {
131 super(new NodeWithValue(potential.getQName(), null),potential);
135 public boolean isKeyedEntry() {
140 private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
141 DataNormalizationOperation<T> {
143 protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) {
144 super(identifier,schema);
148 public boolean isLeaf() {
155 private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
156 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, final DataSchemaNode node) {
163 super(identifier,node);
164 this.schema = schema;
165 this.byArg = new ConcurrentHashMap<>();
166 this.byQName = new ConcurrentHashMap<>();
170 public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
171 DataNormalizationOperation<?> potential = byArg.get(child);
172 if (potential != null) {
175 potential = fromLocalSchema(child);
176 return register(potential);
179 private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child) throws DataNormalizationException {
180 if (child instanceof AugmentationIdentifier) {
181 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
184 return fromSchemaAndQNameChecked(schema, child.getNodeType());
188 public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
189 DataNormalizationOperation<?> potential = byQName.get(child);
190 if (potential != null) {
193 potential = fromLocalSchemaAndQName(schema, child);
194 return register(potential);
197 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException {
198 return fromSchemaAndQNameChecked(schema2, child);
201 private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
202 if (potential != null) {
203 byArg.put(potential.getIdentifier(), potential);
204 for (QName qName : potential.getQNameIdentifiers()) {
205 byQName.put(qName, potential);
213 private static final class ListItemNormalization extends
214 DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
216 private final List<QName> keyDefinition;
218 protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
219 super(identifier, schema,schema);
220 keyDefinition = schema.getKeyDefinition();
224 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
225 DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
226 .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
227 for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
228 builder.addChild(Builders.leafBuilder()
230 .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
233 return builder.build();
238 public boolean isKeyedEntry() {
243 private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
245 protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
246 super(new NodeIdentifier(schema.getQName()), schema,schema);
250 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
251 return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
256 private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
258 protected ContainerNormalization(final ContainerSchemaNode schema) {
259 super(new NodeIdentifier(schema.getQName()),schema, schema);
263 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
264 return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
269 private static abstract class MixinNormalizationOp<T extends PathArgument> extends
270 CompositeNodeNormalizationOperation<T> {
272 protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) {
273 super(identifier,schema);
277 public final boolean isMixin() {
284 private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
287 public 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 public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
302 super(new NodeIdentifier(potential.getQName()),potential);
303 innerOp = new LeafListEntryNormalization(potential);
306 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
307 return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
311 public DataNormalizationOperation<?> getChild(final PathArgument child) {
312 if (child instanceof NodeWithValue) {
319 public DataNormalizationOperation<?> getChild(final QName child) {
320 if (getIdentifier().getNodeType().equals(child)) {
327 private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
329 public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
331 super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null);
335 public boolean isMixin() {
342 protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child)
343 throws DataNormalizationException {
344 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
345 if (!potential.isPresent()) {
349 DataSchemaNode result = potential.get();
350 // We try to look up if this node was added by augmentation
351 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
352 return fromAugmentation(schema, (AugmentationTarget) schema, result);
354 return fromDataSchemaNode(result);
358 protected Set<QName> getQNameIdentifiers() {
359 return getIdentifier().getPossibleChildNames();
363 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
364 return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
369 private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
371 private final ListItemNormalization innerNode;
373 public UnorderedMapMixinNormalization(final ListSchemaNode list) {
374 super(new NodeIdentifier(list.getQName()),list);
375 this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
376 Collections.<QName, Object> emptyMap()), list);
380 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
381 return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
385 public DataNormalizationOperation<?> getChild(final PathArgument child) {
386 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
393 public DataNormalizationOperation<?> getChild(final QName child) {
394 if (getIdentifier().getNodeType().equals(child)) {
403 private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
405 private final UnkeyedListItemNormalization innerNode;
407 public UnkeyedListMixinNormalization(final ListSchemaNode list) {
408 super(new NodeIdentifier(list.getQName()),list);
409 this.innerNode = new UnkeyedListItemNormalization(list);
413 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
414 return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
418 public DataNormalizationOperation<?> getChild(final PathArgument child) {
419 if (child.getNodeType().equals(getIdentifier().getNodeType())) {
426 public DataNormalizationOperation<?> getChild(final QName child) {
427 if (getIdentifier().getNodeType().equals(child)) {
435 private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
437 public OrderedMapMixinNormalization(final ListSchemaNode list) {
442 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
443 return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
448 private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
450 private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
451 private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
453 protected ChoiceNodeNormalization(final ChoiceSchemaNode schema) {
454 super(new NodeIdentifier(schema.getQName()),schema);
455 ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
456 ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
458 for (ChoiceCaseNode caze : schema.getCases()) {
459 for (DataSchemaNode cazeChild : caze.getChildNodes()) {
460 DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
461 byArgBuilder.put(childOp.getIdentifier(), childOp);
462 for (QName qname : childOp.getQNameIdentifiers()) {
463 byQNameBuilder.put(qname, childOp);
467 byQName = byQNameBuilder.build();
468 byArg = byArgBuilder.build();
472 public DataNormalizationOperation<?> getChild(final PathArgument child) {
473 return byArg.get(child);
477 public DataNormalizationOperation<?> getChild(final QName child) {
478 return byQName.get(child);
482 public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
483 return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
487 private static class AnyXmlNormalization extends DataNormalizationOperation<NodeIdentifier> {
489 protected AnyXmlNormalization( final AnyXmlSchemaNode schema) {
490 super( new NodeIdentifier(schema.getQName()), schema);
494 public DataNormalizationOperation<?> getChild( final PathArgument child ) throws DataNormalizationException {
499 public DataNormalizationOperation<?> getChild( final QName child ) throws DataNormalizationException {
504 public boolean isLeaf() {
509 public NormalizedNode<?, ?> createDefault( final PathArgument currentArg ) {
514 private static final Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,final QName child) {
515 DataSchemaNode potential = parent.getDataChildByName(child);
516 if (potential == null) {
517 Iterable<ChoiceSchemaNode> choices = FluentIterable.from(parent.getChildNodes()).filter(ChoiceSchemaNode.class);
518 potential = findChoice(choices, child);
520 return Optional.fromNullable(potential);
523 private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
524 final QName child) throws DataNormalizationException {
526 Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
527 if (!potential.isPresent()) {
528 throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
531 DataSchemaNode result = potential.get();
532 // We try to look up if this node was added by augmentation
533 if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
534 return fromAugmentation(schema, (AugmentationTarget) schema, result);
536 return fromDataSchemaNode(result);
539 private static ChoiceSchemaNode findChoice(final Iterable<ChoiceSchemaNode> choices, final QName child) {
540 ChoiceSchemaNode foundChoice = null;
541 choiceLoop: for (ChoiceSchemaNode choice : choices) {
542 for (ChoiceCaseNode caze : choice.getCases()) {
543 if (findChildSchemaNode(caze, child).isPresent()) {
544 foundChoice = choice;
552 public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
553 ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
554 for (DataSchemaNode child : augmentation.getChildNodes()) {
555 potentialChildren.add(child.getQName());
557 return new AugmentationIdentifier(potentialChildren.build());
560 private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
561 Set<DataSchemaNode> children = new HashSet<>();
562 for (DataSchemaNode augNode : augmentation.getChildNodes()) {
563 children.add(schema.getDataChildByName(augNode.getQName()));
565 return new DataSchemaContainerProxy(children);
569 * Returns a DataNormalizationOperation for provided child node
571 * If supplied child is added by Augmentation this operation returns
572 * a DataNormalizationOperation for augmentation,
573 * otherwise returns a DataNormalizationOperation for child as
574 * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
582 private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
583 final AugmentationTarget parentAug, final DataSchemaNode child) {
584 AugmentationSchema augmentation = null;
585 for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
586 DataSchemaNode potential = aug.getDataChildByName(child.getQName());
587 if (potential != null) {
593 if (augmentation != null) {
594 return new AugmentationNormalization(augmentation, parent);
596 return fromDataSchemaNode(child);
600 public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
601 if (potential instanceof ContainerSchemaNode) {
602 return new ContainerNormalization((ContainerSchemaNode) potential);
603 } else if (potential instanceof ListSchemaNode) {
605 return fromListSchemaNode((ListSchemaNode) potential);
606 } else if (potential instanceof LeafSchemaNode) {
607 return new LeafNormalization((LeafSchemaNode) potential);
608 } else if (potential instanceof ChoiceSchemaNode) {
609 return new ChoiceNodeNormalization((ChoiceSchemaNode) potential);
610 } else if (potential instanceof LeafListSchemaNode) {
611 return fromLeafListSchemaNode((LeafListSchemaNode) potential);
612 } else if (potential instanceof AnyXmlSchemaNode) {
613 return new AnyXmlNormalization( (AnyXmlSchemaNode) potential);
618 private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
619 List<QName> keyDefinition = potential.getKeyDefinition();
620 if(keyDefinition == null || keyDefinition.isEmpty()) {
621 return new UnkeyedListMixinNormalization(potential);
623 if(potential.isUserOrdered()) {
624 return new OrderedMapMixinNormalization(potential);
626 return new UnorderedMapMixinNormalization(potential);
629 private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
630 if(potential.isUserOrdered()) {
631 return new OrderedLeafListMixinNormalization(potential);
633 return new UnorderedLeafListMixinNormalization(potential);
637 public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
638 return new ContainerNormalization(ctx);
641 public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);