Optimize ImmutableNodes.fromInstanceId()

We are doing a single pass over the YangInstanceIdentifier, hence
we can simply iterate over the nodes, without creating another
YangInstanceIdentifier at each step.

Also cleanup method visibility, mark methods final and merge some
common codepaths.

JIRA: YANGTOOLS-897
Change-Id: I7bd599436dd16f943bae71f3adce289164be25c2
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
(cherry picked from commit 38c0fcab1667af91ef8ee0fc1e4b1cd9075f031a)

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java
index 6ab563185f1dc540bd1df9e230b8e816a53eb2db..3a559b277c5f56fb04222b4ba1287f1cc1cb6e50 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java
@@ -7,7 +7,9 @@
  */
 package org.opendaylight.yangtools.yang.data.impl.schema;
 
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.Iterator;
 import java.util.Map.Entry;
 import java.util.Optional;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -15,6 +17,7 @@ import org.opendaylight.yangtools.yang.data.api.ModifyAction;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
@@ -192,12 +195,13 @@ public final class ImmutableNodes {
      */
     public static NormalizedNode<?, ?> fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
             final Optional<NormalizedNode<?, ?>> deepestElement, final Optional<Entry<QName, ModifyAction>> operation) {
-        final YangInstanceIdentifier.PathArgument topLevelElement = id.getPathArguments().get(0);
+        final Iterator<PathArgument> it = id.getPathArguments().iterator();
+        final PathArgument topLevelElement = it.next();
         final DataSchemaNode dataChildByName = ctx.getDataChildByName(topLevelElement.getNodeType());
-        Preconditions.checkNotNull(dataChildByName,
+        checkNotNull(dataChildByName,
             "Cannot find %s node in schema context. Instance identifier has to start from root", topLevelElement);
         final InstanceIdToNodes<?> instanceIdToNodes = InstanceIdToNodes.fromSchemaAndQNameChecked(ctx,
             topLevelElement.getNodeType());
-        return instanceIdToNodes.create(id, deepestElement, operation);
+        return instanceIdToNodes.create(topLevelElement, it, deepestElement, operation);
     }
 }

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java
index 2dfe2d18f43f82dc80acba711ce43ce5e86c29b8..83798c87957e5e3411c1a9267fb18ae2bf962b5a 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToCompositeNodes.java
@@ -8,13 +8,10 @@
 package org.opendaylight.yangtools.yang.data.impl.schema;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Iterables;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -22,7 +19,6 @@ import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
@@ -63,26 +59,23 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
 
     @Override
     @SuppressWarnings("unchecked")
-    public final NormalizedNode<?, ?> create(final YangInstanceIdentifier instanceId,
-            final Optional<NormalizedNode<?, ?>> lastChild, final Optional<Entry<QName,ModifyAction>> operation) {
-        checkNotNull(instanceId);
-        final Iterator<PathArgument> iterator = instanceId.getPathArguments().iterator();
-        final PathArgument legacyData = iterator.next();
-
-        if (!isMixin() && getIdentifier().getNodeType() != null) {
-            checkArgument(getIdentifier().getNodeType().equals(legacyData.getNodeType()),
-                    "Node QName must be %s was %s", getIdentifier().getNodeType(), legacyData.getNodeType());
+    final NormalizedNode<?, ?> create(final PathArgument first, final Iterator<PathArgument> others,
+            final Optional<NormalizedNode<?, ?>> lastChild, final Optional<Entry<QName, ModifyAction>> operation) {
+        if (!isMixin()) {
+            final QName type = getIdentifier().getNodeType();
+            if (type != null) {
+                final QName firstType = first.getNodeType();
+                checkArgument(type.equals(firstType), "Node QName must be %s was %s", type, firstType);
+            }
         }
+
         @SuppressWarnings("rawtypes")
-        final NormalizedNodeContainerBuilder builder = createBuilder(legacyData);
+        final NormalizedNodeContainerBuilder builder = createBuilder(first);
 
-        if (iterator.hasNext()) {
-            final PathArgument childPath = iterator.next();
+        if (others.hasNext()) {
+            final PathArgument childPath = others.next();
             final InstanceIdToNodes<?> childOp = getChildOperation(childPath);
-
-            final YangInstanceIdentifier childId = YangInstanceIdentifier.create(
-                Iterables.skip(instanceId.getPathArguments(), 1));
-            builder.addChild(childOp.create(childId, lastChild, operation));
+            builder.addChild(childOp.create(childPath, others, lastChild, operation));
         } else {
             if (lastChild.isPresent()) {
                 builder.withValue(ImmutableList.copyOf((Collection<?>) lastChild.get().getValue()));
@@ -108,22 +101,21 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         return childOp;
     }
 
-    protected abstract NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(PathArgument compositeNode);
+    abstract NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(PathArgument compositeNode);
 
     abstract static class DataContainerNormalizationOperation<T extends PathArgument>
             extends InstanceIdToCompositeNodes<T> {
 
+        private final Map<PathArgument, InstanceIdToNodes<?>> byArg = new ConcurrentHashMap<>();
         private final DataNodeContainer schema;
-        private final Map<PathArgument, InstanceIdToNodes<?>> byArg;
 
-        protected DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
+        DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
             super(identifier);
             this.schema = schema;
-            this.byArg = new ConcurrentHashMap<>();
         }
 
         @Override
-        public InstanceIdToNodes<?> getChild(final PathArgument child) {
+        final InstanceIdToNodes<?> getChild(final PathArgument child) {
             InstanceIdToNodes<?> potential = byArg.get(child);
             if (potential != null) {
                 return potential;
@@ -149,12 +141,12 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
     }
 
     static final class ListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
-        protected ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
+        ListItemNormalization(final NodeIdentifierWithPredicates identifier, final ListSchemaNode schema) {
             super(identifier, schema);
         }
 
         @Override
-        protected DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> createBuilder(
+        DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> createBuilder(
                 final PathArgument currentArg) {
             final NodeIdentifierWithPredicates arg = (NodeIdentifierWithPredicates) currentArg;
             final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = Builders
@@ -179,7 +171,7 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
 
         @Override
-        protected DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> createBuilder(
+        DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> createBuilder(
                 final PathArgument compositeNode) {
             return Builders.unkeyedListEntryBuilder().withNodeIdentifier(getIdentifier());
         }
@@ -196,8 +188,7 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
 
         @Override
-        protected DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> createBuilder(
-                final PathArgument compositeNode) {
+        DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> createBuilder(final PathArgument compositeNode) {
             return Builders.containerBuilder().withNodeIdentifier(getIdentifier());
         }
 
@@ -213,7 +204,7 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
 
         @Override
-        protected ListNodeBuilder<?, ?> createBuilder(final PathArgument compositeNode) {
+        ListNodeBuilder<?, ?> createBuilder(final PathArgument compositeNode) {
             return Builders.orderedLeafSetBuilder().withNodeIdentifier(getIdentifier());
         }
     }
@@ -227,20 +218,17 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
 
         @Override
-        protected ListNodeBuilder<?, ?> createBuilder(final PathArgument compositeNode) {
+        ListNodeBuilder<?, ?> createBuilder(final PathArgument compositeNode) {
             return Builders.leafSetBuilder().withNodeIdentifier(getIdentifier());
         }
 
         @Override
-        public InstanceIdToNodes<?> getChild(final PathArgument child) {
-            if (child instanceof NodeWithValue) {
-                return innerOp;
-            }
-            return null;
+        final InstanceIdToNodes<?> getChild(final PathArgument child) {
+            return child instanceof NodeWithValue ? innerOp : null;
         }
 
         @Override
-        boolean isMixin() {
+        final boolean isMixin() {
             return true;
         }
     }
@@ -252,7 +240,7 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
 
         @Override
-        protected DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> createBuilder(
+        DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> createBuilder(
                 final PathArgument compositeNode) {
             return Builders.augmentationBuilder().withNodeIdentifier(getIdentifier());
         }
@@ -269,25 +257,21 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         UnorderedMapMixinNormalization(final ListSchemaNode list) {
             super(NodeIdentifier.create(list.getQName()));
             this.innerNode = new ListItemNormalization(new NodeIdentifierWithPredicates(list.getQName(),
-                    Collections.emptyMap()), list);
+                    ImmutableMap.of()), list);
         }
 
         @Override
-        protected CollectionNodeBuilder<MapEntryNode, ? extends MapNode> createBuilder(
-                final PathArgument compositeNode) {
+        CollectionNodeBuilder<MapEntryNode, ? extends MapNode> createBuilder(final PathArgument compositeNode) {
             return Builders.mapBuilder().withNodeIdentifier(getIdentifier());
         }
 
         @Override
-        public InstanceIdToNodes<?> getChild(final PathArgument child) {
-            if (child.getNodeType().equals(getIdentifier().getNodeType())) {
-                return innerNode;
-            }
-            return null;
+        final InstanceIdToNodes<?> getChild(final PathArgument child) {
+            return child.getNodeType().equals(getIdentifier().getNodeType()) ? innerNode : null;
         }
 
         @Override
-        boolean isMixin() {
+        final boolean isMixin() {
             return true;
         }
     }
@@ -298,10 +282,9 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
 
         @Override
-        protected CollectionNodeBuilder<MapEntryNode, OrderedMapNode> createBuilder(final PathArgument compositeNode) {
+        CollectionNodeBuilder<MapEntryNode, OrderedMapNode> createBuilder(final PathArgument compositeNode) {
             return Builders.orderedMapBuilder().withNodeIdentifier(getIdentifier());
         }
-
     }
 
     static final class ChoiceNodeNormalization extends InstanceIdToCompositeNodes<NodeIdentifier> {
@@ -321,12 +304,12 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
 
         @Override
-        public InstanceIdToNodes<?> getChild(final PathArgument child) {
+        InstanceIdToNodes<?> getChild(final PathArgument child) {
             return byArg.get(child);
         }
 
         @Override
-        protected DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> createBuilder(final PathArgument compositeNode) {
+        DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> createBuilder(final PathArgument compositeNode) {
             return Builders.choiceBuilder().withNodeIdentifier(getIdentifier());
         }
 

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToNodes.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToNodes.java
index bf6bcc1a48708fe200d76fe5d30ae58604d47462..d288b000a8ede26a9c47705d64482e473554f4aa 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToNodes.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToNodes.java
@@ -7,9 +7,12 @@
  */
 package org.opendaylight.yangtools.yang.data.impl.schema;
 
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
-import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Optional;
@@ -17,7 +20,6 @@ import javax.xml.transform.dom.DOMSource;
 import org.opendaylight.yangtools.concepts.Identifiable;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
@@ -44,18 +46,17 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  * Use provided static methods for generic YangInstanceIdentifier -> NormalizedNode translation in ImmutableNodes.
  */
 abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable<T> {
-
     private final T identifier;
 
+    InstanceIdToNodes(final T identifier) {
+        this.identifier = identifier;
+    }
+
     @Override
     public final T getIdentifier() {
         return identifier;
     }
 
-    protected InstanceIdToNodes(final T identifier) {
-        this.identifier = identifier;
-    }
-
     /**
      * Build a strategy for the next path argument.
      *
@@ -72,23 +73,19 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
      * @param operation Optional modify operation to be set on the last child
      * @return NormalizedNode structure corresponding to submitted instance ID
      */
-    abstract NormalizedNode<?, ?> create(YangInstanceIdentifier instanceId, Optional<NormalizedNode<?, ?>> deepestChild,
-            Optional<Entry<QName,ModifyAction>> operation);
+    abstract NormalizedNode<?, ?> create(PathArgument first, Iterator<PathArgument> others,
+            Optional<NormalizedNode<?, ?>> deepestChild, Optional<Entry<QName, ModifyAction>> operation);
 
     abstract boolean isMixin();
 
-    public void addModifyOpIfPresent(final Optional<Entry<QName,ModifyAction>> operation,
+    static void addModifyOpIfPresent(final Optional<Entry<QName, ModifyAction>> operation,
             final AttributesBuilder<?> builder) {
         if (operation.isPresent()) {
-            builder.withAttributes(Collections.singletonMap(operation.get().getKey(),
-                modifyOperationToXmlString(operation.get().getValue())));
+            final Entry<QName, ModifyAction> entry = operation.get();
+            builder.withAttributes(ImmutableMap.of(entry.getKey(), entry.getValue().name().toLowerCase()));
         }
     }
 
-    public static String modifyOperationToXmlString(final ModifyAction operation) {
-        return operation.name().toLowerCase();
-    }
-
     private static final class UnkeyedListMixinNormalization extends InstanceIdToCompositeNodes<NodeIdentifier> {
         private final UnkeyedListItemNormalization innerNode;
 
@@ -98,17 +95,13 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
         }
 
         @Override
-        protected CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> createBuilder(
-                final PathArgument compositeNode) {
+        CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> createBuilder(final PathArgument compositeNode) {
             return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
         }
 
         @Override
-        public InstanceIdToNodes<?> getChild(final PathArgument child) {
-            if (child.getNodeType().equals(getIdentifier().getNodeType())) {
-                return innerNode;
-            }
-            return null;
+        InstanceIdToNodes<?> getChild(final PathArgument child) {
+            return child.getNodeType().equals(getIdentifier().getNodeType()) ? innerNode : null;
         }
 
         @Override
@@ -117,32 +110,28 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
         }
     }
 
-    private static class AnyXmlNormalization extends InstanceIdToNodes<NodeIdentifier> {
+    private static final class AnyXmlNormalization extends InstanceIdToNodes<NodeIdentifier> {
         AnyXmlNormalization(final AnyXmlSchemaNode schema) {
             super(NodeIdentifier.create(schema.getQName()));
         }
 
         @Override
-        public InstanceIdToNodes<?> getChild(final PathArgument child) {
+        InstanceIdToNodes<?> getChild(final PathArgument child) {
             return null;
         }
 
         @Override
-        public NormalizedNode<?, ?> create(final YangInstanceIdentifier instanceId,
+        NormalizedNode<?, ?> create(final PathArgument first, final Iterator<PathArgument> others,
                 final Optional<NormalizedNode<?, ?>> deepestChild,
                 final Optional<Entry<QName,ModifyAction>> operation) {
+            final NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> builder = Builders.anyXmlBuilder()
+                    .withNodeIdentifier(getIdentifier());
             if (deepestChild.isPresent()) {
                 final NormalizedNode<?, ?> child = deepestChild.get();
-                Preconditions.checkState(child instanceof AnyXmlNode);
-                final NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> anyXmlBuilder =
-                        Builders.anyXmlBuilder().withNodeIdentifier(getIdentifier()).withValue(
-                            ((AnyXmlNode) child).getValue());
-                addModifyOpIfPresent(operation, anyXmlBuilder);
-                return anyXmlBuilder.build();
+                checkState(child instanceof AnyXmlNode);
+                builder.withValue(((AnyXmlNode) child).getValue());
             }
 
-            final NormalizedNodeAttrBuilder<NodeIdentifier, DOMSource, AnyXmlNode> builder =
-                    Builders.anyXmlBuilder().withNodeIdentifier(getIdentifier());
             addModifyOpIfPresent(operation, builder);
             return builder.build();
         }
@@ -163,7 +152,7 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
 
     static InstanceIdToNodes<?> fromSchemaAndQNameChecked(final DataNodeContainer schema, final QName child) {
         final Optional<DataSchemaNode> potential = findChildSchemaNode(schema, child);
-        Preconditions.checkArgument(potential.isPresent(),
+        checkArgument(potential.isPresent(),
                 "Supplied QName %s is not valid according to schema %s, potential children nodes: %s", child, schema,
                 schema.getChildNodes());
 
@@ -176,17 +165,14 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
     }
 
     private static ChoiceSchemaNode findChoice(final Iterable<ChoiceSchemaNode> choices, final QName child) {
-        ChoiceSchemaNode foundChoice = null;
-        choiceLoop:
         for (final ChoiceSchemaNode choice : choices) {
             for (final CaseSchemaNode caze : choice.getCases().values()) {
                 if (findChildSchemaNode(caze, child).isPresent()) {
-                    foundChoice = choice;
-                    break choiceLoop;
+                    return choice;
                 }
             }
         }
-        return foundChoice;
+        return null;
     }
 
     /**
@@ -199,17 +185,11 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
      */
     private static InstanceIdToNodes<?> fromAugmentation(final DataNodeContainer parent,
             final AugmentationTarget parentAug, final DataSchemaNode child) {
-        AugmentationSchemaNode augmentation = null;
         for (final AugmentationSchemaNode aug : parentAug.getAvailableAugmentations()) {
             final DataSchemaNode potential = aug.getDataChildByName(child.getQName());
             if (potential != null) {
-                augmentation = aug;
-                break;
+                return new InstanceIdToCompositeNodes.AugmentationNormalization(aug, parent);
             }
-
-        }
-        if (augmentation != null) {
-            return new InstanceIdToCompositeNodes.AugmentationNormalization(augmentation, parent);
         }
         return fromDataSchemaNode(child);
     }
@@ -236,16 +216,12 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
         if (keyDefinition == null || keyDefinition.isEmpty()) {
             return new UnkeyedListMixinNormalization(potential);
         }
-        if (potential.isUserOrdered()) {
-            return new InstanceIdToCompositeNodes.OrderedMapMixinNormalization(potential);
-        }
-        return new InstanceIdToCompositeNodes.UnorderedMapMixinNormalization(potential);
+        return potential.isUserOrdered() ? new InstanceIdToCompositeNodes.OrderedMapMixinNormalization(potential)
+                : new InstanceIdToCompositeNodes.UnorderedMapMixinNormalization(potential);
     }
 
     private static InstanceIdToNodes<?> fromLeafListSchemaNode(final LeafListSchemaNode potential) {
-        if (potential.isUserOrdered()) {
-            return new InstanceIdToCompositeNodes.OrderedLeafListMixinNormalization(potential);
-        }
-        return new InstanceIdToCompositeNodes.UnorderedLeafListMixinNormalization(potential);
+        return potential.isUserOrdered() ? new InstanceIdToCompositeNodes.OrderedLeafListMixinNormalization(potential)
+                : new InstanceIdToCompositeNodes.UnorderedLeafListMixinNormalization(potential);
     }
 }

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToSimpleNodes.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToSimpleNodes.java
index 1d246f4726394a5164720f3183529f360caa08e6..a5ab2cc89367a094ccd4fbf1ce22dba7d42c1989 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToSimpleNodes.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/InstanceIdToSimpleNodes.java
@@ -8,13 +8,12 @@
 package org.opendaylight.yangtools.yang.data.impl.schema;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
 
+import java.util.Iterator;
 import java.util.Map.Entry;
 import java.util.Optional;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.ModifyAction;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@@ -30,17 +29,15 @@ import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 */
 abstract class InstanceIdToSimpleNodes<T extends PathArgument> extends InstanceIdToNodes<T> {
 
-    protected InstanceIdToSimpleNodes(final T identifier) {
+    InstanceIdToSimpleNodes(final T identifier) {
         super(identifier);
     }
 
     @Override
-    public NormalizedNode<?, ?> create(final YangInstanceIdentifier instanceId,
+    final NormalizedNode<?, ?> create(final PathArgument first, final Iterator<PathArgument> others,
             final Optional<NormalizedNode<?, ?>> deepestChild, final Optional<Entry<QName, ModifyAction>> operation) {
-        checkNotNull(instanceId);
-        final PathArgument pathArgument = instanceId.getPathArguments().get(0);
         final NormalizedNodeAttrBuilder<? extends PathArgument, Object,
-                ? extends NormalizedNode<? extends PathArgument, Object>> builder = getBuilder(pathArgument);
+                ? extends NormalizedNode<? extends PathArgument, Object>> builder = getBuilder(first);
 
         if (deepestChild.isPresent()) {
             builder.withValue(deepestChild.get().getValue());
@@ -50,29 +47,28 @@ abstract class InstanceIdToSimpleNodes<T extends PathArgument> extends InstanceI
         return builder.build();
     }
 
-    protected abstract NormalizedNodeAttrBuilder<? extends PathArgument, Object,
-            ? extends NormalizedNode<? extends PathArgument, Object>> getBuilder(PathArgument node);
-
     @Override
-    public InstanceIdToNodes<?> getChild(final PathArgument child) {
+    final InstanceIdToNodes<?> getChild(final PathArgument child) {
         return null;
     }
 
+    @Override
+    final boolean isMixin() {
+        return false;
+    }
+
+    abstract NormalizedNodeAttrBuilder<? extends PathArgument, Object,
+            ? extends NormalizedNode<? extends PathArgument, Object>> getBuilder(PathArgument node);
+
     static final class LeafNormalization extends InstanceIdToSimpleNodes<NodeIdentifier> {
         LeafNormalization(final LeafSchemaNode potential) {
             super(new NodeIdentifier(potential.getQName()));
         }
 
         @Override
-        protected NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> getBuilder(
-                final PathArgument node) {
+        NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> getBuilder(final PathArgument node) {
             return Builders.leafBuilder().withNodeIdentifier(getIdentifier());
         }
-
-        @Override
-        boolean isMixin() {
-            return false;
-        }
     }
 
     static final class LeafListEntryNormalization extends InstanceIdToSimpleNodes<NodeWithValue> {
@@ -81,16 +77,10 @@ abstract class InstanceIdToSimpleNodes<T extends PathArgument> extends InstanceI
         }
 
         @Override
-        protected NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> getBuilder(
-                final PathArgument node) {
+        NormalizedNodeAttrBuilder<NodeWithValue, Object, LeafSetEntryNode<Object>> getBuilder(final PathArgument node) {
             checkArgument(node instanceof NodeWithValue);
             return Builders.leafSetEntryBuilder().withNodeIdentifier((NodeWithValue<?>) node)
                     .withValue(((NodeWithValue<?>) node).getValue());
         }
-
-        @Override
-        boolean isMixin() {
-            return false;
-        }
     }
 }