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 com.google.common.base.Preconditions;
11 import com.google.common.base.Strings;
12 import java.io.IOException;
13 import java.io.StringWriter;
15 import javax.xml.XMLConstants;
16 import javax.xml.namespace.NamespaceContext;
17 import javax.xml.stream.XMLStreamException;
18 import javax.xml.stream.XMLStreamWriter;
19 import javax.xml.transform.OutputKeys;
20 import javax.xml.transform.Transformer;
21 import javax.xml.transform.TransformerException;
22 import javax.xml.transform.TransformerFactory;
23 import javax.xml.transform.TransformerFactoryConfigurationError;
24 import javax.xml.transform.dom.DOMSource;
25 import javax.xml.transform.stax.StAXResult;
26 import javax.xml.transform.stream.StreamResult;
27 import org.opendaylight.yangtools.yang.common.QName;
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.PathArgument;
32 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamAttributeWriter;
33 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
34 import org.opendaylight.yangtools.yang.data.impl.codec.SchemaTracker;
35 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
36 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
37 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
38 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
39 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
40 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
41 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
43 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
44 import org.w3c.dom.Element;
47 * A {@link NormalizedNodeStreamWriter} which translates the events into an
48 * {@link XMLStreamWriter}, resulting in a RFC 6020 XML encoding.
50 public final class XMLStreamNormalizedNodeStreamWriter implements NormalizedNodeStreamAttributeWriter {
52 private static final TransformerFactory TRANSFORMER_FACTORY = TransformerFactory.newInstance();
54 private final XMLStreamWriter writer;
55 private final SchemaTracker tracker;
56 private final XmlStreamUtils streamUtils;
57 private final RandomPrefix randomPrefix;
59 private XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
60 this.writer = Preconditions.checkNotNull(writer);
61 this.tracker = SchemaTracker.create(context, path);
62 this.streamUtils = XmlStreamUtils.create(XmlUtils.DEFAULT_XML_CODEC_PROVIDER, context);
63 randomPrefix = new RandomPrefix();
67 * Create a new writer with the specified context as its root.
69 * @param writer Output {@link XMLStreamWriter}
70 * @param context Associated {@link SchemaContext}.
71 * @return A new {@link NormalizedNodeStreamWriter}
73 public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context) {
74 return create( writer, context, SchemaPath.ROOT);
78 * Create a new writer with the specified context and rooted in the specified schema path
80 * @param writer Output {@link XMLStreamWriter}
81 * @param context Associated {@link SchemaContext}.
84 * @return A new {@link NormalizedNodeStreamWriter}
86 public static NormalizedNodeStreamWriter create(final XMLStreamWriter writer, final SchemaContext context, final SchemaPath path) {
87 return new XMLStreamNormalizedNodeStreamWriter(writer, context, path);
90 private void writeStartElement(final QName qname) throws XMLStreamException {
91 String ns = qname.getNamespace().toString();
92 writer.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, qname.getLocalName(), ns);
93 if(writer.getNamespaceContext() != null) {
94 String parentNs = writer.getNamespaceContext().getNamespaceURI(XMLConstants.DEFAULT_NS_PREFIX);
95 if (!ns.equals(parentNs)) {
96 writer.writeDefaultNamespace(ns);
101 private void writeElement(final QName qname, final TypeDefinition<?> type, final Object value) throws IOException {
103 writeStartElement(qname);
105 streamUtils.writeValue(writer, type, value, qname.getModule());
107 writer.writeEndElement();
108 } catch (XMLStreamException e) {
109 throw new IOException("Failed to emit element", e);
113 private void writeElement(final QName qname, final SchemaNode schemaNode, final Object value) throws IOException {
115 writeStartElement(qname);
117 streamUtils.writeValue(writer, schemaNode, value, qname.getModule());
119 writer.writeEndElement();
120 } catch (XMLStreamException e) {
121 throw new IOException("Failed to emit element", e);
125 private void writeElement(final QName qname, final SchemaNode schemaNode, final Object value, final Map<QName, String> attributes) throws IOException {
127 writeStartElement(qname);
129 writeAttributes(attributes);
131 streamUtils.writeValue(writer, schemaNode, value, qname.getModule());
133 writer.writeEndElement();
134 } catch (XMLStreamException e) {
135 throw new IOException("Failed to emit element", e);
139 private void startElement(final QName qname) throws IOException {
141 writeStartElement(qname);
142 } catch (XMLStreamException e) {
143 throw new IOException("Failed to start element", e);
147 private void startList(final NodeIdentifier name) {
148 tracker.startList(name);
151 private void startListItem(final PathArgument name) throws IOException {
152 tracker.startListItem(name);
153 startElement(name.getNodeType());
157 public void leafNode(final NodeIdentifier name, final Object value) throws IOException {
158 final LeafSchemaNode schema = tracker.leafNode(name);
159 writeElement(schema.getQName(), schema, value);
163 public void leafNode(final NodeIdentifier name, final Object value, final Map<QName, String> attributes) throws IOException {
164 final LeafSchemaNode schema = tracker.leafNode(name);
165 writeElement(schema.getQName(), schema, value, attributes);
169 public void leafSetEntryNode(final Object value, final Map<QName, String> attributes) throws IOException {
170 final LeafListSchemaNode schema = tracker.leafSetEntryNode();
171 writeElement(schema.getQName(), schema, value, attributes);
175 public void startContainerNode(final NodeIdentifier name, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
176 startContainerNode(name, childSizeHint);
177 writeAttributes(attributes);
181 public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
182 startYangModeledAnyXmlNode(name, childSizeHint);
183 writeAttributes(attributes);
187 public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
188 startUnkeyedListItem(name, childSizeHint);
189 writeAttributes(attributes);
193 public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint, final Map<QName, String> attributes) throws IOException {
194 startMapEntryNode(identifier, childSizeHint);
195 writeAttributes(attributes);
198 private void writeAttributes(final Map<QName, String> attributes) throws IOException {
199 for (final Map.Entry<QName, String> qNameStringEntry : attributes.entrySet()) {
201 final String namespace = qNameStringEntry.getKey().getNamespace().toString();
203 if(Strings.isNullOrEmpty(namespace)) {
204 writer.writeAttribute(qNameStringEntry.getKey().getLocalName(), qNameStringEntry.getValue());
206 final String prefix = randomPrefix.encodePrefix(qNameStringEntry.getKey().getNamespace());
207 writer.writeAttribute(prefix, namespace, qNameStringEntry.getKey().getLocalName(), qNameStringEntry.getValue());
209 } catch (final XMLStreamException e) {
210 throw new IOException("Unable to emit attribute " + qNameStringEntry, e);
216 public void startLeafSet(final NodeIdentifier name, final int childSizeHint) {
217 tracker.startLeafSet(name);
221 public void leafSetEntryNode(final Object value) throws IOException {
222 final LeafListSchemaNode schema = tracker.leafSetEntryNode();
223 writeElement(schema.getQName(), schema, value);
227 public void startContainerNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
228 final SchemaNode schema = tracker.startContainerNode(name);
229 startElement(schema.getQName());
233 public void startUnkeyedList(final NodeIdentifier name, final int childSizeHint) {
238 public void startUnkeyedListItem(final NodeIdentifier name, final int childSizeHint) throws IOException {
243 public void startMapNode(final NodeIdentifier name, final int childSizeHint) {
248 public void startMapEntryNode(final NodeIdentifierWithPredicates identifier, final int childSizeHint) throws IOException {
249 startListItem(identifier);
253 public void startOrderedMapNode(final NodeIdentifier name, final int childSizeHint) {
258 public void startChoiceNode(final NodeIdentifier name, final int childSizeHint) {
259 tracker.startChoiceNode(name);
263 public void startAugmentationNode(final AugmentationIdentifier identifier) {
264 tracker.startAugmentationNode(identifier);
268 public void anyxmlNode(final NodeIdentifier name, final Object value) throws IOException {
269 final AnyXmlSchemaNode schema = tracker.anyxmlNode(name);
271 Preconditions.checkArgument(value instanceof DOMSource, "AnyXML value must be DOMSource, not %s", value);
272 final QName qname = schema.getQName();
273 final DOMSource domSource = (DOMSource) value;
274 Preconditions.checkNotNull(domSource.getNode());
275 Preconditions.checkArgument(domSource.getNode().getNodeName().equals(qname.getLocalName()));
276 Preconditions.checkArgument(domSource.getNode().getNamespaceURI().equals(qname.getNamespace().toString()));
278 // TODO can the transformer be a constant ? is it thread safe ?
279 final Transformer transformer = TRANSFORMER_FACTORY.newTransformer();
280 // Writer has to be wrapped in a wrapper that ignores endDocument event
281 // EndDocument event forbids any other modification to the writer so a nested anyXml breaks serialization
282 transformer.transform(domSource, new StAXResult(new DelegateWriterNoEndDoc(writer)));
283 } catch (final TransformerException e) {
284 throw new IOException("Unable to transform anyXml(" + name + ") value: " + value, e);
290 public void startYangModeledAnyXmlNode(final NodeIdentifier name, final int childSizeHint) throws IOException {
291 final SchemaNode schema = tracker.startYangModeledAnyXmlNode(name);
292 startElement(schema.getQName());
295 public static String toString(final Element xml) {
297 final Transformer transformer = TransformerFactory.newInstance().newTransformer();
298 transformer.setOutputProperty(OutputKeys.INDENT, "yes");
300 final StreamResult result = new StreamResult(new StringWriter());
301 final DOMSource source = new DOMSource(xml);
302 transformer.transform(source, result);
304 return result.getWriter().toString();
305 } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
306 throw new RuntimeException("Unable to serialize xml element " + xml, e);
311 public void endNode() throws IOException {
312 final Object schema = tracker.endNode();
315 if (schema instanceof ListSchemaNode) {
316 // For lists, we only emit end element on the inner frame
317 final Object parent = tracker.getParent();
318 if (parent == schema) {
319 writer.writeEndElement();
321 } else if (schema instanceof ContainerSchemaNode) {
322 // Emit container end element
323 writer.writeEndElement();
325 } catch (XMLStreamException e) {
326 throw new IOException("Failed to end element", e);
331 public void close() throws IOException {
334 } catch (XMLStreamException e) {
335 throw new IOException("Failed to close writer", e);
340 public void flush() throws IOException {
343 } catch (XMLStreamException e) {
344 throw new IOException("Failed to flush writer", e);
349 * Delegate writer that ignores writeEndDocument event. Used for AnyXml serialization.
351 private static final class DelegateWriterNoEndDoc implements XMLStreamWriter {
352 private final XMLStreamWriter writer;
354 public DelegateWriterNoEndDoc(final XMLStreamWriter writer) {
355 this.writer = writer;
359 public void writeStartElement(final String localName) throws XMLStreamException {
360 writer.writeStartElement(localName);
364 public void writeStartElement(final String namespaceURI, final String localName) throws XMLStreamException {
365 writer.writeStartElement(namespaceURI, localName);
369 public void writeStartElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
370 writer.writeStartElement(prefix, localName, namespaceURI);
374 public void writeEmptyElement(final String namespaceURI, final String localName) throws XMLStreamException {
375 writer.writeEmptyElement(namespaceURI, localName);
379 public void writeEmptyElement(final String prefix, final String localName, final String namespaceURI) throws XMLStreamException {
380 writer.writeEmptyElement(prefix, localName, namespaceURI);
384 public void writeEmptyElement(final String localName) throws XMLStreamException {
385 writer.writeEmptyElement(localName);
389 public void writeEndElement() throws XMLStreamException {
390 writer.writeEndElement();
395 public void writeEndDocument() throws XMLStreamException {
396 // End document is disabled
400 public void close() throws XMLStreamException {
405 public void flush() throws XMLStreamException {
410 public void writeAttribute(final String localName, final String value) throws XMLStreamException {
411 writer.writeAttribute(localName, value);
415 public void writeAttribute(final String prefix, final String namespaceURI, final String localName, final String value) throws XMLStreamException {
416 writer.writeAttribute(prefix, namespaceURI, localName, value);
420 public void writeAttribute(final String namespaceURI, final String localName, final String value) throws XMLStreamException {
421 writer.writeAttribute(namespaceURI, localName, value);
425 public void writeNamespace(final String prefix, final String namespaceURI) throws XMLStreamException {
426 // Workaround for default namespace
427 // 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
428 // Write the namespace at least as an attribute
429 // TODO this is a hotfix, the transformer itself should write namespaces passing the namespace in writeStartElement method
430 if (prefix.equals("xml") || prefix.equals("xmlns")) {
431 writer.writeAttribute(prefix, namespaceURI);
433 writer.writeNamespace(prefix, namespaceURI);
438 public void writeDefaultNamespace(final String namespaceURI) throws XMLStreamException {
439 writer.writeDefaultNamespace(namespaceURI);
443 public void writeComment(final String data) throws XMLStreamException {
444 writer.writeComment(data);
448 public void writeProcessingInstruction(final String target) throws XMLStreamException {
449 writer.writeProcessingInstruction(target);
453 public void writeProcessingInstruction(final String target, final String data) throws XMLStreamException {
454 writer.writeProcessingInstruction(target, data);
458 public void writeCData(final String data) throws XMLStreamException {
459 writer.writeCData(data);
463 public void writeDTD(final String dtd) throws XMLStreamException {
464 writer.writeDTD(dtd);
468 public void writeEntityRef(final String name) throws XMLStreamException {
469 writer.writeEntityRef(name);
473 public void writeStartDocument() throws XMLStreamException {
477 public void writeStartDocument(final String version) throws XMLStreamException {
481 public void writeStartDocument(final String encoding, final String version) throws XMLStreamException {
485 public void writeCharacters(final String text) throws XMLStreamException {
486 writer.writeCharacters(text);
490 public void writeCharacters(final char[] text, final int start, final int len) throws XMLStreamException {
491 writer.writeCharacters(text, start, len);
495 public String getPrefix(final String uri) throws XMLStreamException {
496 return writer.getPrefix(uri);
500 public void setPrefix(final String prefix, final String uri) throws XMLStreamException {
501 // Disabled since it causes exceptions in the underlying writer
505 public void setDefaultNamespace(final String uri) throws XMLStreamException {
506 writer.setDefaultNamespace(uri);
510 public void setNamespaceContext(final NamespaceContext context) throws XMLStreamException {
511 writer.setNamespaceContext(context);
515 public NamespaceContext getNamespaceContext() {
516 return writer.getNamespaceContext();
520 public Object getProperty(final String name) {
521 return writer.getProperty(name);