Expose underlying schema from DataContainerNormalizationOperation

For the purposes for normalizing data child order we will need to
access the underlying schema in a type-safe manner -- this adds
the mechanics to do so.

JIRA: YANGTOOLS-1037
Change-Id: Id52bd0988405429fbee87a88bb2c9d1de093fb30
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
(cherry picked from commit ee532866b58374349522c42e77f575fb9f99ba03)

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 d3b66eba0d5d3f2d4468e1f8ec21f34361f4f4bd..8c7695517fb5b1d2c90aab37aac2d81ebc735b82 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,6 +8,7 @@
 package org.opendaylight.yangtools.yang.data.impl.schema;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -17,6 +18,7 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
@@ -94,25 +96,28 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
 
     abstract NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(PathArgument compositeNode);
 
-    abstract static class DataContainerNormalizationOperation<T extends PathArgument>
+    abstract static class DataContainerNormalizationOperation<T extends PathArgument, S extends DataNodeContainer>
             extends InstanceIdToCompositeNodes<T> {
 
         private final Map<PathArgument, InstanceIdToNodes<?>> byArg = new ConcurrentHashMap<>();
-        private final DataNodeContainer schema;
+        private final @NonNull S schema;
 
-        DataContainerNormalizationOperation(final T identifier, final DataNodeContainer schema) {
+        DataContainerNormalizationOperation(final T identifier, final S schema) {
             super(identifier);
-            this.schema = schema;
+            this.schema = requireNonNull(schema);
         }
 
         @Override
         final InstanceIdToNodes<?> getChild(final PathArgument child) {
-            InstanceIdToNodes<?> potential = byArg.get(child);
-            if (potential != null) {
-                return potential;
+            final InstanceIdToNodes<?> existing = byArg.get(child);
+            if (existing != null) {
+                return existing;
             }
-            potential = fromLocalSchema(child);
-            return register(potential);
+            return register(fromLocalSchema(child));
+        }
+
+        final @NonNull S schema() {
+            return schema;
         }
 
         private InstanceIdToNodes<?> fromLocalSchema(final PathArgument child) {
@@ -131,7 +136,8 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
     }
 
-    static final class MapEntryNormalization extends DataContainerNormalizationOperation<NodeIdentifierWithPredicates> {
+    static final class MapEntryNormalization
+            extends DataContainerNormalizationOperation<NodeIdentifierWithPredicates, ListSchemaNode> {
         MapEntryNormalization(final ListSchemaNode schema) {
             super(NodeIdentifierWithPredicates.of(schema.getQName()), schema);
         }
@@ -156,7 +162,8 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
     }
 
-    static final class UnkeyedListItemNormalization extends DataContainerNormalizationOperation<NodeIdentifier> {
+    static final class UnkeyedListItemNormalization
+            extends DataContainerNormalizationOperation<NodeIdentifier, ListSchemaNode> {
         UnkeyedListItemNormalization(final ListSchemaNode schema) {
             super(NodeIdentifier.create(schema.getQName()), schema);
         }
@@ -173,7 +180,8 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
     }
 
-    static final class ContainerTransformation extends DataContainerNormalizationOperation<NodeIdentifier> {
+    static final class ContainerTransformation
+            extends DataContainerNormalizationOperation<NodeIdentifier, ContainerSchemaNode> {
         ContainerTransformation(final ContainerSchemaNode schema) {
             super(NodeIdentifier.create(schema.getQName()), schema);
         }
@@ -224,7 +232,8 @@ abstract class InstanceIdToCompositeNodes<T extends PathArgument> extends Instan
         }
     }
 
-    static final class AugmentationNormalization extends DataContainerNormalizationOperation<AugmentationIdentifier> {
+    static final class AugmentationNormalization
+            extends DataContainerNormalizationOperation<AugmentationIdentifier, AugmentationSchemaNode> {
         AugmentationNormalization(final AugmentationSchemaNode augmentation, final DataNodeContainer schema) {
             super(DataSchemaContextNode.augmentationIdentifierFrom(augmentation),
                     EffectiveAugmentationSchema.create(augmentation, schema));