Fix AnyXml node handling

[yangtools.git] / yang / yang-data-impl / src / main / java / org / opendaylight / yangtools / yang / data / impl / schema / InstanceIdToNodes.java

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 0185f57cd4b7fe2a332b99ac6c4d7dd1cda0aa52..05ae74df6e0663cb8a199f266cd924273db29e10 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
@@ -22,9 +22,11 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdent
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
 import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.AttributesBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
 import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
@@ -46,7 +48,7 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
     private final T identifier;
 
     @Override
-    public T getIdentifier() {
+    public final T getIdentifier() {
         return identifier;
     }
 
@@ -73,9 +75,10 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
      */
     abstract NormalizedNode<?, ?> create(YangInstanceIdentifier instanceId, Optional<NormalizedNode<?, ?>> deepestChild, Optional<Entry<QName,ModifyAction>> operation);
 
+    abstract boolean isMixin();
 
     public void addModifyOpIfPresent(final Optional<Entry<QName,ModifyAction>> operation, final AttributesBuilder<?> builder) {
-        if(operation.isPresent()) {
+        if (operation.isPresent()) {
             builder.withAttributes(Collections.singletonMap(operation.get().getKey(), modifyOperationToXmlString(operation.get().getValue())));
         }
     }
@@ -84,27 +87,17 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
         return operation.name().toLowerCase();
     }
 
-    static boolean isMixin(final InstanceIdToNodes<?> op) {
-        return op instanceof MixinNormalizationOp;
-    }
-
-    /**
-     * Marker interface for Mixin nodes normalization operations
-     */
-    interface MixinNormalizationOp {}
-
-
-    private static class UnkeyedListMixinNormalization extends InstanceIdToCompositeNodes<NodeIdentifier> implements MixinNormalizationOp {
+    private final static class UnkeyedListMixinNormalization extends InstanceIdToCompositeNodes<NodeIdentifier> {
 
         private final UnkeyedListItemNormalization innerNode;
 
         public UnkeyedListMixinNormalization(final ListSchemaNode list) {
-            super(new NodeIdentifier(list.getQName()));
+            super(NodeIdentifier.create(list.getQName()));
             this.innerNode = new UnkeyedListItemNormalization(list);
         }
 
         @Override
-        protected NormalizedNodeContainerBuilder<?, ?, ?, ?> createBuilder(final PathArgument compositeNode) {
+        protected CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> createBuilder(final PathArgument compositeNode) {
             return Builders.unkeyedListBuilder().withNodeIdentifier(getIdentifier());
         }
 
@@ -115,12 +108,17 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
             }
             return null;
         }
+
+        @Override
+        boolean isMixin() {
+            return true;
+        }
     }
 
     private static class AnyXmlNormalization extends InstanceIdToNodes<NodeIdentifier> {
 
         protected AnyXmlNormalization(final AnyXmlSchemaNode schema) {
-            super(new NodeIdentifier(schema.getQName()));
+            super(NodeIdentifier.create(schema.getQName()));
         }
 
         @Override
@@ -129,11 +127,15 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
         }
 
         @Override
-        public NormalizedNode<?, ?> create(final YangInstanceIdentifier instanceId, final Optional<NormalizedNode<?, ?>> deepestChild, final Optional<Entry<QName,ModifyAction>> operation) {
-            if(deepestChild.isPresent()) {
-                Preconditions.checkState(deepestChild instanceof AnyXmlNode);
+        public NormalizedNode<?, ?> create(final YangInstanceIdentifier instanceId,
+                final Optional<NormalizedNode<?, ?>> deepestChild,
+                final Optional<Entry<QName,ModifyAction>> operation) {
+            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) deepestChild).getValue());
+                        Builders.anyXmlBuilder().withNodeIdentifier(getIdentifier()).withValue(((AnyXmlNode) child).getValue());
                 addModifyOpIfPresent(operation, anyXmlBuilder);
                 return anyXmlBuilder.build();
             }
@@ -144,6 +146,10 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
             return builder.build();
         }
 
+        @Override
+        boolean isMixin() {
+            return false;
+        }
     }
 
     private static Optional<DataSchemaNode> findChildSchemaNode(final DataNodeContainer parent, final QName child) {
@@ -162,7 +168,7 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
 
         final DataSchemaNode result = potential.get();
         // We try to look up if this node was added by augmentation
-        if ((schema instanceof DataSchemaNode) && result.isAugmenting()) {
+        if (schema instanceof DataSchemaNode && result.isAugmenting()) {
             return fromAugmentation(schema, (AugmentationTarget) schema, result);
         }
         return fromDataSchemaNode(result);
@@ -203,9 +209,8 @@ abstract class InstanceIdToNodes<T extends PathArgument> implements Identifiable
         }
         if (augmentation != null) {
             return new InstanceIdToCompositeNodes.AugmentationNormalization(augmentation, parent);
-        } else {
-            return fromDataSchemaNode(child);
         }
+        return fromDataSchemaNode(child);
     }
 
     static InstanceIdToNodes<?> fromDataSchemaNode(final DataSchemaNode potential) {