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.eclipse.jdt.annotation.NonNull;
  21 import org.opendaylight.yangtools.concepts.Delegator;
  22 import org.opendaylight.yangtools.yang.binding.Augmentation;
  23 import org.opendaylight.yangtools.yang.binding.DataContainer;
  24 import org.opendaylight.yangtools.yang.binding.DataObject;
  25 import org.opendaylight.yangtools.yang.binding.Identifiable;
  26 import org.opendaylight.yangtools.yang.binding.Identifier;
  27 import org.opendaylight.yangtools.yang.binding.OpaqueObject;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  31 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  32 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  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 @NonNull 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 Entry<NodeIdentifier, Object> dom = serializeLeaf(name, value);
 134         if (delegate.startAnydataNode(dom.getKey(), value.getValue().getObjectModel())) {
 135             delegate.scalarValue(dom.getValue());
 136             delegate.endNode();
 137         }
 138     }
 139
 140     @Override
 141     public void anyxmlNode(final String name, final Object value) throws IOException {
 142         final Entry<NodeIdentifier, Object> dom = serializeLeaf(name, value);
 143         // FIXME: this is not quite right -- we should be handling other object models, too
 144         if (delegate.startAnyxmlNode(dom.getKey(), DOMSource.class)) {
 145             delegate.domSourceValue((DOMSource) dom.getValue());
 146             delegate.endNode();
 147         }
 148     }
 149
 150     @Override
 151     public void leafSetEntryNode(final Object value) throws IOException {
 152         final LeafSetNodeCodecContext ctx = (LeafSetNodeCodecContext) current();
 153         final Object domValue = ctx.getValueCodec().serialize(value);
 154         delegate.startLeafSetEntryNode(new NodeWithValue<>(ctx.getSchema().getQName(), domValue));
 155         delegate.scalarValue(domValue);
 156         delegate.endNode();
 157     }
 158
 159     @Override
 160     public void startAugmentationNode(final Class<? extends Augmentation<?>> augmentationType)
 161             throws IOException {
 162         delegate.startAugmentationNode(enter(augmentationType, AugmentationIdentifier.class));
 163     }
 164
 165     @Override
 166     public void startCase(final Class<? extends DataObject> caze, final int childSizeHint) {
 167         enter(caze, NodeIdentifier.class);
 168     }
 169
 170     @Override
 171     public void startChoiceNode(final Class<? extends DataContainer> type, final int childSizeHint)
 172             throws IOException {
 173         delegate.startChoiceNode(enter(type, NodeIdentifier.class), childSizeHint);
 174     }
 175
 176     @Override
 177     public void startContainerNode(final Class<? extends DataObject> object, final int childSizeHint)
 178             throws IOException {
 179         delegate.startContainerNode(enter(object, NodeIdentifier.class), childSizeHint);
 180     }
 181
 182     @Override
 183     public void startLeafSet(final String localName, final int childSizeHint) throws IOException {
 184         final NodeIdentifier id = enter(localName, NodeIdentifier.class);
 185         emitSchema(current().getSchema());
 186         delegate.startLeafSet(id, childSizeHint);
 187     }
 188
 189     @Override
 190     public void startOrderedLeafSet(final String localName, final int childSizeHint) throws IOException {
 191         delegate.startOrderedLeafSet(enter(localName, NodeIdentifier.class), childSizeHint);
 192     }
 193
 194     @Override
 195     public void startMapEntryNode(final Identifier<?> key, final int childSizeHint) throws IOException {
 196         duplicateSchemaEnter();
 197         NodeIdentifierWithPredicates identifier = ((KeyedListNodeCodecContext<?, ?>) current()).serialize(key);
 198         delegate.startMapEntryNode(identifier, childSizeHint);
 199     }
 200
 201     @Override
 202     public <T extends DataObject & Identifiable<?>> void startMapNode(final Class<T> mapEntryType,
 203             final int childSizeHint) throws IOException {
 204         delegate.startMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
 205     }
 206
 207     @Override
 208     public <T extends DataObject & Identifiable<?>> void startOrderedMapNode(final Class<T> mapEntryType,
 209             final int childSizeHint) throws IOException {
 210         delegate.startOrderedMapNode(enter(mapEntryType, NodeIdentifier.class), childSizeHint);
 211     }
 212
 213     @Override
 214     public void startUnkeyedList(final Class<? extends DataObject> obj, final int childSizeHint) throws IOException {
 215         delegate.startUnkeyedList(enter(obj, NodeIdentifier.class), childSizeHint);
 216     }
 217
 218     @Override
 219     public void startUnkeyedListItem(final int childSizeHint) throws IOException {
 220         delegate.startUnkeyedListItem(duplicateSchemaEnter(), childSizeHint);
 221     }
 222
 223     @Override
 224     public void flush() throws IOException {
 225         delegate.flush();
 226     }
 227
 228     @Override
 229     public void close() throws IOException {
 230         delegate.close();
 231     }
 232 }