Retain protype in DataContainerCodecContext

[mdsal.git] / binding / mdsal-binding-dom-codec / src / main / java / org / opendaylight / mdsal / binding / dom / codec / impl / BindingToNormalizedStreamWriter.java

diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingToNormalizedStreamWriter.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingToNormalizedStreamWriter.java
index 30fd3282ddb06c8263af55d49be030c7b1823b79..7ae433121825ed9b304cb44375bdcbd139a2c9d6 100644 (file)
--- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingToNormalizedStreamWriter.java
+++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/BindingToNormalizedStreamWriter.java
@@ -21,11 +21,10 @@ import org.opendaylight.yangtools.concepts.Delegator;
 import org.opendaylight.yangtools.yang.binding.Augmentation;
 import org.opendaylight.yangtools.yang.binding.DataContainer;
 import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.Identifiable;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.Key;
+import org.opendaylight.yangtools.yang.binding.KeyAware;
 import org.opendaylight.yangtools.yang.binding.OpaqueObject;
 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;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
@@ -34,11 +33,11 @@ import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 
 final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWriter,
         Delegator<NormalizedNodeStreamWriter> {
-    private final Deque<NodeCodecContext> schema = new ArrayDeque<>();
+    private final Deque<CodecContext> schema = new ArrayDeque<>();
     private final @NonNull NormalizedNodeStreamWriter delegate;
-    private final NodeCodecContext rootContext;
+    private final CodecContext rootContext;
 
-    BindingToNormalizedStreamWriter(final DataContainerCodecContext<?, ?> rootContext,
+    BindingToNormalizedStreamWriter(final DataContainerCodecContext<?, ?, ?> rootContext,
             final NormalizedNodeStreamWriter delegate) {
         this.rootContext = requireNonNull(rootContext);
         this.delegate = requireNonNull(delegate);
@@ -48,13 +47,13 @@ final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWrite
         delegate.nextDataSchemaNode((DataSchemaNode) schemaNode);
     }
 
-    NodeCodecContext current() {
+    CodecContext current() {
         return schema.peek();
     }
 
     private NodeIdentifier duplicateSchemaEnter() {
         final var current = current();
-        final NodeCodecContext next;
+        final CodecContext next;
         if (current == null) {
             // Entry of first node
             next = rootContext;
@@ -62,18 +61,18 @@ final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWrite
             next = current;
         }
         schema.push(next);
-        return (NodeIdentifier) next.getDomPathArgument();
+        return next.getDomPathArgument();
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})
     private <T extends YangInstanceIdentifier.PathArgument> T enter(final Class<?> name, final Class<T> identifier) {
         final var current = current();
-        final NodeCodecContext next;
+        final CodecContext next;
         if (current == null) {
             // Entry of first node
             next = rootContext;
-        } else if (current instanceof DataContainerCodecContext<?, ?> currentContainer) {
-            next = currentContainer.streamChild((Class) name);
+        } else if (current instanceof DataContainerCodecContext<?, ?, ?> currentContainer) {
+            next = currentContainer.getStreamChild((Class) name);
         } else {
             throw new IllegalArgumentException("Could not start node " + name + " in non-container " + current);
         }
@@ -83,7 +82,7 @@ final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWrite
 
     private <T extends YangInstanceIdentifier.PathArgument> T enter(final String localName, final Class<T> identifier) {
         final var current = current();
-        final var next = ((DataObjectCodecContext<?, ?>) current).getLeafChild(localName);
+        final var next = ((AbstractDataObjectCodecContext<?, ?>) current).getLeafChild(localName);
         schema.push(next);
         return identifier.cast(next.getDomPathArgument());
     }
@@ -95,17 +94,17 @@ final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWrite
 
     @Override
     public void endNode() throws IOException {
-        NodeCodecContext left = schema.pop();
-        // NormalizedNode writer does not have entry into case, but into choice
-        // so for leaving case, we do not emit endNode.
-        if (!(left instanceof CaseNodeCodecContext)) {
+        CodecContext left = schema.pop();
+        // Due to writer does not start a new node on startCase() and on startAugmentationNode()
+        // node ending should not be triggered when associated endNode() is invoked.
+        if (!(left instanceof CaseCodecContext) && !(left instanceof AugmentationCodecContext)) {
             delegate.endNode();
         }
     }
 
     private Map.Entry<NodeIdentifier, Object> serializeLeaf(final String localName, final Object value) {
         final var current = current();
-        if (!(current instanceof DataObjectCodecContext<?, ?> currentCasted)) {
+        if (!(current instanceof AbstractDataObjectCodecContext<?, ?> currentCasted)) {
             throw new IllegalArgumentException("Unexpected current context " + current);
         }
 
@@ -153,9 +152,8 @@ final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWrite
     }
 
     @Override
-    public void startAugmentationNode(final Class<? extends Augmentation<?>> augmentationType)
-            throws IOException {
-        delegate.startAugmentationNode(enter(augmentationType, AugmentationIdentifier.class));
+    public void startAugmentationNode(final Class<? extends Augmentation<?>> augmentationType) throws IOException {
+        enter(augmentationType, NodeIdentifier.class);
     }
 
     @Override
@@ -188,20 +186,20 @@ final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWrite
     }
 
     @Override
-    public void startMapEntryNode(final Identifier<?> key, final int childSizeHint) throws IOException {
+    public void startMapEntryNode(final Key<?> key, final int childSizeHint) throws IOException {
         duplicateSchemaEnter();
-        NodeIdentifierWithPredicates identifier = ((KeyedListNodeCodecContext<?, ?>) current()).serialize(key);
+        NodeIdentifierWithPredicates identifier = ((MapCodecContext<?, ?>) current()).serialize(key);
         delegate.startMapEntryNode(identifier, childSizeHint);
     }
 
     @Override
-    public <T extends DataObject & Identifiable<?>> void startMapNode(final Class<T> mapEntryType,
-            final int childSizeHint) throws IOException {
+    public <T extends DataObject & KeyAware<?>> void startMapNode(final Class<T> mapEntryType, final int childSizeHint)
+            throws IOException {
         delegate.startMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
     }
 
     @Override
-    public <T extends DataObject & Identifiable<?>> void startOrderedMapNode(final Class<T> mapEntryType,
+    public <T extends DataObject & KeyAware<?>> void startOrderedMapNode(final Class<T> mapEntryType,
             final int childSizeHint) throws IOException {
         delegate.startOrderedMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
     }