yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/xml/XMLStreamNormalizedNodeStreamWriter.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.yangtools.yang.data.impl.codec.xml;
   9
  10 import com.google.common.base.Preconditions;
  11
  12 import java.io.IOException;
  13
  14 import javax.xml.stream.XMLOutputFactory;
  15 import javax.xml.stream.XMLStreamException;
  16 import javax.xml.stream.XMLStreamWriter;
  17
  18 import org.opendaylight.yangtools.yang.common.QName;
  19 import org.opendaylight.yangtools.yang.data.api.Node;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  21 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  22 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  24 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  25 import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
  26 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
  27 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  28 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  29 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  30 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  31 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  32 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  33 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  34 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  35
  36 /**
  37  * A {@link NormalizedNodeStreamWriter} which translates the events into an
  38  * {@link XMLStreamWriter}, resulting in a RFC 6020 XML encoding.
  39  */
  40 public final class XMLStreamNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
  41     private static final XmlStreamUtils UTILS = XmlStreamUtils.create(XmlUtils.DEFAULT_XML_CODEC_PROVIDER);
  42
  43     private final XMLStreamWriter writer;
  44     private final SchemaTracker tracker;
  45
  46     private XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
  47         this.writer = Preconditions.checkNotNull(writer);
  48         this.tracker = SchemaTracker.create(context, path);
  49     }
  50
  51     /**
  52      * Create a new writer with the specified context as its root.
  53      *
  54      * @param writer Output {@link XMLStreamWriter}
  55      * @param context Associated {@link SchemaContext}.
  56      * @return A new {@link NormalizedNodeStreamWriter}
  57      */
  58     public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context) {
  59         return create( writer, context, SchemaPath.ROOT);
  60     }
  61
  62     /**
  63      * Create a new writer with the specified context and rooted in the specified schema path
  64      *
  65      * @param writer Output {@link XMLStreamWriter}
  66      * @param context Associated {@link SchemaContext}.
  67      *
  68      * @return A new {@link NormalizedNodeStreamWriter}
  69      */
  70     public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
  71         final Boolean repairing = (Boolean) writer.getProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES);
  72         Preconditions.checkArgument(repairing == true, "XML Stream Writer has to be repairing namespaces");
  73         return new XMLStreamNormalizedNodeStreamWriter(writer, context, path);
  74     }
  75
  76     private void writeElement(final QName qname, final TypeDefinition<?> type, final Object value) throws IOException {
  77         final String ns = qname.getNamespace().toString();
  78
  79         try {
  80             if (value != null) {
  81                 writer.writeStartElement(ns, qname.getLocalName());
  82                 UTILS.writeValue(writer, type, value);
  83                 writer.writeEndElement();
  84             } else {
  85                 writer.writeEmptyElement(ns, qname.getLocalName());
  86             }
  87         } catch (XMLStreamException e) {
  88             throw new IOException("Failed to emit element", e);
  89         }
  90     }
  91
  92     private void startElement(final QName qname) throws IOException {
  93         try {
  94             writer.writeStartElement(qname.getNamespace().toString(), qname.getLocalName());
  95         } catch (XMLStreamException e) {
  96             throw new IOException("Failed to start element", e);
  97         }
  98     }
  99
 100     private void startList(final NodeIdentifier name) {
 101         tracker.startList(name);
 102     }
 103
 104     private void startListItem(final PathArgument name) throws IOException {
 105         tracker.startListItem(name);
 106         startElement(name.getNodeType());
 107     }
 108
 109     @Override
 110     public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
 111         final LeafSchemaNode schema = tracker.leafNode(name);
 112
 113         writeElement(schema.getQName(), schema.getType(), value);
 114     }
 115
 116     @Override
 117     public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
 118         tracker.startLeafSet(name);
 119     }
 120
 121     @Override
 122     public void leafSetEntryNode(final Object value) throws IOException {
 123         final LeafListSchemaNode schema = tracker.leafSetEntryNode();
 124         writeElement(schema.getQName(), schema.getType(), value);
 125     }
 126
 127     @Override
 128     public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
 129         final SchemaNode schema = tracker.startContainerNode(name);
 130         startElement(schema.getQName());
 131     }
 132
 133     @Override
 134     public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
 135         startList(name);
 136     }
 137
 138     @Override
 139     public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
 140         startListItem(name);
 141     }
 142
 143     @Override
 144     public void startMapNode(final NodeIdentifier name, final int childSizeHint) {
 145         startList(name);
 146     }
 147
 148     @Override
 149     public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException {
 150         startListItem(identifier);
 151     }
 152
 153     @Override
 154     public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
 155         startList(name);
 156     }
 157
 158     @Override
 159     public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) {
 160         tracker.startChoiceNode(name);
 161     }
 162
 163     @Override
 164     public void startAugmentationNode(final AugmentationIdentifier identifier) {
 165         tracker.startAugmentationNode(identifier);
 166     }
 167
 168     @Override
 169     public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
 170         final AnyXmlSchemaNode schema = tracker.anyxmlNode(name);
 171         final QName qname = schema.getQName();
 172         final String ns = qname.getNamespace().toString();
 173
 174         try {
 175             if (value != null) {
 176                 writer.writeStartElement(ns, qname.getLocalName());
 177                 UTILS.writeValue(writer, (Node<?>)value, schema);
 178                 writer.writeEndElement();
 179             } else {
 180                 writer.writeEmptyElement(ns, qname.getLocalName());
 181             }
 182         } catch (XMLStreamException e) {
 183             throw new IOException("Failed to emit element", e);
 184         }
 185     }
 186
 187     @Override
 188     public void endNode() throws IOException {
 189         final Object schema = tracker.endNode();
 190
 191         try {
 192             if (schema instanceof ListSchemaNode) {
 193                 // For lists, we only emit end element on the inner frame
 194                 final Object parent = tracker.getParent();
 195                 if (parent == schema) {
 196                     writer.writeEndElement();
 197                 }
 198             } else if (schema instanceof ContainerSchemaNode) {
 199                 // Emit container end element
 200                 writer.writeEndElement();
 201             }
 202         } catch (XMLStreamException e) {
 203             throw new IOException("Failed to end element", e);
 204         }
 205     }
 206
 207     @Override
 208     public void close() throws IOException {
 209         try {
 210             writer.close();
 211         } catch (XMLStreamException e) {
 212             throw new IOException("Failed to close writer", e);
 213         }
 214     }
 215
 216     @Override
 217     public void flush() throws IOException {
 218         try {
 219             writer.flush();
 220         } catch (XMLStreamException e) {
 221             throw new IOException("Failed to flush writer", e);
 222         }
 223     }
 224 }