binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/CachingNormalizedNodeSerializer.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.dom.codec.impl;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import java.io.IOException;
  13 import org.opendaylight.mdsal.binding.dom.codec.api.BindingStreamEventWriter;
  14 import org.opendaylight.yangtools.yang.binding.DataObject;
  15 import org.opendaylight.yangtools.yang.binding.TypeObject;
  16 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  17 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
  18 import org.slf4j.Logger;
  19 import org.slf4j.LoggerFactory;
  20
  21 /**
  22  * Serializer of Binding objects to Normalized Node which uses {@link DataObjectNormalizedNodeCache} to
  23  * cache already serialized values.
  24  *
  25  * <p>
  26  * This serializer implements {@link BindingStreamEventWriter} along with {@link BindingSerializer}.
  27  *
  28  * <p>
  29  * {@link BindingSerializer} interface is used by generated implementations of {@link DataContainerSerializer} to
  30  * provide Binding object for inspection and to prevent streaming of already serialized object.
  31  */
  32 final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEventWriter
  33         implements BindingSerializer<Object, DataObject> {
  34     private static final Logger LOG = LoggerFactory.getLogger(CachingNormalizedNodeSerializer.class);
  35
  36     private final NormalizationResultHolder domResult = new NormalizationResultHolder();
  37     private final NormalizedNodeWriterWithAddChild domWriter = new NormalizedNodeWriterWithAddChild(domResult);
  38     private final AbstractBindingNormalizedNodeCacheHolder cacheHolder;
  39     private final BindingToNormalizedStreamWriter delegate;
  40
  41     private CachingNormalizedNodeSerializer(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
  42             final DataContainerCodecContext<?, ?, ?> subtreeRoot) {
  43         this.cacheHolder = requireNonNull(cacheHolder);
  44         delegate = new BindingToNormalizedStreamWriter(subtreeRoot, domWriter);
  45     }
  46
  47     /**
  48      * Serializes supplied data using stream writer with child cache enabled.
  49      *
  50      * @param cacheHolder Binding to Normalized Node Cache holder
  51      * @param subtreeRoot Codec Node for provided data object
  52      * @param data Data to be serialized
  53      * @return Normalized Node representation of data.
  54      */
  55     static NormalizedNode serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
  56             final DataContainerCodecContext<?, ?, ?> subtreeRoot, final DataObject data) {
  57         final var writer = new CachingNormalizedNodeSerializer(cacheHolder, subtreeRoot);
  58         try {
  59             subtreeRoot.eventStreamSerializer().serialize(data, writer);
  60         } catch (final IOException e) {
  61             throw new IllegalStateException(e);
  62         }
  63         return writer.domResult.getResult().data();
  64     }
  65
  66     @Override
  67     protected AnydataBindingStreamWriter delegate() {
  68         return delegate;
  69     }
  70
  71     @Override
  72     public void leafNode(final String localName, final Object value) throws IOException {
  73         if (value instanceof TypeObject typed) {
  74             // TypeObject is a tagging interface used for generated classes which wrap derived and restricted types.
  75             // They are immutable and hence we can safely wrap them in LeafNodes and reuse them, if directed to do so.
  76             final var type = typed.getClass();
  77             if (cacheHolder.isCached(type)) {
  78                 final var context = ((AbstractDataObjectCodecContext<?, ?>) delegate.current()).getLeafChild(localName);
  79                 if (context instanceof LeafNodeCodecContext.OfTypeObject<?> typeContext) {
  80                     final var cache = cacheHolder.getCachingSerializer(typeContext);
  81                     if (cache != null) {
  82                         // We have a cache hit and are thus done
  83                         domWriter.addChild(cache.get(typed));
  84                         return;
  85                     }
  86
  87                     LOG.debug("Unexpected failure to acquire cache for context {}, skipping caching", context);
  88                 } else {
  89                     LOG.debug("Context {} does not match expected TypeObject {}, skipping caching", context, typed);
  90                 }
  91             }
  92         }
  93         super.leafNode(localName, value);
  94     }
  95
  96     /**
  97      * Serializes input if it is cached, returns null otherwise.
  98      *
  99      * <p>
 100      * If input is cached it uses {@link NormalizedNodeWriterWithAddChild#addChild(NormalizedNode)}
 101      * to provide already serialized value to underlying NormalizedNodeWriter in order to reuse
 102      * value instead of creating new one using Normalized Node stream APIs.
 103      *
 104      * <p>
 105      * Note that this optional is serialization of child node invoked from
 106      * {@link org.opendaylight.mdsal.binding.dom.codec.impl.DataContainerSerializer}, which may opt-out from
 107      * streaming of data when non-null result is returned.
 108      */
 109     @Override
 110     public NormalizedNode serialize(final DataObject input) {
 111         final var cachingSerializer = getCacheSerializer(input.implementedInterface());
 112         if (cachingSerializer != null) {
 113             final var domData = cachingSerializer.get(input);
 114             domWriter.addChild(domData);
 115             return domData;
 116         }
 117         return null;
 118     }
 119
 120     private AbstractBindingNormalizedNodeCache<DataObject, ?> getCacheSerializer(
 121             final Class<? extends DataObject> type) {
 122         if (cacheHolder.isCached(type)) {
 123             final var currentCtx = (DataContainerCodecContext<?, ?, ?>) delegate.current();
 124             if (type.equals(currentCtx.getBindingClass())) {
 125                 return cacheHolder.getCachingSerializer(currentCtx);
 126             }
 127             return cacheHolder.getCachingSerializer(currentCtx.getStreamChild(type));
 128         }
 129         return null;
 130     }
 131 }