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=a36d984fa75c88e50360b7da64a8c8bbb7dcd832;hb=92f1fd15e99ce5b9e52612c0b52f70cd661b99cc;hpb=dc1a275c3c1ea8949dd3a607e08ee4624e758511 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 a36d984fa7..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,12 +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.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; @@ -45,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; @@ -82,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) { @@ -112,6 +118,11 @@ public abstract class DataNormalizationOperation impleme return null; } + @Override + public boolean isLeaf() { + return true; + } + } private static final class LeafNormalization extends SimpleTypeNormalization { @@ -147,7 +158,7 @@ public abstract class DataNormalizationOperation impleme } private static abstract class CompositeNodeNormalizationOperation extends - DataNormalizationOperation { + DataNormalizationOperation { protected CompositeNodeNormalizationOperation(final T identifier) { super(identifier); @@ -198,13 +209,18 @@ public abstract class DataNormalizationOperation impleme return builder.build(); } + @Override + public boolean isLeaf() { + 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; @@ -223,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); @@ -250,7 +278,7 @@ public abstract class DataNormalizationOperation impleme } private static final class ListItemNormalization extends - DataContainerNormalizationOperation { + DataContainerNormalizationOperation { private final List keyDefinition; @@ -260,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) { @@ -300,7 +328,7 @@ public abstract class DataNormalizationOperation impleme } @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { + protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier()); } @@ -318,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()); } @@ -330,7 +358,7 @@ public abstract class DataNormalizationOperation impleme } private static abstract class MixinNormalizationOp extends - CompositeNodeNormalizationOperation { + CompositeNodeNormalizationOperation { protected MixinNormalizationOp(final T identifier) { super(identifier); @@ -352,7 +380,7 @@ public abstract class DataNormalizationOperation impleme } @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { + protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier()); } @@ -372,7 +400,7 @@ public abstract class DataNormalizationOperation impleme } @Override - protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { + protected NormalizedNodeContainerBuilder createBuilder(final CompositeNode compositeNode) { return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier()); } @@ -398,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 @@ -581,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()); } @@ -591,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) { + 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( @@ -615,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; } @@ -629,33 +696,47 @@ 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) { @@ -670,6 +751,8 @@ public abstract class DataNormalizationOperation impleme return new ChoiceNodeNormalization((org.opendaylight.yangtools.yang.model.api.ChoiceNode) potential); } else if (potential instanceof LeafListSchemaNode) { return fromLeafListSchemaNode((LeafListSchemaNode) potential); + } else if (potential instanceof AnyXmlSchemaNode) { + return new AnyXmlNormalization( new NodeIdentifier(potential.getQName() ) ); } return null; }