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=2b9694bed71d87dfb8d48e04024b94f619e5c049;hp=1055fa81fde264b1949217b0ca860dac945918d8;hb=92f1fd15e99ce5b9e52612c0b52f70cd661b99cc;hpb=1b2bfec7e88011ceb4a53c96a522d835ad1ee7ce 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 1055fa81fd..2b9694bed7 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 @@ -10,6 +10,11 @@ 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; +import com.google.common.collect.ImmutableSet; + import java.util.Collections; import java.util.HashSet; import java.util.List; @@ -28,13 +33,15 @@ 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.schema.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; 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; @@ -46,10 +53,6 @@ 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 com.google.common.collect.FluentIterable; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; - public abstract class DataNormalizationOperation implements Identifiable { private final T identifier; @@ -83,6 +86,8 @@ public abstract class DataNormalizationOperation impleme public abstract NormalizedNode normalize(Node legacyData); + public abstract boolean isLeaf(); + private static abstract class SimpleTypeNormalization extends DataNormalizationOperation { protected SimpleTypeNormalization(final T identifier) { @@ -110,10 +115,14 @@ public abstract class DataNormalizationOperation impleme @Override public NormalizedNode createDefault(final PathArgument currentArg) { - // TODO Auto-generated method stub return null; } + @Override + public boolean isLeaf() { + return true; + } + } private static final class LeafNormalization extends SimpleTypeNormalization { @@ -148,16 +157,16 @@ public abstract class DataNormalizationOperation impleme } } - private static abstract class CompositeNodeNormalizationOpertation extends - DataNormalizationOperation { + private static abstract class CompositeNodeNormalizationOperation extends + DataNormalizationOperation { - protected CompositeNodeNormalizationOpertation(final T identifier) { + protected CompositeNodeNormalizationOperation(final T identifier) { super(identifier); } @SuppressWarnings({ "rawtypes", "unchecked" }) @Override - public final NormalizedNodeContainer normalize(final Node legacyData) { + public final NormalizedNode normalize(final Node legacyData) { checkArgument(legacyData != null); if (!isMixin() && getIdentifier().getNodeType() != null) { checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()), @@ -197,7 +206,12 @@ public abstract class DataNormalizationOperation impleme builder.addChild(childOp.normalize(childLegacy)); } } - return (NormalizedNodeContainer) builder.build(); + return builder.build(); + } + + @Override + public boolean isLeaf() { + return false; } @SuppressWarnings("rawtypes") @@ -206,7 +220,7 @@ public abstract class DataNormalizationOperation impleme } private static abstract class DataContainerNormalizationOperation extends - CompositeNodeNormalizationOpertation { + CompositeNodeNormalizationOperation { private final DataNodeContainer schema; private final Map> byQName; @@ -225,20 +239,32 @@ public abstract class DataNormalizationOperation impleme if (potential != null) { return potential; } - potential = fromSchema(schema, child); + potential = fromLocalSchema(child); return register(potential); } + private DataNormalizationOperation fromLocalSchema(final PathArgument child) throws DataNormalizationException { + if (child instanceof AugmentationIdentifier) { + return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames() + .iterator().next()); + } + return fromSchemaAndQNameChecked(schema, child.getNodeType()); + } + @Override public DataNormalizationOperation getChild(final QName child) throws DataNormalizationException { DataNormalizationOperation potential = byQName.get(child); if (potential != null) { return potential; } - potential = fromSchemaAndPathArgument(schema, child); + potential = fromLocalSchemaAndQName(schema, child); return register(potential); } + protected DataNormalizationOperation fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) throws DataNormalizationException { + return fromSchemaAndQNameChecked(schema2, child); + } + private DataNormalizationOperation register(final DataNormalizationOperation potential) { if (potential != null) { byArg.put(potential.getIdentifier(), potential); @@ -252,7 +278,7 @@ public abstract class DataNormalizationOperation impleme } private static final class ListItemNormalization extends - DataContainerNormalizationOperation { + DataContainerNormalizationOperation { private final List keyDefinition; @@ -262,7 +288,7 @@ public abstract class DataNormalizationOperation impleme } @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { + protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { ImmutableMap.Builder keys = ImmutableMap.builder(); for (QName key : keyDefinition) { @@ -295,6 +321,24 @@ 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()); + } + + @Override + public NormalizedNode createDefault(final PathArgument currentArg) { + return Builders.unkeyedListEntryBuilder().withNodeIdentifier((NodeIdentifier) currentArg).build(); + } + + } + private static final class ContainerNormalization extends DataContainerNormalizationOperation { protected ContainerNormalization(final ContainerSchemaNode schema) { @@ -302,7 +346,7 @@ public abstract class DataNormalizationOperation impleme } @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { + protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { return Builders.containerBuilder().withNodeIdentifier(getIdentifier()); } @@ -314,7 +358,7 @@ public abstract class DataNormalizationOperation impleme } private static abstract class MixinNormalizationOp extends - CompositeNodeNormalizationOpertation { + CompositeNodeNormalizationOperation { protected MixinNormalizationOp(final T identifier) { super(identifier); @@ -327,17 +371,36 @@ public abstract class DataNormalizationOperation impleme } - private static final class LeafListMixinNormalization extends MixinNormalizationOp { + + private static final class OrderedLeafListMixinNormalization extends UnorderedLeafListMixinNormalization { + + + public OrderedLeafListMixinNormalization(final LeafListSchemaNode potential) { + 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(); + } + } + + private static class UnorderedLeafListMixinNormalization extends MixinNormalizationOp { private final DataNormalizationOperation innerOp; - public LeafListMixinNormalization(final LeafListSchemaNode potential) { + public UnorderedLeafListMixinNormalization(final LeafListSchemaNode potential) { super(new NodeIdentifier(potential.getQName())); innerOp = new LeafListEntryNormalization(potential); } @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { + protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()); } @@ -363,38 +426,34 @@ public abstract class DataNormalizationOperation impleme } } - private static final class AugmentationNormalization extends MixinNormalizationOp { - - private final Map> byQName; - private final Map> byArg; + private static final class AugmentationNormalization extends DataContainerNormalizationOperation { public AugmentationNormalization(final AugmentationSchema augmentation, final DataNodeContainer schema) { - super(augmentationIdentifierFrom(augmentation)); - - ImmutableMap.Builder> byQNameBuilder = ImmutableMap.builder(); - ImmutableMap.Builder> byArgBuilder = ImmutableMap.builder(); - - for (DataSchemaNode augNode : augmentation.getChildNodes()) { - DataSchemaNode resolvedNode = schema.getDataChildByName(augNode.getQName()); - DataNormalizationOperation resolvedOp = fromDataSchemaNode(resolvedNode); - byArgBuilder.put(resolvedOp.getIdentifier(), resolvedOp); - for (QName resQName : resolvedOp.getQNameIdentifiers()) { - byQNameBuilder.put(resQName, resolvedOp); - } - } - byQName = byQNameBuilder.build(); - byArg = byArgBuilder.build(); - + //super(); + super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation,schema)); } @Override - public DataNormalizationOperation getChild(final PathArgument child) { - return byArg.get(child); + public boolean isMixin() { + return true; } + + @Override - public DataNormalizationOperation getChild(final QName child) { - return byQName.get(child); + protected DataNormalizationOperation fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child) + throws DataNormalizationException { + Optional potential = findChildSchemaNode(schema, child); + if (!potential.isPresent()) { + return null; + } + + 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); + } + return fromDataSchemaNode(result); } @Override @@ -415,11 +474,11 @@ public abstract class DataNormalizationOperation impleme } - private static final class ListMixinNormalization extends MixinNormalizationOp { + private static class UnorderedMapMixinNormalization extends MixinNormalizationOp { private final ListItemNormalization innerNode; - public ListMixinNormalization(final ListSchemaNode list) { + public UnorderedMapMixinNormalization(final ListSchemaNode list) { super(new NodeIdentifier(list.getQName())); this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(), Collections. emptyMap()), list); @@ -454,6 +513,64 @@ public abstract class DataNormalizationOperation impleme } + + private static class UnkeyedListMixinNormalization extends MixinNormalizationOp { + + private final UnkeyedListItemNormalization innerNode; + + public UnkeyedListMixinNormalization(final ListSchemaNode list) { + super(new NodeIdentifier(list.getQName())); + 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(); + } + + @Override + public DataNormalizationOperation getChild(final PathArgument child) { + if (child.getNodeType().equals(getIdentifier().getNodeType())) { + return innerNode; + } + return null; + } + + @Override + public DataNormalizationOperation getChild(final QName child) { + if (getIdentifier().getNodeType().equals(child)) { + return innerNode; + } + return null; + } + + } + + private static final class OrderedMapMixinNormalization extends UnorderedMapMixinNormalization { + + public OrderedMapMixinNormalization(final ListSchemaNode list) { + 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(); + } + + } + private static class ChoiceNodeNormalization extends MixinNormalizationOp { private final ImmutableMap> byQName; @@ -488,7 +605,7 @@ public abstract class DataNormalizationOperation impleme } @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { + protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { return Builders.choiceBuilder().withNodeIdentifier(getIdentifier()); } @@ -498,23 +615,66 @@ public abstract class DataNormalizationOperation impleme } } - private static DataNormalizationOperation fromSchemaAndPathArgument(final DataNodeContainer schema, - final QName child) throws DataNormalizationException { - DataSchemaNode potential = schema.getDataChildByName(child); + private static class AnyXmlNormalization extends DataNormalizationOperation { + + protected AnyXmlNormalization( final NodeIdentifier identifier ) { + super( identifier ); + } + + @Override + public DataNormalizationOperation getChild( final PathArgument child ) throws DataNormalizationException { + return null; + } + + @Override + public DataNormalizationOperation getChild( final QName child ) throws DataNormalizationException { + return null; + } + + @Override + public NormalizedNode normalize( final 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( final PathArgument currentArg ) { + return null; + } + } + + private static final Optional findChildSchemaNode(final DataNodeContainer parent,final QName child) { + DataSchemaNode potential = parent.getDataChildByName(child); if (potential == null) { Iterable choices = FluentIterable.from( - schema.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class); + parent.getChildNodes()).filter(org.opendaylight.yangtools.yang.model.api.ChoiceNode.class); potential = findChoice(choices, child); } + return Optional.fromNullable(potential); + } - if (potential == null) { - throw new DataNormalizationException(String.format("Supplied QName %s is not valid according to schema %s", child, schema)); + private static DataNormalizationOperation fromSchemaAndQNameChecked(final DataNodeContainer schema, + final QName child) throws DataNormalizationException { + + 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())); } - if ((schema instanceof DataSchemaNode) && !((DataSchemaNode) schema).isAugmenting() && potential.isAugmenting()) { - return fromAugmentation(schema, (AugmentationTarget) schema, potential); + 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); } - return fromDataSchemaNode(potential); + return fromDataSchemaNode(result); } private static org.opendaylight.yangtools.yang.model.api.ChoiceNode findChoice( @@ -522,7 +682,7 @@ public abstract class DataNormalizationOperation impleme 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()) { - if (caze.getDataChildByName(child) != null) { + if (findChildSchemaNode(caze, child).isPresent()) { foundChoice = choice; break choiceLoop; } @@ -536,50 +696,86 @@ public abstract class DataNormalizationOperation impleme for (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()) { + children.add(schema.getDataChildByName(augNode.getQName())); + } + return new DataSchemaContainerProxy(children); } - private static AugmentationNormalization fromAugmentation(final DataNodeContainer schema, - final AugmentationTarget augments, final DataSchemaNode potential) { + /** + * Returns a DataNormalizationOperation for provided child node + * + * If supplied child is added by Augmentation this operation returns + * a DataNormalizationOperation for augmentation, + * otherwise returns a DataNormalizationOperation for child as + * call for {@link #fromDataSchemaNode(DataSchemaNode)}. + * + * + * @param parent + * @param parentAug + * @param child + * @return + */ + private static DataNormalizationOperation fromAugmentation(final DataNodeContainer parent, + final AugmentationTarget parentAug, final DataSchemaNode child) { AugmentationSchema augmentation = null; - for (AugmentationSchema aug : augments.getAvailableAugmentations()) { - DataSchemaNode child = aug.getDataChildByName(potential.getQName()); - if (child != null) { + for (AugmentationSchema aug : parentAug.getAvailableAugmentations()) { + DataSchemaNode potential = aug.getDataChildByName(child.getQName()); + if (potential != null) { augmentation = aug; break; } } if (augmentation != null) { - return new AugmentationNormalization(augmentation, schema); + return new AugmentationNormalization(augmentation, parent); } else { - return null; - } - } - - private static DataNormalizationOperation fromSchema(final DataNodeContainer schema, final PathArgument child) throws DataNormalizationException { - if (child instanceof AugmentationIdentifier) { - return fromSchemaAndPathArgument(schema, ((AugmentationIdentifier) child).getPossibleChildNames() - .iterator().next()); + return fromDataSchemaNode(child); } - return fromSchemaAndPathArgument(schema, child.getNodeType()); } public static DataNormalizationOperation fromDataSchemaNode(final DataSchemaNode potential) { if (potential instanceof ContainerSchemaNode) { return new ContainerNormalization((ContainerSchemaNode) potential); } else if (potential instanceof ListSchemaNode) { - return new ListMixinNormalization((ListSchemaNode) potential); + + 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); } else if (potential instanceof LeafListSchemaNode) { - return new LeafListMixinNormalization((LeafListSchemaNode) potential); + return fromLeafListSchemaNode((LeafListSchemaNode) potential); + } else if (potential instanceof AnyXmlSchemaNode) { + return new AnyXmlNormalization( new NodeIdentifier(potential.getQName() ) ); } return null; } + private static DataNormalizationOperation fromListSchemaNode(final ListSchemaNode potential) { + List keyDefinition = potential.getKeyDefinition(); + if(keyDefinition == null || keyDefinition.isEmpty()) { + return new UnkeyedListMixinNormalization(potential); + } + if(potential.isUserOrdered()) { + return new OrderedMapMixinNormalization(potential); + } + return new UnorderedMapMixinNormalization(potential); + } + + private static DataNormalizationOperation fromLeafListSchemaNode(final LeafListSchemaNode potential) { + if(potential.isUserOrdered()) { + return new OrderedLeafListMixinNormalization(potential); + } + return new UnorderedLeafListMixinNormalization(potential); + } + + public static DataNormalizationOperation from(final SchemaContext ctx) { return new ContainerNormalization(ctx); }