2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.yangtools.yang.data.impl.codec.xml;
10 import static javax.xml.XMLConstants.DEFAULT_NS_PREFIX;
12 import com.google.common.base.Preconditions;
13 import java.io.IOException;
14 import java.io.StringWriter;
15 import javax.xml.namespace.NamespaceContext;
16 import javax.xml.stream.XMLStreamException;
17 import javax.xml.stream.XMLStreamWriter;
18 import javax.xml.transform.OutputKeys;
19 import javax.xml.transform.Transformer;
20 import javax.xml.transform.TransformerException;
21 import javax.xml.transform.TransformerFactory;
22 import javax.xml.transform.TransformerFactoryConfigurationError;
23 import javax.xml.transform.dom.DOMSource;
24 import javax.xml.transform.stax.StAXResult;
25 import javax.xml.transform.stream.StreamResult;
26 import org.opendaylight.yangtools.yang.common.QName;
27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
31 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
32 import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
33 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
34 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
35 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
39 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
40 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
41 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
42 import org.w3c.dom.Element;
45 * A {@link NormalizedNodeStreamWriter} which translates the events into an
46 * {@link XMLStreamWriter}, resulting in a RFC 6020 XML encoding.
48 public final class XMLStreamNormalizedNodeStreamWriter implements NormalizedNodeStreamWriter {
50 private static final TransformerFactory TRANSFORMER_FACTORY = TransformerFactory.newInstance();
52 private final XMLStreamWriter writer;
53 private final SchemaTracker tracker;
54 private final XmlStreamUtils streamUtils;
56 private XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
57 this.writer = Preconditions.checkNotNull(writer);
58 this.tracker = SchemaTracker.create(context, path);
59 this.streamUtils = XmlStreamUtils.create(XmlUtils.DEFAULT_XML_CODEC_PROVIDER, context);
63 * Create a new writer with the specified context as its root.
65 * @param writer Output {@link XMLStreamWriter}
66 * @param context Associated {@link SchemaContext}.
67 * @return A new {@link NormalizedNodeStreamWriter}
69 public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context) {
70 return create( writer, context, SchemaPath.ROOT);
74 * Create a new writer with the specified context and rooted in the specified schema path
76 * @param writer Output {@link XMLStreamWriter}
77 * @param context Associated {@link SchemaContext}.
79 * @return A new {@link NormalizedNodeStreamWriter}
81 public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
82 return new XMLStreamNormalizedNodeStreamWriter(writer, context, path);
85 private void writeStartElement( QName qname) throws XMLStreamException {
86 String ns = qname.getNamespace().toString();
87 writer.writeStartElement(DEFAULT_NS_PREFIX, qname.getLocalName(), ns);
88 if(writer.getNamespaceContext() != null) {
89 String parentNs = writer.getNamespaceContext().getNamespaceURI(DEFAULT_NS_PREFIX);
90 if (!ns.equals(parentNs)) {
91 writer.writeDefaultNamespace(ns);
96 private void writeElement(final QName qname, final TypeDefinition<?> type, final Object value) throws IOException {
98 writeStartElement(qname);
100 streamUtils.writeValue(writer, type, value);
102 writer.writeEndElement();
103 } catch (XMLStreamException e) {
104 throw new IOException("Failed to emit element", e);
108 private void writeElement(final QName qname, final SchemaNode schemaNode, final Object value) throws IOException {
110 writeStartElement(qname);
112 streamUtils.writeValue(writer, schemaNode, value);
114 writer.writeEndElement();
115 } catch (XMLStreamException e) {
116 throw new IOException("Failed to emit element", e);
120 private void startElement(final QName qname) throws IOException {
122 writeStartElement(qname);
123 } catch (XMLStreamException e) {
124 throw new IOException("Failed to start element", e);
128 private void startList(final NodeIdentifier name) {
129 tracker.startList(name);
132 private void startListItem(final PathArgument name) throws IOException {
133 tracker.startListItem(name);
134 startElement(name.getNodeType());
138 public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
139 final LeafSchemaNode schema = tracker.leafNode(name);
140 writeElement(schema.getQName(), schema, value);
144 public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
145 tracker.startLeafSet(name);
149 public void leafSetEntryNode(final Object value) throws IOException {
150 final LeafListSchemaNode schema = tracker.leafSetEntryNode();
151 writeElement(schema.getQName(), schema, value);
155 public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
156 final SchemaNode schema = tracker.startContainerNode(name);
157 startElement(schema.getQName());
161 public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
166 public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
171 public void startMapNode(final NodeIdentifier name, final int childSizeHint) {
176 public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException {
177 startListItem(identifier);
181 public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
186 public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) {
187 tracker.startChoiceNode(name);
191 public void startAugmentationNode(final AugmentationIdentifier identifier) {
192 tracker.startAugmentationNode(identifier);
196 public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
197 final AnyXmlSchemaNode schema = tracker.anyxmlNode(name);
199 Preconditions.checkArgument(value instanceof DOMSource, "AnyXML value must be DOMSource, not %s", value);
200 final QName qname = schema.getQName();
201 final DOMSource domSource = (DOMSource) value;
202 Preconditions.checkNotNull(domSource.getNode());
203 Preconditions.checkArgument(domSource.getNode().getNodeName().equals(qname.getLocalName()));
204 Preconditions.checkArgument(domSource.getNode().getNamespaceURI().equals(qname.getNamespace().toString()));
206 // TODO can the transformer be a constant ? is it thread safe ?
207 final Transformer transformer = TRANSFORMER_FACTORY.newTransformer();
208 // Writer has to be wrapped in a wrapper that ignores endDocument event
209 // EndDocument event forbids any other modification to the writer so a nested anyXml breaks serialization
210 transformer.transform(domSource, new StAXResult(new DelegateWriterNoEndDoc(writer)));
211 } catch (final TransformerException e) {
212 throw new IOException("Unable to transform anyXml(" + name + ") value: " + value, e);
217 public static String toString(final Element xml) {
219 final Transformer transformer = TransformerFactory.newInstance().newTransformer();
220 transformer.setOutputProperty(OutputKeys.INDENT, "yes");
222 final StreamResult result = new StreamResult(new StringWriter());
223 final DOMSource source = new DOMSource(xml);
224 transformer.transform(source, result);
226 return result.getWriter().toString();
227 } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
228 throw new RuntimeException("Unable to serialize xml element " + xml, e);
233 public void endNode() throws IOException {
234 final Object schema = tracker.endNode();
237 if (schema instanceof ListSchemaNode) {
238 // For lists, we only emit end element on the inner frame
239 final Object parent = tracker.getParent();
240 if (parent == schema) {
241 writer.writeEndElement();
243 } else if (schema instanceof ContainerSchemaNode) {
244 // Emit container end element
245 writer.writeEndElement();
247 } catch (XMLStreamException e) {
248 throw new IOException("Failed to end element", e);
253 public void close() throws IOException {
256 } catch (XMLStreamException e) {
257 throw new IOException("Failed to close writer", e);
262 public void flush() throws IOException {
265 } catch (XMLStreamException e) {
266 throw new IOException("Failed to flush writer", e);
271 * Delegate writer that ignores writeEndDocument event. Used for AnyXml serialization.
273 private static final class DelegateWriterNoEndDoc implements XMLStreamWriter {
274 private final XMLStreamWriter writer;
276 public DelegateWriterNoEndDoc(final XMLStreamWriter writer) {
277 this.writer = writer;
281 public void writeStartElement(final String localName) throws XMLStreamException {
282 writer.writeStartElement(localName);
286 public void writeStartElement(final String namespaceURI, final String localName) throws XMLStreamException {
287 writer.writeStartElement(namespaceURI, localName);
291 public void writeStartElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
292 writer.writeStartElement(prefix, localName, namespaceURI);
296 public void writeEmptyElement(final String namespaceURI, final String localName) throws XMLStreamException {
297 writer.writeEmptyElement(namespaceURI, localName);
301 public void writeEmptyElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
302 writer.writeEmptyElement(prefix, localName, namespaceURI);
306 public void writeEmptyElement(final String localName) throws XMLStreamException {
307 writer.writeEmptyElement(localName);
311 public void writeEndElement() throws XMLStreamException {
312 writer.writeEndElement();
317 public void writeEndDocument() throws XMLStreamException {
318 // End document is disabled
322 public void close() throws XMLStreamException {
327 public void flush() throws XMLStreamException {
332 public void writeAttribute(final String localName, final String value) throws XMLStreamException {
333 writer.writeAttribute(localName, value);
337 public void writeAttribute(final String prefix, final String namespaceURI, final String localName, final String value) throws XMLStreamException {
338 writer.writeAttribute(prefix, namespaceURI, localName, value);
342 public void writeAttribute(final String namespaceURI, final String localName, final String value) throws XMLStreamException {
343 writer.writeAttribute(namespaceURI, localName, value);
347 public void writeNamespace(final String prefix, final String namespaceURI) throws XMLStreamException {
348 // Workaround for default namespace
349 // If a namespace is not prefixed, it is is still treated as prefix namespace. This results in the NamespaceSupport class ignoring the namespace since xmlns is not a valid prefix
350 // Write the namespace at least as an attribute
351 // TODO this is a hotfix, the transformer itself should write namespaces passing the namespace in writeStartElement method
352 if (prefix.equals("xml") || prefix.equals("xmlns")) {
353 writer.writeAttribute(prefix, namespaceURI);
355 writer.writeNamespace(prefix, namespaceURI);
360 public void writeDefaultNamespace(final String namespaceURI) throws XMLStreamException {
361 writer.writeDefaultNamespace(namespaceURI);
365 public void writeComment(final String data) throws XMLStreamException {
366 writer.writeComment(data);
370 public void writeProcessingInstruction(final String target) throws XMLStreamException {
371 writer.writeProcessingInstruction(target);
375 public void writeProcessingInstruction(final String target, final String data) throws XMLStreamException {
376 writer.writeProcessingInstruction(target, data);
380 public void writeCData(final String data) throws XMLStreamException {
381 writer.writeCData(data);
385 public void writeDTD(final String dtd) throws XMLStreamException {
386 writer.writeDTD(dtd);
390 public void writeEntityRef(final String name) throws XMLStreamException {
391 writer.writeEntityRef(name);
395 public void writeStartDocument() throws XMLStreamException {
399 public void writeStartDocument(final String version) throws XMLStreamException {
403 public void writeStartDocument(final String encoding, final String version) throws XMLStreamException {
407 public void writeCharacters(final String text) throws XMLStreamException {
408 writer.writeCharacters(text);
412 public void writeCharacters(final char[] text, final int start, final int len) throws XMLStreamException {
413 writer.writeCharacters(text, start, len);
417 public String getPrefix(final String uri) throws XMLStreamException {
418 return writer.getPrefix(uri);
422 public void setPrefix(final String prefix, final String uri) throws XMLStreamException {
423 // Disabled since it causes exceptions in the underlying writer
427 public void setDefaultNamespace(final String uri) throws XMLStreamException {
428 writer.setDefaultNamespace(uri);
432 public void setNamespaceContext(final NamespaceContext context) throws XMLStreamException {
433 writer.setNamespaceContext(context);
437 public NamespaceContext getNamespaceContext() {
438 return writer.getNamespaceContext();
442 public Object getProperty(final String name) throws IllegalArgumentException {
443 return writer.getProperty(name);