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=b4dcb1167c70d8743d73ba106e2aaf4842017489;hp=ec8ce6ecd5a96e628d2883ab38f24aaab383095a;hb=3927509ec3ecfa32a51b725d2b7155d425f5b877;hpb=af01f3ff581487d002140ca08a94e4636546d649 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 ec8ce6ecd5..b4dcb1167c 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,20 +9,14 @@ 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; import java.util.Map; -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.PathArgument; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.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; @@ -36,6 +30,17 @@ 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.Predicates; +import com.google.common.collect.FluentIterable; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Iterables; + +/** + * @deprecated This class provides compatibility between {@link CompositeNode} and {@link NormalizedNode}. + * Users of this class should use {@link NormalizedNode}s directly. + */ +@Deprecated public class DataNormalizer { private final DataNormalizationOperation operation; @@ -44,11 +49,11 @@ public class DataNormalizer { operation = DataNormalizationOperation.from(ctx); } - public InstanceIdentifier toNormalized(final InstanceIdentifier legacy) { + public YangInstanceIdentifier toNormalized(final YangInstanceIdentifier legacy) { ImmutableList.Builder normalizedArgs = ImmutableList.builder(); DataNormalizationOperation currentOp = operation; - Iterator arguments = legacy.getPath().iterator(); + Iterator arguments = legacy.getPathArguments().iterator(); try { while (arguments.hasNext()) { @@ -67,21 +72,31 @@ public class DataNormalizer { throw new IllegalArgumentException(String.format("Failed to normalize path %s", legacy), e); } - return new InstanceIdentifier(normalizedArgs.build()); + return YangInstanceIdentifier.create(normalizedArgs.build()); } - public Map.Entry> toNormalized( - final Map.Entry legacy) { + public DataNormalizationOperation getOperation(final YangInstanceIdentifier legacy) throws DataNormalizationException { + DataNormalizationOperation currentOp = operation; + Iterator arguments = legacy.getPathArguments().iterator(); + + while (arguments.hasNext()) { + currentOp = currentOp.getChild(arguments.next()); + } + return currentOp; + } + + public Map.Entry> toNormalized( + final Map.Entry legacy) { return toNormalized(legacy.getKey(), legacy.getValue()); } - public Map.Entry> toNormalized(final InstanceIdentifier legacyPath, + public Map.Entry> toNormalized(final YangInstanceIdentifier legacyPath, final CompositeNode legacyData) { - InstanceIdentifier normalizedPath = toNormalized(legacyPath); + YangInstanceIdentifier normalizedPath = toNormalized(legacyPath); DataNormalizationOperation currentOp = operation; - for (PathArgument arg : normalizedPath.getPath()) { + for (PathArgument arg : normalizedPath.getPathArguments()) { try { currentOp = currentOp.getChild(arg); } catch (DataNormalizationException e) { @@ -89,53 +104,32 @@ public class DataNormalizer { normalizedPath), e); } } - - // Write Augmentation data resolution - if (legacyData.getValue().size() == 1) { - final DataNormalizationOperation potentialOp; - - try { - 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) { - currentOp = potentialOp; - ArrayList reworkedArgs = new ArrayList<>(normalizedPath.getPath()); - reworkedArgs.add(potentialOp.getIdentifier()); - normalizedPath = new InstanceIdentifier(reworkedArgs); - } - } - Preconditions.checkArgument(currentOp != null, "Instance Identifier %s does not reference correct schema Node.", normalizedPath); - return new AbstractMap.SimpleEntry>(normalizedPath, + return new AbstractMap.SimpleEntry>(normalizedPath, currentOp.normalize(legacyData)); } - public InstanceIdentifier toLegacy(final InstanceIdentifier normalized) throws DataNormalizationException { + public YangInstanceIdentifier toLegacy(final YangInstanceIdentifier 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()) { + if (!currentOp.isMixin()) { legacyArgs.add(normalizedArg); } } - return new InstanceIdentifier(legacyArgs.build()); + return YangInstanceIdentifier.create(legacyArgs.build()); } - public CompositeNode toLegacy(final InstanceIdentifier normalizedPath, final NormalizedNode normalizedData) { + public CompositeNode toLegacy(final YangInstanceIdentifier normalizedPath, final NormalizedNode normalizedData) { // Preconditions.checkArgument(normalizedData instanceof // 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 value instanceof CompositeNode ? (CompositeNode) value : null; } return null; } @@ -170,7 +164,7 @@ 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) { + } else if (child instanceof UnkeyedListNode) { builder.addAll(toLegacyNodesFromUnkeyedList((UnkeyedListNode) child)); } else { addToBuilder(builder, toLegacy(child));