opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizationOperation.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.controller.md.sal.common.impl.util.compat;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static com.google.common.base.Preconditions.checkNotNull;
  12
  13 import java.util.Collections;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Map.Entry;
  18 import java.util.Set;
  19 import java.util.concurrent.ConcurrentHashMap;
  20
  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.InstanceIdentifier.AugmentationIdentifier;
  25 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
  26 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
  27 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
  28 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.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.MapEntryNode;
  32 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  33 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  34 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  35 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
  36 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
  37 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  38 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
  39 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  40 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  41 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  42 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  43 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  44 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  45 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  46 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  47
  48 import com.google.common.base.Optional;
  49 import com.google.common.collect.FluentIterable;
  50 import com.google.common.collect.ImmutableMap;
  51 import com.google.common.collect.ImmutableSet;
  52
  53 public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
  54
  55     private final T identifier;
  56
  57     @Override
  58     public T getIdentifier() {
  59         return identifier;
  60     };
  61
  62     protected DataNormalizationOperation(final T identifier) {
  63         super();
  64         this.identifier = identifier;
  65     }
  66
  67     public boolean isMixin() {
  68         return false;
  69     }
  70
  71
  72     public boolean isKeyedEntry() {
  73         return false;
  74     }
  75
  76     protected Set<QName> getQNameIdentifiers() {
  77         return Collections.singleton(identifier.getNodeType());
  78     }
  79
  80     public abstract DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException;
  81
  82     public abstract DataNormalizationOperation<?> getChild(QName child) throws DataNormalizationException;
  83
  84     public abstract NormalizedNode<?, ?> normalize(Node<?> legacyData);
  85
  86     private static abstract class SimpleTypeNormalization<T extends PathArgument> extends DataNormalizationOperation<T> {
  87
  88         protected SimpleTypeNormalization(final T identifier) {
  89             super(identifier);
  90         }
  91
  92         @Override
  93         public NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
  94             checkArgument(legacyData != null);
  95             checkArgument(legacyData instanceof SimpleNode<?>);
  96             return normalizeImpl((SimpleNode<?>) legacyData);
  97         }
  98
  99         protected abstract NormalizedNode<?, ?> normalizeImpl(SimpleNode<?> node);
 100
 101         @Override
 102         public DataNormalizationOperation<?> getChild(final PathArgument child) {
 103             return null;
 104         }
 105
 106         @Override
 107         public DataNormalizationOperation<?> getChild(final QName child) {
 108             return null;
 109         }
 110
 111         @Override
 112         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 113             return null;
 114         }
 115
 116     }
 117
 118     private static final class LeafNormalization extends SimpleTypeNormalization<NodeIdentifier> {
 119
 120         protected LeafNormalization(final NodeIdentifier identifier) {
 121             super(identifier);
 122         }
 123
 124         @Override
 125         protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
 126             return ImmutableNodes.leafNode(node.getNodeType(), node.getValue());
 127         }
 128
 129     }
 130
 131     private static final class LeafListEntryNormalization extends SimpleTypeNormalization<NodeWithValue> {
 132
 133         public LeafListEntryNormalization(final LeafListSchemaNode potential) {
 134             super(new NodeWithValue(potential.getQName(), null));
 135         }
 136
 137         @Override
 138         protected NormalizedNode<?, ?> normalizeImpl(final SimpleNode<?> node) {
 139             NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue());
 140             return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build();
 141         }
 142
 143
 144         @Override
 145         public boolean isKeyedEntry() {
 146             return true;
 147         }
 148     }
 149
 150     private static abstract class CompositeNodeNormalizationOperation<T extends PathArgument> extends
 151             DataNormalizationOperation<T> {
 152
 153         protected CompositeNodeNormalizationOperation(final T identifier) {
 154             super(identifier);
 155         }
 156
 157         @SuppressWarnings({ "rawtypes", "unchecked" })
 158         @Override
 159         public final NormalizedNode<?, ?> normalize(final Node<?> legacyData) {
 160             checkArgument(legacyData != null);
 161             if (!isMixin() && getIdentifier().getNodeType() != null) {
 162                 checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
 163                         "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
 164             }
 165             checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData);
 166             CompositeNode compositeNode = (CompositeNode) legacyData;
 167             NormalizedNodeContainerBuilder builder = createBuilder(compositeNode);
 168
 169             Set<DataNormalizationOperation<?>> usedMixins = new HashSet<>();
 170             for (Node<?> childLegacy : compositeNode.getValue()) {
 171                 final DataNormalizationOperation childOp;
 172
 173                 try {
 174                     childOp = getChild(childLegacy.getNodeType());
 175                 } catch (DataNormalizationException e) {
 176                     throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e);
 177                 }
 178
 179                 // We skip unknown nodes if this node is mixin since
 180                 // it's nodes and parent nodes are interleaved
 181                 if (childOp == null && isMixin()) {
 182                     continue;
 183                 }
 184
 185                 checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(),
 186                         getIdentifier());
 187                 if (childOp.isMixin()) {
 188                     if (usedMixins.contains(childOp)) {
 189                         // We already run / processed that mixin, so to avoid
 190                         // duplicity we are skipping next nodes.
 191                         continue;
 192                     }
 193                     builder.addChild(childOp.normalize(compositeNode));
 194                     usedMixins.add(childOp);
 195                 } else {
 196                     builder.addChild(childOp.normalize(childLegacy));
 197                 }
 198             }
 199             return builder.build();
 200         }
 201
 202         @SuppressWarnings("rawtypes")
 203         protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode);
 204
 205     }
 206
 207     private static abstract class DataContainerNormalizationOperation<T extends PathArgument> extends
 208             CompositeNodeNormalizationOperation<T> {
 209
 210         private final DataNodeContainer schema;
 211         private final Map<QName, DataNormalizationOperation<?>> byQName;
 212         private final Map<PathArgument, DataNormalizationOperation<?>> byArg;
 213
 214         protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
 215             super(identifier);
 216             this.schema = schema;
 217             this.byArg = new ConcurrentHashMap<>();
 218             this.byQName = new ConcurrentHashMap<>();
 219         }
 220
 221         @Override
 222         public DataNormalizationOperation<?> getChild(final PathArgument child) throws DataNormalizationException {
 223             DataNormalizationOperation<?> potential = byArg.get(child);
 224             if (potential != null) {
 225                 return potential;
 226             }
 227             potential = fromLocalSchema(child);
 228             return register(potential);
 229         }
 230
 231         private DataNormalizationOperation<?> fromLocalSchema(final PathArgument child) throws DataNormalizationException {
 232             if (child instanceof AugmentationIdentifier) {
 233                 return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
 234                         .iterator().next());
 235             }
 236             return fromSchemaAndQNameChecked(schema, child.getNodeType());
 237         }
 238
 239         @Override
 240         public DataNormalizationOperation<?> getChild(final QName child) throws DataNormalizationException {
 241             DataNormalizationOperation<?> potential = byQName.get(child);
 242             if (potential != null) {
 243                 return potential;
 244             }
 245             potential = fromLocalSchemaAndQName(schema, child);
 246             return register(potential);
 247         }
 248
 249         protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException {
 250             return fromSchemaAndQNameChecked(schema2, child);
 251         }
 252
 253         private DataNormalizationOperation<?> register(final DataNormalizationOperation<?> potential) {
 254             if (potential != null) {
 255                 byArg.put(potential.getIdentifier(), potential);
 256                 for (QName qName : potential.getQNameIdentifiers()) {
 257                     byQName.put(qName, potential);
 258                 }
 259             }
 260             return potential;
 261         }
 262
 263     }
 264
 265     private static final class ListItemNormalization extends
 266             DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
 267
 268         private final List<QName> keyDefinition;
 269
 270         protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
 271             super(identifier, schema);
 272             keyDefinition = schema.getKeyDefinition();
 273         }
 274
 275         @Override
 276         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 277             ImmutableMap.Builder<QName, Object> keys = ImmutableMap.builder();
 278             for (QName key : keyDefinition) {
 279
 280                 SimpleNode<?> valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key),
 281                         "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key);
 282                 keys.put(key, valueNode.getValue());
 283             }
 284
 285             return Builders.mapEntryBuilder().withNodeIdentifier(
 286                     new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build()));
 287         }
 288
 289         @Override
 290         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 291             DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
 292                     .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg);
 293             for (Entry<QName, Object> keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) {
 294                 builder.addChild(Builders.leafBuilder()
 295                         //
 296                         .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue())
 297                         .build());
 298             }
 299             return builder.build();
 300         }
 301
 302
 303         @Override
 304         public boolean isKeyedEntry() {
 305             return true;
 306         }
 307     }
 308
 309     private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
 310
 311         protected UnkeyedListItemNormalization(final ListSchemaNode schema) {
 312             super(new NodeIdentifier(schema.getQName()), schema);
 313         }
 314
 315         @Override
 316         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 317             return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
 318         }
 319
 320         @Override
 321         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 322             return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
 323         }
 324
 325     }
 326
 327     private static final class ContainerNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
 328
 329         protected ContainerNormalization(final ContainerSchemaNode schema) {
 330             super(new NodeIdentifier(schema.getQName()), schema);
 331         }
 332
 333         @Override
 334         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 335             return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
 336         }
 337
 338         @Override
 339         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 340             return Builders.containerBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build();
 341         }
 342
 343     }
 344
 345     private static abstract class MixinNormalizationOp<T extends PathArgument> extends
 346             CompositeNodeNormalizationOperation<T> {
 347
 348         protected MixinNormalizationOp(final T identifier) {
 349             super(identifier);
 350         }
 351
 352         @Override
 353         public final boolean isMixin() {
 354             return true;
 355         }
 356
 357     }
 358
 359
 360     private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization {
 361
 362
 363         public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
 364             super(potential);
 365         }
 366
 367         @Override
 368         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 369             return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
 370         }
 371
 372         @Override
 373         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 374             return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build();
 375         }
 376     }
 377
 378     private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
 379
 380         private final DataNormalizationOperation<?> innerOp;
 381
 382         public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) {
 383             super(new NodeIdentifier(potential.getQName()));
 384             innerOp = new LeafListEntryNormalization(potential);
 385         }
 386
 387         @Override
 388         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 389             return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
 390         }
 391
 392         @Override
 393         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 394             return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build();
 395         }
 396
 397         @Override
 398         public DataNormalizationOperation<?> getChild(final PathArgument child) {
 399             if (child instanceof NodeWithValue) {
 400                 return innerOp;
 401             }
 402             return null;
 403         }
 404
 405         @Override
 406         public DataNormalizationOperation<?> getChild(final QName child) {
 407             if (getIdentifier().getNodeType().equals(child)) {
 408                 return innerOp;
 409             }
 410             return null;
 411         }
 412     }
 413
 414     private static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
 415
 416         public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) {
 417             //super();
 418             super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema));
 419         }
 420
 421         @Override
 422         public boolean isMixin() {
 423             return true;
 424         }
 425
 426
 427
 428         @Override
 429         protected DataNormalizationOperation<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child)
 430                 throws DataNormalizationException {
 431             Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
 432             if (!potential.isPresent()) {
 433                 return null;
 434             }
 435
 436             DataSchemaNode result = potential.get();
 437             // We try to look up if this node was added by augmentation
 438             if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
 439                 return fromAugmentation(schema, (AugmentationTarget) schema, result);
 440             }
 441             return fromDataSchemaNode(result);
 442         }
 443
 444         @Override
 445         protected Set<QName> getQNameIdentifiers() {
 446             return getIdentifier().getPossibleChildNames();
 447         }
 448
 449         @SuppressWarnings("rawtypes")
 450         @Override
 451         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 452             return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
 453         }
 454
 455         @Override
 456         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 457             return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build();
 458         }
 459
 460     }
 461
 462     private static class UnorderedMapMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
 463
 464         private final ListItemNormalization innerNode;
 465
 466         public UnorderedMapMixinNormalization(final ListSchemaNode list) {
 467             super(new NodeIdentifier(list.getQName()));
 468             this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
 469                     Collections.<QName, Object> emptyMap()), list);
 470         }
 471
 472         @SuppressWarnings("rawtypes")
 473         @Override
 474         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 475             return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
 476         }
 477
 478         @Override
 479         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 480             return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build();
 481         }
 482
 483         @Override
 484         public DataNormalizationOperation<?> getChild(final PathArgument child) {
 485             if (child.getNodeType().equals(getIdentifier().getNodeType())) {
 486                 return innerNode;
 487             }
 488             return null;
 489         }
 490
 491         @Override
 492         public DataNormalizationOperation<?> getChild(final QName child) {
 493             if (getIdentifier().getNodeType().equals(child)) {
 494                 return innerNode;
 495             }
 496             return null;
 497         }
 498
 499     }
 500
 501
 502     private static class UnkeyedListMixinNormalization extends MixinNormalizationOp<NodeIdentifier> {
 503
 504         private final UnkeyedListItemNormalization innerNode;
 505
 506         public UnkeyedListMixinNormalization(final ListSchemaNode list) {
 507             super(new NodeIdentifier(list.getQName()));
 508             this.innerNode = new UnkeyedListItemNormalization(list);
 509         }
 510
 511         @SuppressWarnings("rawtypes")
 512         @Override
 513         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 514             return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
 515         }
 516
 517         @Override
 518         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 519             return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build();
 520         }
 521
 522         @Override
 523         public DataNormalizationOperation<?> getChild(final PathArgument child) {
 524             if (child.getNodeType().equals(getIdentifier().getNodeType())) {
 525                 return innerNode;
 526             }
 527             return null;
 528         }
 529
 530         @Override
 531         public DataNormalizationOperation<?> getChild(final QName child) {
 532             if (getIdentifier().getNodeType().equals(child)) {
 533                 return innerNode;
 534             }
 535             return null;
 536         }
 537
 538     }
 539
 540     private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization {
 541
 542         public OrderedMapMixinNormalization(final ListSchemaNode list) {
 543             super(list);
 544         }
 545
 546         @SuppressWarnings("rawtypes")
 547         @Override
 548         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 549             return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
 550         }
 551
 552         @Override
 553         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 554             return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build();
 555         }
 556
 557     }
 558
 559     private static class ChoiceNodeNormalization extends MixinNormalizationOp<NodeIdentifier> {
 560
 561         private final ImmutableMap<QName, DataNormalizationOperation<?>> byQName;
 562         private final ImmutableMap<PathArgument, DataNormalizationOperation<?>> byArg;
 563
 564         protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) {
 565             super(new NodeIdentifier(schema.getQName()));
 566             ImmutableMap.Builder<QName, DataNormalizationOperation<?>> byQNameBuilder = ImmutableMap.builder();
 567             ImmutableMap.Builder<PathArgument, DataNormalizationOperation<?>> byArgBuilder = ImmutableMap.builder();
 568
 569             for (ChoiceCaseNode caze : schema.getCases()) {
 570                 for (DataSchemaNode cazeChild : caze.getChildNodes()) {
 571                     DataNormalizationOperation<?> childOp = fromDataSchemaNode(cazeChild);
 572                     byArgBuilder.put(childOp.getIdentifier(), childOp);
 573                     for (QName qname : childOp.getQNameIdentifiers()) {
 574                         byQNameBuilder.put(qname, childOp);
 575                     }
 576                 }
 577             }
 578             byQName = byQNameBuilder.build();
 579             byArg = byArgBuilder.build();
 580         }
 581
 582         @Override
 583         public DataNormalizationOperation<?> getChild(final PathArgument child) {
 584             return byArg.get(child);
 585         }
 586
 587         @Override
 588         public DataNormalizationOperation<?> getChild(final QName child) {
 589             return byQName.get(child);
 590         }
 591
 592         @Override
 593         protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) {
 594             return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
 595         }
 596
 597         @Override
 598         public NormalizedNode<?, ?> createDefault(final PathArgument currentArg) {
 599             return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build();
 600         }
 601     }
 602
 603     private static final Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent,final QName child) {
 604         DataSchemaNode potential = parent.getDataChildByName(child);
 605         if (potential == null) {
 606             Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices = FluentIterable.from(
 607                     parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class);
 608             potential = findChoice(choices, child);
 609         }
 610         return Optional.fromNullable(potential);
 611     }
 612
 613     private static DataNormalizationOperation<?> fromSchemaAndQNameChecked(final DataNodeContainer schema,
 614             final QName child) throws DataNormalizationException {
 615
 616         Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
 617         if (!potential.isPresent()) {
 618             throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes()));
 619         }
 620
 621         DataSchemaNode result = potential.get();
 622         // We try to look up if this node was added by augmentation
 623         if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
 624             return fromAugmentation(schema, (AugmentationTarget) schema, result);
 625         }
 626         return fromDataSchemaNode(result);
 627     }
 628
 629     private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice(
 630             final Iterable<org.opendaylight.yangtools.yang.model.api.ChoiceNode> choices, final QName child) {
 631         org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null;
 632         choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) {
 633             for (ChoiceCaseNode caze : choice.getCases()) {
 634                 if (findChildSchemaNode(caze, child).isPresent()) {
 635                     foundChoice = choice;
 636                     break choiceLoop;
 637                 }
 638             }
 639         }
 640         return foundChoice;
 641     }
 642
 643     public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) {
 644         ImmutableSet.Builder<QName> potentialChildren = ImmutableSet.builder();
 645         for (DataSchemaNode child : augmentation.getChildNodes()) {
 646             potentialChildren.add(child.getQName());
 647         }
 648         return new AugmentationIdentifier(null, potentialChildren.build());
 649     }
 650
 651     private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) {
 652         Set<DataSchemaNode> children = new HashSet<>();
 653         for (DataSchemaNode augNode : augmentation.getChildNodes()) {
 654             children.add(schema.getDataChildByName(augNode.getQName()));
 655         }
 656         return new DataSchemaContainerProxy(children);
 657     }
 658
 659     /**
 660      * Returns a DataNormalizationOperation for provided child node
 661      *
 662      * If supplied child is added by Augmentation this operation returns
 663      * a DataNormalizationOperation for augmentation,
 664      * otherwise returns a DataNormalizationOperation for child as
 665      * call for {@link #fromDataSchemaNode(DataSchemaNode)}.
 666      *
 667      *
 668      * @param parent
 669      * @param parentAug
 670      * @param child
 671      * @return
 672      */
 673     private static DataNormalizationOperation<?> fromAugmentation(final DataNodeContainer parent,
 674             final AugmentationTarget parentAug, final DataSchemaNode child) {
 675         AugmentationSchema augmentation = null;
 676         for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) {
 677             DataSchemaNode potential = aug.getDataChildByName(child.getQName());
 678             if (potential != null) {
 679                 augmentation = aug;
 680                 break;
 681             }
 682
 683         }
 684         if (augmentation != null) {
 685             return new AugmentationNormalization(augmentation, parent);
 686         } else {
 687             return fromDataSchemaNode(child);
 688         }
 689     }
 690
 691     public static DataNormalizationOperation<?> fromDataSchemaNode(final DataSchemaNode potential) {
 692         if (potential instanceof ContainerSchemaNode) {
 693             return new ContainerNormalization((ContainerSchemaNode) potential);
 694         } else if (potential instanceof ListSchemaNode) {
 695
 696             return fromListSchemaNode((ListSchemaNode) potential);
 697         } else if (potential instanceof LeafSchemaNode) {
 698             return new LeafNormalization(new NodeIdentifier(potential.getQName()));
 699         } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) {
 700             return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential);
 701         } else if (potential instanceof LeafListSchemaNode) {
 702             return fromLeafListSchemaNode((LeafListSchemaNode) potential);
 703         }
 704         return null;
 705     }
 706
 707     private static DataNormalizationOperation<?> fromListSchemaNode(final ListSchemaNode potential) {
 708         List<QName> keyDefinition = potential.getKeyDefinition();
 709         if(keyDefinition == null || keyDefinition.isEmpty()) {
 710             return new UnkeyedListMixinNormalization(potential);
 711         }
 712         if(potential.isUserOrdered()) {
 713             return new OrderedMapMixinNormalization(potential);
 714         }
 715         return new UnorderedMapMixinNormalization(potential);
 716     }
 717
 718     private static DataNormalizationOperation<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
 719         if(potential.isUserOrdered()) {
 720             return new OrderedLeafListMixinNormalization(potential);
 721         }
 722         return new UnorderedLeafListMixinNormalization(potential);
 723     }
 724
 725
 726     public static DataNormalizationOperation<?> from(final SchemaContext ctx) {
 727         return new ContainerNormalization(ctx);
 728     }
 729
 730     public abstract NormalizedNode<?, ?> createDefault(PathArgument currentArg);
 731 }