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=9487f2159011132cd71e935a757b432dd324270a;hb=02f34337b56b74def8fe59a7681c1012a58d4f04;hpb=43d7c8702fc7a89ca5acdeefb4696c91b2963b38 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 9487f21590..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 @@ -1,16 +1,23 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ package org.opendaylight.controller.md.sal.common.impl.util.compat; import static com.google.common.base.Preconditions.checkArgument; 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.NodeIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates; 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; @@ -18,25 +25,23 @@ 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; public class DataNormalizer { - private final SchemaContext schemaContext; - private final DataNormalizationOperation operation; public DataNormalizer(final SchemaContext ctx) { - schemaContext = ctx; operation = DataNormalizationOperation.from(ctx); } @@ -44,35 +49,60 @@ public class DataNormalizer { ImmutableList.Builder normalizedArgs = ImmutableList.builder(); DataNormalizationOperation currentOp = operation; - for (PathArgument legacyArg : legacy.getPath()) { - currentOp = currentOp.getChild(legacyArg); - 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()); + Iterator arguments = legacy.getPath().iterator(); + + try { + 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()); + while (currentOp.isMixin()) { + normalizedArgs.add(currentOp.getIdentifier()); + currentOp = currentOp.getChild(legacyArg.getNodeType()); + } + normalizedArgs.add(legacyArg); } - normalizedArgs.add(legacyArg); + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(String.format("Failed to normalize path %s", legacy), e); } + 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); DataNormalizationOperation currentOp = operation; for (PathArgument arg : normalizedPath.getPath()) { - currentOp = currentOp.getChild(arg); + try { + currentOp = currentOp.getChild(arg); + } catch (DataNormalizationException e) { + throw new IllegalArgumentException(String.format("Failed to validate normalized path %s", + normalizedPath), e); + } } - // Write Augmentaiton data resolution - if (legacyData.getChildren().size() == 1) { - DataNormalizationOperation potentialOp = currentOp.getChild(legacyData.getChildren().get(0) - .getNodeType()); - if(potentialOp.getIdentifier() instanceof AugmentationIdentifier) { + + // 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()); @@ -82,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()); } @@ -120,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; @@ -146,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)); } @@ -153,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); @@ -164,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() {