X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-dom-codec%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fdom%2Fcodec%2Fimpl%2FCachingNormalizedNodeSerializer.java;h=60cbccf998b45c4acee59fb22092cc680a97d09d;hb=3b18d17d6882c14b0f3542717e3ca539c0bc9593;hp=75ffa0153f7ce8d84b6c2b6a0ece45dc45cee124;hpb=bd39a0dd326cb6d5b538ad2aaf84e0f2195414f2;p=mdsal.git

diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/CachingNormalizedNodeSerializer.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/CachingNormalizedNodeSerializer.java
index 75ffa0153f..60cbccf998 100644
--- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/CachingNormalizedNodeSerializer.java
+++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/CachingNormalizedNodeSerializer.java
@@ -7,13 +7,14 @@
  */
 package org.opendaylight.mdsal.binding.dom.codec.impl;
 
+import static java.util.Objects.requireNonNull;
+
 import java.io.IOException;
 import org.opendaylight.mdsal.binding.dom.codec.api.BindingStreamEventWriter;
-import org.opendaylight.mdsal.binding.dom.codec.impl.LeafNodeCodecContext.OfTypeObject;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.TypeObject;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
+import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -25,24 +26,41 @@ import org.slf4j.LoggerFactory;
  * This serializer implements {@link BindingStreamEventWriter} along with {@link BindingSerializer}.
  *
  * <p>
- * {@link BindingSerializer} interface is used by generated implementations of {@link DataObjectSerializer} to provide
- * Binding object for inspection and to prevent streaming of already serialized object.
+ * {@link BindingSerializer} interface is used by generated implementations of {@link DataContainerSerializer} to
+ * provide Binding object for inspection and to prevent streaming of already serialized object.
  */
 final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEventWriter
         implements BindingSerializer<Object, DataObject> {
     private static final Logger LOG = LoggerFactory.getLogger(CachingNormalizedNodeSerializer.class);
 
-    private final NormalizedNodeResult domResult;
-    private final NormalizedNodeWriterWithAddChild domWriter;
-    private final BindingToNormalizedStreamWriter delegate;
+    private final NormalizationResultHolder domResult = new NormalizationResultHolder();
+    private final NormalizedNodeWriterWithAddChild domWriter = new NormalizedNodeWriterWithAddChild(domResult);
     private final AbstractBindingNormalizedNodeCacheHolder cacheHolder;
+    private final BindingToNormalizedStreamWriter delegate;
+
+    private CachingNormalizedNodeSerializer(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
+            final DataContainerCodecContext<?, ?, ?> subtreeRoot) {
+        this.cacheHolder = requireNonNull(cacheHolder);
+        delegate = new BindingToNormalizedStreamWriter(subtreeRoot, domWriter);
+    }
 
-    CachingNormalizedNodeSerializer(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
-            final DataContainerCodecContext<?, ?> subtreeRoot) {
-        this.cacheHolder = cacheHolder;
-        this.domResult = new NormalizedNodeResult();
-        this.domWriter = new NormalizedNodeWriterWithAddChild(domResult);
-        this.delegate = BindingToNormalizedStreamWriter.create(subtreeRoot, domWriter);
+    /**
+     * Serializes supplied data using stream writer with child cache enabled.
+     *
+     * @param cacheHolder Binding to Normalized Node Cache holder
+     * @param subtreeRoot Codec Node for provided data object
+     * @param data Data to be serialized
+     * @return Normalized Node representation of data.
+     */
+    static NormalizedNode serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
+            final DataContainerCodecContext<?, ?, ?> subtreeRoot, final DataObject data) {
+        final var writer = new CachingNormalizedNodeSerializer(cacheHolder, subtreeRoot);
+        try {
+            subtreeRoot.eventStreamSerializer().serialize(data, writer);
+        } catch (final IOException e) {
+            throw new IllegalStateException(e);
+        }
+        return writer.domResult.getResult().data();
     }
 
     @Override
@@ -50,23 +68,16 @@ final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEvent
         return delegate;
     }
 
-    NormalizedNode<?, ?> build() {
-        return domResult.getResult();
-    }
-
     @Override
     public void leafNode(final String localName, final Object value) throws IOException {
-        if (value instanceof TypeObject) {
+        if (value instanceof TypeObject typed) {
             // TypeObject is a tagging interface used for generated classes which wrap derived and restricted types.
             // They are immutable and hence we can safely wrap them in LeafNodes and reuse them, if directed to do so.
-            final TypeObject typed = (TypeObject) value;
-            final Class<? extends TypeObject> type = typed.getClass();
+            final var type = typed.getClass();
             if (cacheHolder.isCached(type)) {
-                final ValueNodeCodecContext context = ((DataObjectCodecContext<?, ?>) delegate.current())
-                        .getLeafChild(localName);
-                if (context instanceof OfTypeObject) {
-                    final AbstractBindingNormalizedNodeCache<TypeObject, ?> cache = cacheHolder.getCachingSerializer(
-                        (OfTypeObject<?>)context);
+                final var context = ((AbstractDataObjectCodecContext<?, ?>) delegate.current()).getLeafChild(localName);
+                if (context instanceof LeafNodeCodecContext.OfTypeObject<?> typeContext) {
+                    final var cache = cacheHolder.getCachingSerializer(typeContext);
                     if (cache != null) {
                         // We have a cache hit and are thus done
                         domWriter.addChild(cache.get(typed));
@@ -92,15 +103,14 @@ final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEvent
      *
      * <p>
      * Note that this optional is serialization of child node invoked from
-     * {@link org.opendaylight.mdsal.binding.dom.codec.impl.DataObjectSerializer}, which may opt-out from
+     * {@link org.opendaylight.mdsal.binding.dom.codec.impl.DataContainerSerializer}, which may opt-out from
      * streaming of data when non-null result is returned.
      */
     @Override
-    public NormalizedNode<?, ?> serialize(final DataObject input) {
-        final AbstractBindingNormalizedNodeCache<DataObject, ?> cachingSerializer = getCacheSerializer(
-            input.implementedInterface());
+    public NormalizedNode serialize(final DataObject input) {
+        final var cachingSerializer = getCacheSerializer(input.implementedInterface());
         if (cachingSerializer != null) {
-            final NormalizedNode<?, ?> domData = cachingSerializer.get(input);
+            final var domData = cachingSerializer.get(input);
             domWriter.addChild(domData);
             return domData;
         }
@@ -110,31 +120,12 @@ final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEvent
     private AbstractBindingNormalizedNodeCache<DataObject, ?> getCacheSerializer(
             final Class<? extends DataObject> type) {
         if (cacheHolder.isCached(type)) {
-            final DataContainerCodecContext<?, ?> currentCtx = (DataContainerCodecContext<?, ?>) delegate.current();
+            final var currentCtx = (DataContainerCodecContext<?, ?, ?>) delegate.current();
             if (type.equals(currentCtx.getBindingClass())) {
                 return cacheHolder.getCachingSerializer(currentCtx);
             }
-            return cacheHolder.getCachingSerializer(currentCtx.streamChild(type));
+            return cacheHolder.getCachingSerializer(currentCtx.getStreamChild(type));
         }
         return null;
     }
-
-    /**
-     * Serializes supplied data using stream writer with child cache enabled.
-     *
-     * @param cacheHolder Binding to Normalized Node Cache holder
-     * @param subtreeRoot Codec Node for provided data object
-     * @param data Data to be serialized
-     * @return Normalized Node representation of data.
-     */
-    static NormalizedNode<?, ?> serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
-            final DataContainerCodecContext<?, ?> subtreeRoot, final DataObject data) {
-        final CachingNormalizedNodeSerializer writer = new CachingNormalizedNodeSerializer(cacheHolder, subtreeRoot);
-        try {
-            subtreeRoot.eventStreamSerializer().serialize(data, writer);
-            return writer.build();
-        } catch (final IOException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-}
\ No newline at end of file
+}