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

   1 /*
   2  * Copyright (c) 2014 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 com.google.common.base.Preconditions.checkArgument;
  11 import static java.util.Objects.requireNonNull;
  12
  13 import java.io.IOException;
  14 import java.util.AbstractMap;
  15 import java.util.ArrayDeque;
  16 import java.util.Deque;
  17 import java.util.Map;
  18 import java.util.Map.Entry;
  19 import javax.xml.transform.dom.DOMSource;
  20 import org.opendaylight.yangtools.concepts.Delegator;
  21 import org.opendaylight.yangtools.yang.binding.Augmentation;
  22 import org.opendaylight.yangtools.yang.binding.DataContainer;
  23 import org.opendaylight.yangtools.yang.binding.DataObject;
  24 import org.opendaylight.yangtools.yang.binding.Identifiable;
  25 import org.opendaylight.yangtools.yang.binding.Identifier;
  26 import org.opendaylight.yangtools.yang.binding.OpaqueObject;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  31 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  32 import org.opendaylight.yangtools.yang.data.api.schema.stream.AnydataExtension;
  33 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  34 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  35
  36 final class BindingToNormalizedStreamWriter implements AnydataBindingStreamWriter,
  37         Delegator<NormalizedNodeStreamWriter> {
  38     private final Deque<NodeCodecContext> schema = new ArrayDeque<>();
  39     private final NormalizedNodeStreamWriter delegate;
  40     private final NodeCodecContext rootNodeSchema;
  41
  42     BindingToNormalizedStreamWriter(final NodeCodecContext rootNodeSchema, final NormalizedNodeStreamWriter delegate) {
  43         this.rootNodeSchema = requireNonNull(rootNodeSchema);
  44         this.delegate = requireNonNull(delegate);
  45     }
  46
  47     static BindingToNormalizedStreamWriter create(final NodeCodecContext schema,
  48             final NormalizedNodeStreamWriter delegate) {
  49         return new BindingToNormalizedStreamWriter(schema, delegate);
  50     }
  51
  52     private void emitSchema(final Object schemaNode) {
  53         delegate.nextDataSchemaNode((DataSchemaNode) schemaNode);
  54     }
  55
  56     NodeCodecContext current() {
  57         return schema.peek();
  58     }
  59
  60     private NodeIdentifier duplicateSchemaEnter() {
  61         final NodeCodecContext next;
  62         if (current() == null) {
  63             // Entry of first node
  64             next = rootNodeSchema;
  65         } else {
  66             next = current();
  67         }
  68         this.schema.push(next);
  69         return (NodeIdentifier) current().getDomPathArgument();
  70     }
  71
  72     @SuppressWarnings({"unchecked", "rawtypes"})
  73     private <T extends YangInstanceIdentifier.PathArgument> T enter(final Class<?> name, final Class<T> identifier) {
  74         final NodeCodecContext next;
  75         if (current() == null) {
  76             // Entry of first node
  77             next = rootNodeSchema;
  78         } else {
  79             checkArgument(current() instanceof DataContainerCodecContext, "Could not start node %s", name);
  80             next = ((DataContainerCodecContext<?,?>) current()).streamChild((Class) name);
  81         }
  82         this.schema.push(next);
  83         T arg = (T) next.getDomPathArgument();
  84         return arg;
  85     }
  86
  87     private <T extends YangInstanceIdentifier.PathArgument> T enter(final String localName, final Class<T> identifier) {
  88         NodeCodecContext current = current();
  89         NodeCodecContext next = ((DataObjectCodecContext<?, ?>) current).getLeafChild(localName);
  90         this.schema.push(next);
  91         @SuppressWarnings("unchecked")
  92         T arg = (T) next.getDomPathArgument();
  93         return arg;
  94     }
  95
  96     @Override
  97     public NormalizedNodeStreamWriter getDelegate() {
  98         return delegate;
  99     }
 100
 101     @Override
 102     public void endNode() throws IOException {
 103         NodeCodecContext left = schema.pop();
 104         // NormalizedNode writer does not have entry into case, but into choice
 105         // so for leaving case, we do not emit endNode.
 106         if (!(left instanceof CaseNodeCodecContext)) {
 107             delegate.endNode();
 108         }
 109     }
 110
 111     private Map.Entry<NodeIdentifier, Object> serializeLeaf(final String localName, final Object value) {
 112         checkArgument(current() instanceof DataObjectCodecContext);
 113
 114         DataObjectCodecContext<?,?> currentCasted = (DataObjectCodecContext<?,?>) current();
 115         ValueNodeCodecContext leafContext = currentCasted.getLeafChild(localName);
 116
 117         NodeIdentifier domArg = leafContext.getDomPathArgument();
 118         Object domValue = leafContext.getValueCodec().serialize(value);
 119         emitSchema(leafContext.getSchema());
 120         return new AbstractMap.SimpleEntry<>(domArg, domValue);
 121     }
 122
 123     @Override
 124     public void leafNode(final String localName, final Object value) throws IOException {
 125         final Entry<NodeIdentifier, Object> dom = serializeLeaf(localName, value);
 126         delegate.startLeafNode(dom.getKey());
 127         delegate.scalarValue(dom.getValue());
 128         delegate.endNode();
 129     }
 130
 131     @Override
 132     public void anydataNode(final String name, final OpaqueObject<?> value) throws IOException {
 133         final AnydataExtension ext = delegate.getExtensions().getInstance(AnydataExtension.class);
 134         if (ext != null) {
 135             final Entry<NodeIdentifier, Object> dom = serializeLeaf(name, value);
 136             if (ext.startAnydataNode(dom.getKey(), value.getValue().getObjectModel())) {
 137                 delegate.scalarValue(dom.getValue());
 138                 delegate.endNode();
 139             }
 140         }
 141     }
 142
 143     @Override
 144     public void anyxmlNode(final String name, final Object value) throws IOException {
 145         final Entry<NodeIdentifier, Object> dom = serializeLeaf(name, value);
 146         delegate.startAnyxmlNode(dom.getKey());
 147         delegate.domSourceValue((DOMSource) dom.getValue());
 148         delegate.endNode();
 149     }
 150
 151     @Override
 152     public void leafSetEntryNode(final Object value) throws IOException {
 153         final LeafSetNodeCodecContext ctx = (LeafSetNodeCodecContext) current();
 154         final Object domValue = ctx.getValueCodec().serialize(value);
 155         delegate.startLeafSetEntryNode(new NodeWithValue<>(ctx.getSchema().getQName(), domValue));
 156         delegate.scalarValue(domValue);
 157         delegate.endNode();
 158     }
 159
 160     @Override
 161     public void startAugmentationNode(final Class<? extends Augmentation<?>> augmentationType)
 162             throws IOException {
 163         delegate.startAugmentationNode(enter(augmentationType, AugmentationIdentifier.class));
 164     }
 165
 166     @Override
 167     public void startCase(final Class<? extends DataObject> caze, final int childSizeHint) {
 168         enter(caze, NodeIdentifier.class);
 169     }
 170
 171     @Override
 172     public void startChoiceNode(final Class<? extends DataContainer> type, final int childSizeHint)
 173             throws IOException {
 174         delegate.startChoiceNode(enter(type, NodeIdentifier.class), childSizeHint);
 175     }
 176
 177     @Override
 178     public void startContainerNode(final Class<? extends DataObject> object, final int childSizeHint)
 179             throws IOException {
 180         delegate.startContainerNode(enter(object, NodeIdentifier.class), childSizeHint);
 181     }
 182
 183     @Override
 184     public void startLeafSet(final String localName, final int childSizeHint) throws IOException {
 185         final NodeIdentifier id = enter(localName, NodeIdentifier.class);
 186         emitSchema(current().getSchema());
 187         delegate.startLeafSet(id, childSizeHint);
 188     }
 189
 190     @Override
 191     public void startOrderedLeafSet(final String localName, final int childSizeHint) throws IOException {
 192         delegate.startOrderedLeafSet(enter(localName, NodeIdentifier.class), childSizeHint);
 193     }
 194
 195     @Override
 196     public void startMapEntryNode(final Identifier<?> key, final int childSizeHint) throws IOException {
 197         duplicateSchemaEnter();
 198         NodeIdentifierWithPredicates identifier = ((KeyedListNodeCodecContext<?>) current()).serialize(key);
 199         delegate.startMapEntryNode(identifier, childSizeHint);
 200     }
 201
 202     @Override
 203     public <T extends DataObject & Identifiable<?>> void startMapNode(final Class<T> mapEntryType,
 204             final int childSizeHint) throws IOException {
 205         delegate.startMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
 206     }
 207
 208     @Override
 209     public <T extends DataObject & Identifiable<?>> void startOrderedMapNode(final Class<T> mapEntryType,
 210             final int childSizeHint) throws IOException {
 211         delegate.startOrderedMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
 212     }
 213
 214     @Override
 215     public void startUnkeyedList(final Class<? extends DataObject> obj, final int childSizeHint) throws IOException {
 216         delegate.startUnkeyedList(enter(obj, NodeIdentifier.class), childSizeHint);
 217     }
 218
 219     @Override
 220     public void startUnkeyedListItem(final int childSizeHint) throws IOException {
 221         delegate.startUnkeyedListItem(duplicateSchemaEnter(), childSizeHint);
 222     }
 223
 224     @Override
 225     public void flush() throws IOException {
 226         delegate.flush();
 227     }
 228
 229     @Override
 230     public void close() throws IOException {
 231         delegate.close();
 232     }
 233 }