X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-common-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fcommon%2Fimpl%2Futil%2Fcompat%2FDataNormalizationOperation.java;h=bbe366016342a7998c961e5028538e56a4b57f9b;hp=7ce475dd59ea1a056ac8d5a85d751a33f6d9a17f;hb=edf86350dae8df2cfad04236eddfb05b29e8bce8;hpb=5e7328e70f420ee4460a9f64f10368175c851370 diff --git a/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizationOperation.java b/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizationOperation.java index 7ce475dd59..bbe3660163 100644 --- a/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizationOperation.java +++ b/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizationOperation.java @@ -7,9 +7,6 @@ */ package org.opendaylight.controller.md.sal.common.impl.util.compat; -import static com.google.common.base.Preconditions.checkArgument; -import static com.google.common.base.Preconditions.checkNotNull; - import com.google.common.base.Optional; import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableMap; @@ -23,26 +20,20 @@ import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.opendaylight.yangtools.concepts.Identifiable; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; -import org.opendaylight.yangtools.yang.data.api.Node; -import org.opendaylight.yangtools.yang.data.api.SimpleNode; -import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.impl.schema.Builders; -import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder; -import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder; import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; +import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; @@ -50,19 +41,28 @@ import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.api.SchemaNode; +import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema; +@Deprecated public abstract class DataNormalizationOperation implements Identifiable { private final T identifier; + private final Optional dataSchemaNode; @Override public T getIdentifier() { return identifier; - }; + } - protected DataNormalizationOperation(final T identifier) { + protected DataNormalizationOperation(final T identifier, final SchemaNode schema) { super(); this.identifier = identifier; + if(schema instanceof DataSchemaNode) { + this.dataSchemaNode = Optional.of((DataSchemaNode) schema); + } else { + this.dataSchemaNode = Optional.absent(); + } } public boolean isMixin() { @@ -82,25 +82,20 @@ public abstract class DataNormalizationOperation impleme public abstract DataNormalizationOperation getChild(QName child) throws DataNormalizationException; - public abstract NormalizedNode normalize(Node legacyData); public abstract boolean isLeaf(); + public Optional getDataSchemaNode() { + // FIXME + return dataSchemaNode; + } + private static abstract class SimpleTypeNormalization extends DataNormalizationOperation { - protected SimpleTypeNormalization(final T identifier) { - super(identifier); + protected SimpleTypeNormalization(final T identifier, final DataSchemaNode potential) { + super(identifier,potential); } - @Override - public NormalizedNode normalize(final Node legacyData) { - checkArgument(legacyData != null); - checkArgument(legacyData instanceof SimpleNode); - return normalizeImpl((SimpleNode) legacyData); - } - - protected abstract NormalizedNode normalizeImpl(SimpleNode node); - @Override public DataNormalizationOperation getChild(final PathArgument child) { return null; @@ -125,13 +120,8 @@ public abstract class DataNormalizationOperation impleme private static final class LeafNormalization extends SimpleTypeNormalization { - protected LeafNormalization(final NodeIdentifier identifier) { - super(identifier); - } - - @Override - protected NormalizedNode normalizeImpl(final SimpleNode node) { - return ImmutableNodes.leafNode(node.getNodeType(), node.getValue()); + protected LeafNormalization(final LeafSchemaNode potential) { + super(new NodeIdentifier(potential.getQName()),potential); } } @@ -139,16 +129,9 @@ public abstract class DataNormalizationOperation impleme private static final class LeafListEntryNormalization extends SimpleTypeNormalization { public LeafListEntryNormalization(final LeafListSchemaNode potential) { - super(new NodeWithValue(potential.getQName(), null)); + super(new NodeWithValue(potential.getQName(), null),potential); } - @Override - protected NormalizedNode normalizeImpl(final SimpleNode node) { - NodeWithValue nodeId = new NodeWithValue(node.getNodeType(), node.getValue()); - return Builders.leafSetEntryBuilder().withNodeIdentifier(nodeId).withValue(node.getValue()).build(); - } - - @Override public boolean isKeyedEntry() { return true; @@ -156,55 +139,10 @@ public abstract class DataNormalizationOperation impleme } private static abstract class CompositeNodeNormalizationOperation extends - DataNormalizationOperation { + DataNormalizationOperation { - protected CompositeNodeNormalizationOperation(final T identifier) { - super(identifier); - } - - @SuppressWarnings({ "rawtypes", "unchecked" }) - @Override - public final NormalizedNode normalize(final Node legacyData) { - checkArgument(legacyData != null); - if (!isMixin() && getIdentifier().getNodeType() != null) { - checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()), - "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType()); - } - checkArgument(legacyData instanceof CompositeNode, "Node %s should be composite", legacyData); - CompositeNode compositeNode = (CompositeNode) legacyData; - NormalizedNodeContainerBuilder builder = createBuilder(compositeNode); - - Set> usedMixins = new HashSet<>(); - for (Node childLegacy : compositeNode.getValue()) { - final DataNormalizationOperation childOp; - - try { - childOp = getChild(childLegacy.getNodeType()); - } catch (DataNormalizationException e) { - throw new IllegalArgumentException(String.format("Failed to normalize data %s", compositeNode.getValue()), e); - } - - // We skip unknown nodes if this node is mixin since - // it's nodes and parent nodes are interleaved - if (childOp == null && isMixin()) { - continue; - } - - checkArgument(childOp != null, "Node %s is not allowed inside %s", childLegacy.getNodeType(), - getIdentifier()); - if (childOp.isMixin()) { - if (usedMixins.contains(childOp)) { - // We already run / processed that mixin, so to avoid - // duplicity we are skipping next nodes. - continue; - } - builder.addChild(childOp.normalize(compositeNode)); - usedMixins.add(childOp); - } else { - builder.addChild(childOp.normalize(childLegacy)); - } - } - return builder.build(); + protected CompositeNodeNormalizationOperation(final T identifier, final DataSchemaNode schema) { + super(identifier,schema); } @Override @@ -212,20 +150,18 @@ public abstract class DataNormalizationOperation impleme return false; } - @SuppressWarnings("rawtypes") - protected abstract NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode); } private static abstract class DataContainerNormalizationOperation extends - CompositeNodeNormalizationOperation { + CompositeNodeNormalizationOperation { private final DataNodeContainer schema; private final Map> byQName; private final Map> byArg; - protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) { - super(identifier); + protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema, final DataSchemaNode node) { + super(identifier,node); this.schema = schema; this.byArg = new ConcurrentHashMap<>(); this.byQName = new ConcurrentHashMap<>(); @@ -266,7 +202,7 @@ public abstract class DataNormalizationOperation impleme private DataNormalizationOperation register(final DataNormalizationOperation potential) { if (potential != null) { byArg.put(potential.getIdentifier(), potential); - for (QName qName : potential.getQNameIdentifiers()) { + for (final QName qName : potential.getQNameIdentifiers()) { byQName.put(qName, potential); } } @@ -276,34 +212,20 @@ public abstract class DataNormalizationOperation impleme } private static final class ListItemNormalization extends - DataContainerNormalizationOperation { + DataContainerNormalizationOperation { private final List keyDefinition; protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) { - super(identifier, schema); + super(identifier, schema,schema); keyDefinition = schema.getKeyDefinition(); } - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - ImmutableMap.Builder keys = ImmutableMap.builder(); - for (QName key : keyDefinition) { - - SimpleNode valueNode = checkNotNull(compositeNode.getFirstSimpleByName(key), - "List node %s MUST contain leaf %s with value.", getIdentifier().getNodeType(), key); - keys.put(key, valueNode.getValue()); - } - - return Builders.mapEntryBuilder().withNodeIdentifier( - new NodeIdentifierWithPredicates(getIdentifier().getNodeType(), keys.build())); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { - DataContainerNodeAttrBuilder builder = Builders + final DataContainerNodeAttrBuilder builder = Builders .mapEntryBuilder().withNodeIdentifier((NodeIdentifierWithPredicates) currentArg); - for (Entry keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) { + for (final Entry keyValue : ((NodeIdentifierWithPredicates) currentArg).getKeyValues().entrySet()) { builder.addChild(Builders.leafBuilder() // .withNodeIdentifier(new NodeIdentifier(keyValue.getKey())).withValue(keyValue.getValue()) @@ -322,12 +244,7 @@ public abstract class DataNormalizationOperation impleme private static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation { protected UnkeyedListItemNormalization(final ListSchemaNode schema) { - super(new NodeIdentifier(schema.getQName()), schema); - } - - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier()); + super(new NodeIdentifier(schema.getQName()), schema,schema); } @Override @@ -340,12 +257,7 @@ public abstract class DataNormalizationOperation impleme private static final class ContainerNormalization extends DataContainerNormalizationOperation { protected ContainerNormalization(final ContainerSchemaNode schema) { - super(new NodeIdentifier(schema.getQName()), schema); - } - - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.containerBuilder().withNodeIdentifier(getIdentifier()); + super(new NodeIdentifier(schema.getQName()),schema, schema); } @Override @@ -356,10 +268,10 @@ public abstract class DataNormalizationOperation impleme } private static abstract class MixinNormalizationOp extends - CompositeNodeNormalizationOperation { + CompositeNodeNormalizationOperation { - protected MixinNormalizationOp(final T identifier) { - super(identifier); + protected MixinNormalizationOp(final T identifier, final DataSchemaNode schema) { + super(identifier,schema); } @Override @@ -377,11 +289,6 @@ public abstract class DataNormalizationOperation impleme super(potential); } - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()).build(); @@ -393,15 +300,9 @@ public abstract class DataNormalizationOperation impleme private final DataNormalizationOperation innerOp; public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) { - super(new NodeIdentifier(potential.getQName())); + super(new NodeIdentifier(potential.getQName()),potential); innerOp = new LeafListEntryNormalization(potential); } - - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()).build(); @@ -428,7 +329,7 @@ public abstract class DataNormalizationOperation impleme public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) { //super(); - super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema)); + super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema),null); } @Override @@ -441,12 +342,12 @@ public abstract class DataNormalizationOperation impleme @Override protected DataNormalizationOperation fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child) throws DataNormalizationException { - Optional potential = findChildSchemaNode(schema, child); + final Optional potential = findChildSchemaNode(schema, child); if (!potential.isPresent()) { return null; } - DataSchemaNode result = potential.get(); + final DataSchemaNode result = potential.get(); // We try to look up if this node was added by augmentation if ((schema instanceof DataSchemaNode) && result.isAugmenting()) { return fromAugmentation(schema, (AugmentationTarget) schema, result); @@ -459,12 +360,6 @@ public abstract class DataNormalizationOperation impleme return getIdentifier().getPossibleChildNames(); } - @SuppressWarnings("rawtypes") - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier()).build(); @@ -477,17 +372,11 @@ public abstract class DataNormalizationOperation impleme private final ListItemNormalization innerNode; public UnorderedMapMixinNormalization(final ListSchemaNode list) { - super(new NodeIdentifier(list.getQName())); + super(new NodeIdentifier(list.getQName()),list); this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(), Collections. emptyMap()), list); } - @SuppressWarnings("rawtypes") - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.mapBuilder().withNodeIdentifier(getIdentifier()); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { return Builders.mapBuilder().withNodeIdentifier(getIdentifier()).build(); @@ -517,16 +406,10 @@ public abstract class DataNormalizationOperation impleme private final UnkeyedListItemNormalization innerNode; public UnkeyedListMixinNormalization(final ListSchemaNode list) { - super(new NodeIdentifier(list.getQName())); + super(new NodeIdentifier(list.getQName()),list); this.innerNode = new UnkeyedListItemNormalization(list); } - @SuppressWarnings("rawtypes") - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier()).build(); @@ -556,12 +439,6 @@ public abstract class DataNormalizationOperation impleme super(list); } - @SuppressWarnings("rawtypes") - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier()).build(); @@ -574,16 +451,16 @@ public abstract class DataNormalizationOperation impleme private final ImmutableMap> byQName; private final ImmutableMap> byArg; - protected ChoiceNodeNormalization(final org.opendaylight.yangtools.yang.model.api.ChoiceNode schema) { - super(new NodeIdentifier(schema.getQName())); - ImmutableMap.Builder> byQNameBuilder = ImmutableMap.builder(); - ImmutableMap.Builder> byArgBuilder = ImmutableMap.builder(); + protected ChoiceNodeNormalization(final ChoiceSchemaNode schema) { + super(new NodeIdentifier(schema.getQName()),schema); + final ImmutableMap.Builder> byQNameBuilder = ImmutableMap.builder(); + final ImmutableMap.Builder> byArgBuilder = ImmutableMap.builder(); - for (ChoiceCaseNode caze : schema.getCases()) { - for (DataSchemaNode cazeChild : caze.getChildNodes()) { - DataNormalizationOperation childOp = fromDataSchemaNode(cazeChild); + for (final ChoiceCaseNode caze : schema.getCases()) { + for (final DataSchemaNode cazeChild : caze.getChildNodes()) { + final DataNormalizationOperation childOp = fromDataSchemaNode(cazeChild); byArgBuilder.put(childOp.getIdentifier(), childOp); - for (QName qname : childOp.getQNameIdentifiers()) { + for (final QName qname : childOp.getQNameIdentifiers()) { byQNameBuilder.put(qname, childOp); } } @@ -602,11 +479,6 @@ public abstract class DataNormalizationOperation impleme return byQName.get(child); } - @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { - return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()); - } - @Override public NormalizedNode createDefault(final PathArgument currentArg) { return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()).build(); @@ -615,36 +487,27 @@ public abstract class DataNormalizationOperation impleme private static class AnyXmlNormalization extends DataNormalizationOperation { - protected AnyXmlNormalization( NodeIdentifier identifier ) { - super( identifier ); + protected AnyXmlNormalization( final AnyXmlSchemaNode schema) { + super( new NodeIdentifier(schema.getQName()), schema); } @Override - public DataNormalizationOperation getChild( PathArgument child ) throws DataNormalizationException { + public DataNormalizationOperation getChild( final PathArgument child ) throws DataNormalizationException { return null; } @Override - public DataNormalizationOperation getChild( QName child ) throws DataNormalizationException { + public DataNormalizationOperation getChild( final QName child ) throws DataNormalizationException { return null; } - @Override - public NormalizedNode normalize( Node legacyData ) { - NormalizedNodeAttrBuilder, AnyXmlNode> builder = - Builders.anyXmlBuilder().withNodeIdentifier( - new NodeIdentifier( legacyData.getNodeType() ) ); - builder.withValue(legacyData); - return builder.build(); - } - @Override public boolean isLeaf() { return false; } @Override - public NormalizedNode createDefault( PathArgument currentArg ) { + public NormalizedNode createDefault( final PathArgument currentArg ) { return null; } } @@ -652,8 +515,7 @@ public abstract class DataNormalizationOperation impleme private static final Optional findChildSchemaNode(final DataNodeContainer parent,final QName child) { DataSchemaNode potential = parent.getDataChildByName(child); if (potential == null) { - Iterable choices = FluentIterable.from( - parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class); + final Iterable choices = FluentIterable.from(parent.getChildNodes()).filter(ChoiceSchemaNode.class); potential = findChoice(choices, child); } return Optional.fromNullable(potential); @@ -662,12 +524,12 @@ public abstract class DataNormalizationOperation impleme private static DataNormalizationOperation fromSchemaAndQNameChecked(final DataNodeContainer schema, final QName child) throws DataNormalizationException { - Optional potential = findChildSchemaNode(schema, child); + final Optional potential = findChildSchemaNode(schema, child); if (!potential.isPresent()) { throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,schema.getChildNodes())); } - DataSchemaNode result = potential.get(); + final DataSchemaNode result = potential.get(); // We try to look up if this node was added by augmentation if ((schema instanceof DataSchemaNode) && result.isAugmenting()) { return fromAugmentation(schema, (AugmentationTarget) schema, result); @@ -675,11 +537,10 @@ public abstract class DataNormalizationOperation impleme return fromDataSchemaNode(result); } - private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice( - final Iterable choices, final QName child) { - org.opendaylight.yangtools.yang.model.api.ChoiceNode foundChoice = null; - choiceLoop: for (org.opendaylight.yangtools.yang.model.api.ChoiceNode choice : choices) { - for (ChoiceCaseNode caze : choice.getCases()) { + private static ChoiceSchemaNode findChoice(final Iterable choices, final QName child) { + ChoiceSchemaNode foundChoice = null; + choiceLoop: for (final ChoiceSchemaNode choice : choices) { + for (final ChoiceCaseNode caze : choice.getCases()) { if (findChildSchemaNode(caze, child).isPresent()) { foundChoice = choice; break choiceLoop; @@ -690,19 +551,19 @@ public abstract class DataNormalizationOperation impleme } public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchema augmentation) { - ImmutableSet.Builder potentialChildren = ImmutableSet.builder(); - for (DataSchemaNode child : augmentation.getChildNodes()) { + final ImmutableSet.Builder potentialChildren = ImmutableSet.builder(); + for (final DataSchemaNode child : augmentation.getChildNodes()) { potentialChildren.add(child.getQName()); } - return new AugmentationIdentifier(null, potentialChildren.build()); + return new AugmentationIdentifier(potentialChildren.build()); } private static DataNodeContainer augmentationProxy(final AugmentationSchema augmentation, final DataNodeContainer schema) { - Set children = new HashSet<>(); - for (DataSchemaNode augNode : augmentation.getChildNodes()) { + final Set children = new HashSet<>(); + for (final DataSchemaNode augNode : augmentation.getChildNodes()) { children.add(schema.getDataChildByName(augNode.getQName())); } - return new DataSchemaContainerProxy(children); + return new EffectiveAugmentationSchema(augmentation, children); } /** @@ -722,8 +583,8 @@ public abstract class DataNormalizationOperation impleme private static DataNormalizationOperation fromAugmentation(final DataNodeContainer parent, final AugmentationTarget parentAug, final DataSchemaNode child) { AugmentationSchema augmentation = null; - for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) { - DataSchemaNode potential = aug.getDataChildByName(child.getQName()); + for (final AugmentationSchema aug : parentAug.getAvailableAugmentations()) { + final DataSchemaNode potential = aug.getDataChildByName(child.getQName()); if (potential != null) { augmentation = aug; break; @@ -744,19 +605,19 @@ public abstract class DataNormalizationOperation impleme return fromListSchemaNode((ListSchemaNode) potential); } else if (potential instanceof LeafSchemaNode) { - return new LeafNormalization(new NodeIdentifier(potential.getQName())); - } else if (potential instanceof org.opendaylight.yangtools.yang.model.api.ChoiceNode) { - return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential); + return new LeafNormalization((LeafSchemaNode) potential); + } else if (potential instanceof ChoiceSchemaNode) { + return new ChoiceNodeNormalization((ChoiceSchemaNode) potential); } else if (potential instanceof LeafListSchemaNode) { return fromLeafListSchemaNode((LeafListSchemaNode) potential); } else if (potential instanceof AnyXmlSchemaNode) { - return new AnyXmlNormalization( new NodeIdentifier(potential.getQName() ) ); + return new AnyXmlNormalization( (AnyXmlSchemaNode) potential); } return null; } private static DataNormalizationOperation fromListSchemaNode(final ListSchemaNode potential) { - List keyDefinition = potential.getKeyDefinition(); + final List keyDefinition = potential.getKeyDefinition(); if(keyDefinition == null || keyDefinition.isEmpty()) { return new UnkeyedListMixinNormalization(potential); }