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=75ffa0153f7ce8d84b6c2b6a0ece45dc45cee124;hb=191052b2c293127f62f39802da76151653cf369b;hp=b1a073eb5322f3eff0f070806df42efa56c1ae34;hpb=fda572130077da8029e12bb770b0b8c8fb7890d0;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 b1a073eb53..75ffa0153f 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
@@ -8,26 +8,29 @@
 package org.opendaylight.mdsal.binding.dom.codec.impl;
 
 import java.io.IOException;
-import org.opendaylight.yangtools.yang.binding.BindingSerializer;
-import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
+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.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * Serializer of Binding objects to Normalized Node which uses {@link BindingNormalizedNodeCache} to
+ * Serializer of Binding objects to Normalized Node which uses {@link DataObjectNormalizedNodeCache} to
  * cache already serialized values.
  *
  * <p>
  * This serializer implements {@link BindingStreamEventWriter} along with {@link BindingSerializer}.
  *
  * <p>
- * {@link BindingSerializer} interface is used by generated implementations of
- * {@link org.opendaylight.yangtools.yang.binding.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 DataObjectSerializer} to provide
+ * Binding object for inspection and to prevent streaming of already serialized object.
  */
-final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEventWriter implements
-        BindingSerializer<Object, DataObject> {
+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;
@@ -43,7 +46,7 @@ final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEvent
     }
 
     @Override
-    protected BindingStreamEventWriter delegate() {
+    protected AnydataBindingStreamWriter delegate() {
         return delegate;
     }
 
@@ -51,6 +54,34 @@ final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEvent
         return domResult.getResult();
     }
 
+    @Override
+    public void leafNode(final String localName, final Object value) throws IOException {
+        if (value instanceof TypeObject) {
+            // 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();
+            if (cacheHolder.isCached(type)) {
+                final ValueNodeCodecContext context = ((DataObjectCodecContext<?, ?>) delegate.current())
+                        .getLeafChild(localName);
+                if (context instanceof OfTypeObject) {
+                    final AbstractBindingNormalizedNodeCache<TypeObject, ?> cache = cacheHolder.getCachingSerializer(
+                        (OfTypeObject<?>)context);
+                    if (cache != null) {
+                        // We have a cache hit and are thus done
+                        domWriter.addChild(cache.get(typed));
+                        return;
+                    }
+
+                    LOG.debug("Unexpected failure to acquire cache for context {}, skipping caching", context);
+                } else {
+                    LOG.debug("Context {} does not match expected TypeObject {}, skipping caching", context, typed);
+                }
+            }
+        }
+        super.leafNode(localName, value);
+    }
+
     /**
      * Serializes input if it is cached, returns null otherwise.
      *
@@ -61,12 +92,13 @@ final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEvent
      *
      * <p>
      * Note that this optional is serialization of child node invoked from
-     * {@link org.opendaylight.yangtools.yang.binding.DataObjectSerializer}, which may opt-out from
+     * {@link org.opendaylight.mdsal.binding.dom.codec.impl.DataObjectSerializer}, which may opt-out from
      * streaming of data when non-null result is returned.
      */
     @Override
     public NormalizedNode<?, ?> serialize(final DataObject input) {
-        final BindingNormalizedNodeCache cachingSerializer = getCacheSerializer(input.implementedInterface());
+        final AbstractBindingNormalizedNodeCache<DataObject, ?> cachingSerializer = getCacheSerializer(
+            input.implementedInterface());
         if (cachingSerializer != null) {
             final NormalizedNode<?, ?> domData = cachingSerializer.get(input);
             domWriter.addChild(domData);
@@ -75,26 +107,8 @@ final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEvent
         return null;
     }
 
-    /**
-     * Serializes supplied data using stream writer with child cache enabled or using cache directly
-     * if cache is avalaible also for supplied Codec node.
-     *
-     * @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<?, ?> serialize(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
-            final DataContainerCodecContext<?, ?> subtreeRoot, final DataObject data) {
-        final BindingNormalizedNodeCache cache = cacheHolder.getCachingSerializer(subtreeRoot);
-        if (cache != null) {
-            return cache.get(data);
-        }
-        return serializeUsingStreamWriter(cacheHolder, subtreeRoot, data);
-    }
-
-    @SuppressWarnings({"rawtypes", "unchecked"})
-    private BindingNormalizedNodeCache getCacheSerializer(final Class type) {
+    private AbstractBindingNormalizedNodeCache<DataObject, ?> getCacheSerializer(
+            final Class<? extends DataObject> type) {
         if (cacheHolder.isCached(type)) {
             final DataContainerCodecContext<?, ?> currentCtx = (DataContainerCodecContext<?, ?>) delegate.current();
             if (type.equals(currentCtx.getBindingClass())) {