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%2FDataNormalizer.java;h=f30c8ddcaabf5c8c7cff69744b9ee3e8f936ebf8;hp=e1fc3c3cdb200b3c79a2e72b4d96abd03ca0572c;hb=02f34337b56b74def8fe59a7681c1012a58d4f04;hpb=26cb66156fe0e1f533d0e6a7dd39040c7423999f diff --git a/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizer.java b/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizer.java index e1fc3c3cdb..f30c8ddcaa 100644 --- a/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizer.java +++ b/opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/util/compat/DataNormalizer.java @@ -18,9 +18,6 @@ import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.CompositeNode; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; 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; @@ -28,13 +25,14 @@ import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.MixinNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; +import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode; import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode; import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl; import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import com.google.common.base.Preconditions; -import com.google.common.base.Predicate; +import com.google.common.base.Predicates; import com.google.common.collect.FluentIterable; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -54,17 +52,17 @@ public class DataNormalizer { Iterator arguments = legacy.getPath().iterator(); try { - while ( arguments.hasNext() ) { + while (arguments.hasNext()) { PathArgument legacyArg = arguments.next(); currentOp = currentOp.getChild(legacyArg); - checkArgument(currentOp != null, "Legacy Instance Identifier %s is not correct. Normalized Instance Identifier so far %s",legacy,normalizedArgs.build()); + checkArgument(currentOp != null, + "Legacy Instance Identifier %s is not correct. Normalized Instance Identifier so far %s", + legacy, normalizedArgs.build()); while (currentOp.isMixin()) { normalizedArgs.add(currentOp.getIdentifier()); currentOp = currentOp.getChild(legacyArg.getNodeType()); } - if(arguments.hasNext() || (!currentOp.isKeyedEntry() || legacyArg instanceof NodeIdentifierWithPredicates || legacyArg instanceof NodeWithValue)) { - normalizedArgs.add(legacyArg); - } + normalizedArgs.add(legacyArg); } } catch (DataNormalizationException e) { throw new IllegalArgumentException(String.format("Failed to normalize path %s", legacy), e); @@ -73,11 +71,13 @@ public class DataNormalizer { return new InstanceIdentifier(normalizedArgs.build()); } - public Map.Entry> toNormalized(final Map.Entry legacy) { + public Map.Entry> toNormalized( + final Map.Entry legacy) { return toNormalized(legacy.getKey(), legacy.getValue()); } - public Map.Entry> toNormalized(final InstanceIdentifier legacyPath, final CompositeNode legacyData) { + public Map.Entry> toNormalized(final InstanceIdentifier legacyPath, + final CompositeNode legacyData) { InstanceIdentifier normalizedPath = toNormalized(legacyPath); @@ -86,22 +86,23 @@ public class DataNormalizer { try { currentOp = currentOp.getChild(arg); } catch (DataNormalizationException e) { - throw new IllegalArgumentException(String.format("Failed to validate normalized path %s", normalizedPath), e); + throw new IllegalArgumentException(String.format("Failed to validate normalized path %s", + normalizedPath), e); } } // Write Augmentation data resolution - if (legacyData.getChildren().size() == 1) { + if (legacyData.getValue().size() == 1) { final DataNormalizationOperation potentialOp; try { - final QName childType = legacyData.getChildren().get(0).getNodeType(); + final QName childType = legacyData.getValue().get(0).getNodeType(); potentialOp = currentOp.getChild(childType); } catch (DataNormalizationException e) { throw new IllegalArgumentException(String.format("Failed to get child operation for %s", legacyData), e); } - if(potentialOp.getIdentifier() instanceof AugmentationIdentifier) { + if (potentialOp.getIdentifier() instanceof AugmentationIdentifier) { currentOp = potentialOp; ArrayList reworkedArgs = new ArrayList<>(normalizedPath.getPath()); reworkedArgs.add(potentialOp.getIdentifier()); @@ -111,28 +112,19 @@ public class DataNormalizer { Preconditions.checkArgument(currentOp != null, "Instance Identifier %s does not reference correct schema Node.", normalizedPath); - return new AbstractMap.SimpleEntry>(normalizedPath,currentOp.normalize(legacyData)); + return new AbstractMap.SimpleEntry>(normalizedPath, + currentOp.normalize(legacyData)); } - public InstanceIdentifier toLegacy(final InstanceIdentifier normalized) { + public InstanceIdentifier toLegacy(final InstanceIdentifier normalized) throws DataNormalizationException { ImmutableList.Builder legacyArgs = ImmutableList.builder(); PathArgument previous = null; + DataNormalizationOperation currentOp = operation; for (PathArgument normalizedArg : normalized.getPath()) { - if (normalizedArg instanceof NodeIdentifier) { - if (previous != null) { - legacyArgs.add(previous); - } - previous = normalizedArg; - } else if (normalizedArg instanceof NodeIdentifierWithPredicates) { - // We skip previous node, which was mixin. - previous = normalizedArg; - } else if (normalizedArg instanceof AugmentationIdentifier) { - // We ignore argument + currentOp = currentOp.getChild(normalizedArg); + if(!currentOp.isMixin()) { + legacyArgs.add(normalizedArg); } - // FIXME : Add option for reading choice - } - if (previous != null) { - legacyArgs.add(previous); } return new InstanceIdentifier(legacyArgs.build()); } @@ -149,9 +141,8 @@ public class DataNormalizer { public static Node toLegacy(final NormalizedNode node) { if (node instanceof MixinNode) { /** - * Direct reading of MixinNodes is not supported, - * since it is not possible in legacy APIs create pointer - * to Mixin Nodes. + * Direct reading of MixinNodes is not supported, since it is not + * possible in legacy APIs create pointer to Mixin Nodes. * */ return null; @@ -175,6 +166,8 @@ public class DataNormalizer { for (NormalizedNode child : node.getValue()) { if (child instanceof MixinNode && child instanceof NormalizedNodeContainer) { builder.addAll(toLegacyNodesFromMixin((NormalizedNodeContainer) child)); + } else if( child instanceof UnkeyedListNode) { + builder.addAll(toLegacyNodesFromUnkeyedList((UnkeyedListNode) child)); } else { addToBuilder(builder, toLegacy(child)); } @@ -182,6 +175,14 @@ public class DataNormalizer { return builder.toInstance(); } + private static Iterable> toLegacyNodesFromUnkeyedList(final UnkeyedListNode mixin) { + ArrayList> ret = new ArrayList<>(); + for (NormalizedNode child : mixin.getValue()) { + ret.add(toLegacy(child)); + } + return FluentIterable.from(ret).filter(Predicates.notNull()); + } + private static void addToBuilder(final CompositeNodeBuilder builder, final Node legacy) { if (legacy != null) { builder.add(legacy); @@ -193,19 +194,13 @@ public class DataNormalizer { final NormalizedNodeContainer> mixin) { ArrayList> ret = new ArrayList<>(); for (NormalizedNode child : mixin.getValue()) { - if(child instanceof MixinNode && child instanceof NormalizedNodeContainer) { - Iterables.addAll(ret,toLegacyNodesFromMixin((NormalizedNodeContainer) child)); + if (child instanceof MixinNode && child instanceof NormalizedNodeContainer) { + Iterables.addAll(ret, toLegacyNodesFromMixin((NormalizedNodeContainer) child)); } else { ret.add(toLegacy(child)); } } - return FluentIterable.from(ret).filter(new Predicate>() { - - @Override - public boolean apply(final Node input) { - return input != null; - } - }); + return FluentIterable.from(ret).filter(Predicates.notNull()); } public DataNormalizationOperation getRootOperation() {