X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?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=113d3dc9f762ec1f0f2f6d4c7307ae3f04e0d19b;hb=0e7b83c0739ac579ca6dbf6a3f7992f70eb3000f;hp=8fb6ff38a2477243545fe6fef86ca48532c4d493;hpb=259b65622b8c29c49235c2210609b9f7a68826eb;p=controller.git 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 8fb6ff38a2..113d3dc9f7 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 @@ -9,6 +9,12 @@ package org.opendaylight.controller.md.sal.common.impl.util.compat; import static com.google.common.base.Preconditions.checkArgument; +import com.google.common.base.Preconditions; +import com.google.common.base.Predicates; +import com.google.common.collect.FluentIterable; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Iterables; + import java.util.AbstractMap; import java.util.ArrayList; import java.util.Iterator; @@ -21,21 +27,17 @@ import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationI 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.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.collect.FluentIterable; -import com.google.common.collect.ImmutableList; -import com.google.common.collect.Iterables; - public class DataNormalizer { private final DataNormalizationOperation operation; @@ -48,7 +50,7 @@ public class DataNormalizer { ImmutableList.Builder normalizedArgs = ImmutableList.builder(); DataNormalizationOperation currentOp = operation; - Iterator arguments = legacy.getPath().iterator(); + Iterator arguments = legacy.getPathArguments().iterator(); try { while (arguments.hasNext()) { @@ -67,7 +69,7 @@ public class DataNormalizer { throw new IllegalArgumentException(String.format("Failed to normalize path %s", legacy), e); } - return new InstanceIdentifier(normalizedArgs.build()); + return InstanceIdentifier.create(normalizedArgs.build()); } public Map.Entry> toNormalized( @@ -81,7 +83,7 @@ public class DataNormalizer { InstanceIdentifier normalizedPath = toNormalized(legacyPath); DataNormalizationOperation currentOp = operation; - for (PathArgument arg : normalizedPath.getPath()) { + for (PathArgument arg : normalizedPath.getPathArguments()) { try { currentOp = currentOp.getChild(arg); } catch (DataNormalizationException e) { @@ -91,11 +93,11 @@ public class DataNormalizer { } // 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); @@ -103,9 +105,7 @@ public class DataNormalizer { if (potentialOp.getIdentifier() instanceof AugmentationIdentifier) { currentOp = potentialOp; - ArrayList reworkedArgs = new ArrayList<>(normalizedPath.getPath()); - reworkedArgs.add(potentialOp.getIdentifier()); - normalizedPath = new InstanceIdentifier(reworkedArgs); + normalizedPath = normalizedPath.node(potentialOp.getIdentifier()); } } @@ -117,15 +117,14 @@ public class DataNormalizer { public InstanceIdentifier toLegacy(final InstanceIdentifier normalized) throws DataNormalizationException { ImmutableList.Builder legacyArgs = ImmutableList.builder(); - PathArgument previous = null; DataNormalizationOperation currentOp = operation; - for (PathArgument normalizedArg : normalized.getPath()) { + for (PathArgument normalizedArg : normalized.getPathArguments()) { currentOp = currentOp.getChild(normalizedArg); if(!currentOp.isMixin()) { legacyArgs.add(normalizedArg); } } - return new InstanceIdentifier(legacyArgs.build()); + return InstanceIdentifier.create(legacyArgs.build()); } public CompositeNode toLegacy(final InstanceIdentifier normalizedPath, final NormalizedNode normalizedData) { @@ -133,6 +132,9 @@ public class DataNormalizer { // DataContainerNode,"Node object %s, %s should be of type DataContainerNode",normalizedPath,normalizedData); if (normalizedData instanceof DataContainerNode) { return toLegacyFromDataContainer((DataContainerNode) normalizedData); + } else if (normalizedData instanceof AnyXmlNode) { + Node value = ((AnyXmlNode) normalizedData).getValue(); + return value instanceof CompositeNode ? (CompositeNode)value : null; } return null; } @@ -149,6 +151,8 @@ public class DataNormalizer { if (node instanceof DataContainerNode) { return toLegacyFromDataContainer((DataContainerNode) node); + } else if (node instanceof AnyXmlNode) { + return ((AnyXmlNode) node).getValue(); } return toLegacySimple(node); @@ -165,6 +169,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)); } @@ -172,6 +178,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); @@ -189,13 +203,7 @@ public class DataNormalizer { 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() {