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 java.io.IOException;
  11 import org.opendaylight.yangtools.yang.binding.BindingSerializer;
  12 import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
  13 import org.opendaylight.yangtools.yang.binding.DataObject;
  14 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  15 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  16
  17 /**
  18  * Serializer of Binding objects to Normalized Node which uses {@link BindingNormalizedNodeCache} to
  19  * cache already serialized values.
  20  *
  21  * <p>
  22  * This serializer implements {@link BindingStreamEventWriter} along with {@link BindingSerializer}.
  23  *
  24  * <p>
  25  * {@link BindingSerializer} interface is used by generated implementations of
  26  * {@link org.opendaylight.yangtools.yang.binding.DataObjectSerializer} to provide Binding object
  27  * for inspection and to prevent streaming of already serialized object.
  28  */
  29 final class CachingNormalizedNodeSerializer extends ForwardingBindingStreamEventWriter implements
  30         BindingSerializer<Object, DataObject> {
  31
  32     private final NormalizedNodeResult domResult;
  33     private final NormalizedNodeWriterWithAddChild domWriter;
  34     private final BindingToNormalizedStreamWriter delegate;
  35     private final AbstractBindingNormalizedNodeCacheHolder cacheHolder;
  36
  37     CachingNormalizedNodeSerializer(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
  38             final DataContainerCodecContext<?, ?> subtreeRoot) {
  39         this.cacheHolder = cacheHolder;
  40         this.domResult = new NormalizedNodeResult();
  41         this.domWriter = new NormalizedNodeWriterWithAddChild(domResult);
  42         this.delegate = BindingToNormalizedStreamWriter.create(subtreeRoot, domWriter);
  43     }
  44
  45     @Override
  46     protected BindingStreamEventWriter delegate() {
  47         return delegate;
  48     }
  49
  50     NormalizedNode<?, ?> build() {
  51         return domResult.getResult();
  52     }
  53
  54     /**
  55      * Serializes input if it is cached, returns null otherwise.
  56      *
  57      * <p>
  58      * If input is cached it uses {@link NormalizedNodeWriterWithAddChild#addChild(NormalizedNode)}
  59      * to provide already serialized value to underlying NormalizedNodeWriter in order to reuse
  60      * value instead of creating new one using Normalized Node stream APIs.
  61      *
  62      * <p>
  63      * Note that this optional is serialization of child node invoked from
  64      * {@link org.opendaylight.yangtools.yang.binding.DataObjectSerializer}, which may opt-out from
  65      * streaming of data when non-null result is returned.
  66      */
  67     @Override
  68     public NormalizedNode<?, ?> serialize(final DataObject input) {
  69         final BindingNormalizedNodeCache cachingSerializer = getCacheSerializer(input.getImplementedInterface());
  70         if (cachingSerializer != null) {
  71             final NormalizedNode<?, ?> domData = cachingSerializer.get(input);
  72             domWriter.addChild(domData);
  73             return domData;
  74         }
  75         return null;
  76     }
  77
  78     /**
  79      * Serializes supplied data using stream writer with child cache enabled or using cache directly
  80      * if cache is avalaible also for supplied Codec node.
  81      *
  82      * @param cacheHolder Binding to Normalized Node Cache holder
  83      * @param subtreeRoot Codec Node for provided data object
  84      * @param data Data to be serialized
  85      * @return Normalized Node representation of data.
  86      */
  87     static NormalizedNode<?, ?> serialize(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
  88             final DataContainerCodecContext<?, ?> subtreeRoot, final DataObject data) {
  89         final BindingNormalizedNodeCache cache = cacheHolder.getCachingSerializer(subtreeRoot);
  90         if (cache != null) {
  91             return cache.get(data);
  92         }
  93         return serializeUsingStreamWriter(cacheHolder, subtreeRoot, data);
  94     }
  95
  96     @SuppressWarnings({"rawtypes", "unchecked"})
  97     private BindingNormalizedNodeCache getCacheSerializer(final Class type) {
  98         if (cacheHolder.isCached(type)) {
  99             final DataContainerCodecContext<?, ?> currentCtx = (DataContainerCodecContext<?, ?>) delegate.current();
 100             if (type.equals(currentCtx.getBindingClass())) {
 101                 return cacheHolder.getCachingSerializer(currentCtx);
 102             }
 103             return cacheHolder.getCachingSerializer(currentCtx.streamChild(type));
 104         }
 105         return null;
 106     }
 107
 108     /**
 109      * Serializes supplied data using stream writer with child cache enabled.
 110      *
 111      * @param cacheHolder Binding to Normalized Node Cache holder
 112      * @param subtreeRoot Codec Node for provided data object
 113      * @param data Data to be serialized
 114      * @return Normalized Node representation of data.
 115      */
 116     static NormalizedNode<?, ?> serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
 117             final DataContainerCodecContext<?, ?> subtreeRoot, final DataObject data) {
 118         final CachingNormalizedNodeSerializer writer = new CachingNormalizedNodeSerializer(cacheHolder, subtreeRoot);
 119         try {
 120             subtreeRoot.eventStreamSerializer().serialize(data, writer);
 121             return writer.build();
 122         } catch (final IOException e) {
 123             throw new RuntimeException(e);
 124         }
 125     }
 126 }