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