microsoft.exchange.webservices.data.EwsServiceXmlWriter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of exchange-ws-api Show documentation
Show all versions of exchange-ws-api Show documentation
The source came from http://archive.msdn.microsoft.com/ewsjavaapi
Support for Maven has been added.
The newest version!
/**************************************************************************
* copyright file="EwsServiceXmlWriter.java" company="Microsoft"
* Copyright (c) Microsoft Corporation. All rights reserved.
*
* Defines the EwsServiceXmlWriter.java.
**************************************************************************/
package microsoft.exchange.webservices.data;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.w3c.dom.CDATASection;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.EntityReference;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;
/**
* * Stax based XML Writer implementation.
*/
class EwsServiceXmlWriter implements IDisposable {
/** The is disposed. */
private boolean isDisposed;
/** The service. */
private ExchangeServiceBase service;
/** The xml writer. */
private XMLStreamWriter xmlWriter;
/** The is time zone header emitted. */
private boolean isTimeZoneHeaderEmitted;
/** The Buffer size. */
private static final int BufferSize = 4096;
/**
* * Initializes a new instance.
*
* @param service
* The service.
* @param stream
* The stream.
* @throws XMLStreamException
* the xML stream exception
*/
protected EwsServiceXmlWriter(ExchangeServiceBase service,
OutputStream stream) throws XMLStreamException {
this.service = service;
XMLOutputFactory xmlof = XMLOutputFactory.newInstance();
xmlWriter = xmlof.createXMLStreamWriter(stream, "utf-8");
}
/**
* * Try to convert object to a string.
*
* @param value
* The value.
* @param str
* the str
* @return True if object was converted, false otherwise. A null object will
* be "successfully" converted to a null string.
*/
protected boolean tryConvertObjectToString(Object value,
OutParam str) {
boolean converted = true;
str.setParam(null);
if (value != null) {
if (value.getClass().isEnum()) {
str.setParam(EwsUtilities.serializeEnum(value));
} else if (value.getClass().equals(Boolean.class)) {
str.setParam(EwsUtilities.boolToXSBool((Boolean)value));
} else if (value instanceof Date) {
str
.setParam(this.service
.convertDateTimeToUniversalDateTimeString(
(Date)value));
} else if (value.getClass().isPrimitive()) {
str.setParam(value.toString());
} else if (value instanceof String) {
str.setParam(value.toString());
} else if (value instanceof ISearchStringProvider) {
ISearchStringProvider searchStringProvider =
(ISearchStringProvider)value;
str.setParam(searchStringProvider.getSearchString());
} else if (value instanceof Integer) {
str.setParam(value.toString());
} else {
converted = false;
}
}
return converted;
}
/***
* Performs application-defined tasks associated with freeing, releasing, or
* resetting unmanaged resources.
*/
@Override
public void dispose() {
if (!this.isDisposed) {
try {
this.xmlWriter.close();
} catch (XMLStreamException e) {
e.printStackTrace();
}
this.isDisposed = true;
}
}
/**
* * Flushes this instance.
*
* @throws XMLStreamException
* the xML stream exception
*/
public void flush() throws XMLStreamException {
this.xmlWriter.flush();
}
/**
* * Writes the start element.
*
* @param xmlNamespace
* The XML namespace.
* @param localName
* The local name of the element.
* @throws XMLStreamException
* the xML stream exception
*/
public void writeStartElement(XmlNamespace xmlNamespace, String localName)
throws XMLStreamException {
String strPrefix = EwsUtilities.getNamespacePrefix(xmlNamespace);
String strNameSpace = EwsUtilities.getNamespaceUri(xmlNamespace);
this.xmlWriter.writeStartElement(strPrefix, localName, strNameSpace);
}
/**
* * Writes the end element.
*
* @throws XMLStreamException
* the xML stream exception
*/
public void writeEndElement() throws XMLStreamException {
this.xmlWriter.writeEndElement();
}
/**
* * Writes the attribute value.
*
* @param localName
* The local name of the attribute.
* @param value
* The value.
* @throws ServiceXmlSerializationException
* the service xml serialization exception
*/
public void writeAttributeValue(String localName, Object value)
throws ServiceXmlSerializationException {
this.writeAttributeValue(localName,
false /* alwaysWriteEmptyString */, value);
}
/**
* Writes the attribute value. Optionally emits empty string values.
* @param localName The local name of the attribute.
* @param alwaysWriteEmptyString Always emit the empty string as the value.
* @param value The value.
* @throws ServiceXmlSerializationException
*/
public void writeAttributeValue(String localName,
boolean alwaysWriteEmptyString,
Object value) throws ServiceXmlSerializationException {
OutParam stringOut = new OutParam();
String stringValue = null;
if (this.tryConvertObjectToString(value, stringOut)) {
stringValue = stringOut.getParam();
if ((null != stringValue) && (alwaysWriteEmptyString || (stringValue.length() != 0))) {
this.writeAttributeString(localName, stringValue);
}
} else {
throw new ServiceXmlSerializationException(String.format(
Strings.AttributeValueCannotBeSerialized, value.getClass()
.getName(), localName));
}
}
/**
* * Writes the attribute value.
*
* @param namespacePrefix
* The namespace prefix.
* @param localName
* The local name of the attribute.
* @param value
* The value.
* @throws ServiceXmlSerializationException
* the service xml serialization exception
*/
public void writeAttributeValue(String namespacePrefix, String localName,
Object value) throws ServiceXmlSerializationException {
OutParam stringOut = new OutParam();
String stringValue = null;
if (this.tryConvertObjectToString(value, stringOut)) {
stringValue = stringOut.getParam();
if (null != stringValue && !stringValue.isEmpty()) {
this.writeAttributeString(namespacePrefix, localName,
stringValue);
}
} else {
throw new ServiceXmlSerializationException(String.format(
Strings.AttributeValueCannotBeSerialized, value.getClass()
.getName(), localName));
}
}
/***
* Writes the attribute value.
*
* @param localName
* The local name of the attribute.
* @param stringValue
* The string value.
* @throws ServiceXmlSerializationException
* Thrown if string value isn't valid for XML.
*/
protected void writeAttributeString(String localName, String stringValue)
throws ServiceXmlSerializationException {
try {
this.xmlWriter.writeAttribute(localName, stringValue);
} catch (XMLStreamException e) {
// Bug E14:65046: XmlTextWriter will throw ArgumentException
//if string includes invalid characters.
throw new ServiceXmlSerializationException(String.format(
Strings.InvalidAttributeValue, stringValue, localName), e);
}
}
/***
* Writes the attribute value.
*
* @param namespacePrefix
* The namespace prefix.
* @param localName
* The local name of the attribute.
* @param stringValue
* The string value.
* @throws ServiceXmlSerializationException
* Thrown if string value isn't valid for XML.
*/
protected void writeAttributeString(String namespacePrefix,
String localName, String stringValue)
throws ServiceXmlSerializationException {
try {
this.xmlWriter.writeAttribute(namespacePrefix, "", localName,
stringValue);
} catch (XMLStreamException e) {
// Bug E14:65046: XmlTextWriter will throw ArgumentException
//if string includes invalid characters.
throw new ServiceXmlSerializationException(String.format(
Strings.InvalidAttributeValue, stringValue, localName), e);
}
}
/***
* Writes string value.
*
* @param value
* The value.
* @param name
* Element name (used for error handling)
* @throws ServiceXmlSerializationException
* Thrown if string value isn't valid for XML.
*/
public void writeValue(String value, String name)
throws ServiceXmlSerializationException {
try {
this.xmlWriter.writeCharacters(value);
} catch (XMLStreamException e) {
// Bug E14:65046: XmlTextWriter will throw ArgumentException
//if string includes invalid characters.
throw new ServiceXmlSerializationException(String.format(
Strings.InvalidElementStringValue, value, name), e);
}
}
/**
* * Writes the element value.
*
* @param xmlNamespace
* The XML namespace.
* @param localName
* The local name of the element.
* @param displayName
* The name that should appear in the exception message when the
* value can not be serialized.
* @param value
* The value.
* @throws XMLStreamException
* the xML stream exception
* @throws ServiceXmlSerializationException
* the service xml serialization exception
*/
protected void writeElementValue(XmlNamespace xmlNamespace,
String localName, String displayName, Object value)
throws XMLStreamException, ServiceXmlSerializationException {
String stringValue = null;
OutParam strOut = new OutParam();
if (this.tryConvertObjectToString(value, strOut)) {
stringValue = strOut.getParam();
if (null != stringValue) {
// allow an empty string to create an empty element (like ).
this.writeStartElement(xmlNamespace, localName);
this.writeValue(stringValue, displayName);
this.writeEndElement();
}
} else {
throw new ServiceXmlSerializationException(String.format(
Strings.ElementValueCannotBeSerialized, value.getClass()
.getName(), localName));
}
}
public void writeNode(Node xmlNode) throws XMLStreamException {
if (xmlNode != null) {
writeNode(xmlNode,this.xmlWriter);
//this.xmlWriter.writeCharacters(xmlNode.);
//this.xmlWriter.writeDTD(xmlNode);
//xmlNode.WriteTo(this.xmlWriter);
}
}
/**
*
* @param xmlNode
* @param xmlStreamWriter
* @throws XMLStreamException
*/
public static void writeNode(Node xmlNode, XMLStreamWriter xmlStreamWriter)
throws XMLStreamException {
if (xmlNode instanceof Element) {
addElement((Element) xmlNode, xmlStreamWriter);
} else if (xmlNode instanceof Text) {
xmlStreamWriter.writeCharacters(((Text) xmlNode).getNodeValue());
} else if (xmlNode instanceof CDATASection) {
xmlStreamWriter.writeCData(((CDATASection) xmlNode).getData());
} else if (xmlNode instanceof Comment) {
xmlStreamWriter.writeComment(((Comment) xmlNode).getData());
} else if (xmlNode instanceof EntityReference) {
xmlStreamWriter.writeEntityRef(((EntityReference) xmlNode)
.getNodeValue());
} else if (xmlNode instanceof ProcessingInstruction) {
ProcessingInstruction procInst = (ProcessingInstruction) xmlNode;
xmlStreamWriter.writeProcessingInstruction(procInst.getTarget(),
procInst.getData());
} else if (xmlNode instanceof Document) {
writeToDocument((Document) xmlNode, xmlStreamWriter);
}
}
/**
*
* @param document
* @param xmlStreamWriter
* @throws XMLStreamException
*/
public static void writeToDocument(Document document,
XMLStreamWriter xmlStreamWriter) throws XMLStreamException {
xmlStreamWriter.writeStartDocument();
Element rootElement = document.getDocumentElement();
addElement(rootElement, xmlStreamWriter);
xmlStreamWriter.writeEndDocument();
}
/**
*
* @param element
* @param writer
* @throws XMLStreamException
*/
public static void addElement(Element element, XMLStreamWriter writer)
throws XMLStreamException {
String nameSpace = element.getNamespaceURI();
String prefix = element.getPrefix();
String localName = element.getLocalName();
if (prefix == null) {
prefix = "";
}
if (localName == null) {
localName = element.getNodeName();
if (localName == null) {
throw new IllegalStateException(
"Element's local name cannot be null!");
}
}
String decUri = writer.getNamespaceContext().getNamespaceURI(prefix);
boolean declareNamespace = decUri == null || !decUri.equals(nameSpace);
if (nameSpace == null || nameSpace.length() == 0) {
writer.writeStartElement(localName);
} else {
writer.writeStartElement(prefix, localName, nameSpace);
}
NamedNodeMap attrs = element.getAttributes();
for (int i = 0; i < attrs.getLength(); i++) {
Node attr = attrs.item(i);
String name = attr.getNodeName();
String attrPrefix = "";
int prefixIndex = name.indexOf(':');
if (prefixIndex != -1) {
attrPrefix = name.substring(0, prefixIndex);
name = name.substring(prefixIndex + 1);
}
if ("xmlns".equals(attrPrefix)) {
writer.writeNamespace(name, attr.getNodeValue());
if (name.equals(prefix)
&& attr.getNodeValue().equals(nameSpace)) {
declareNamespace = false;
}
} else {
if ("xmlns".equals(name) && "".equals(attrPrefix)) {
writer.writeNamespace("", attr.getNodeValue());
if (attr.getNodeValue().equals(nameSpace)) {
declareNamespace = false;
}
} else {
writer.writeAttribute(attrPrefix, attr.getNamespaceURI(),
name, attr.getNodeValue());
}
}
}
if (declareNamespace) {
if (nameSpace == null) {
writer.writeNamespace(prefix, "");
} else {
writer.writeNamespace(prefix, nameSpace);
}
}
NodeList nodes = element.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
Node n = nodes.item(i);
writeNode(n, writer);
}
writer.writeEndElement();
}
/**
* * Writes the element value.
*
* @param xmlNamespace
* The XML namespace.
* @param localName
* The local name of the element.
* @param value
* The value.
* @throws XMLStreamException
* the xML stream exception
* @throws ServiceXmlSerializationException
* the service xml serialization exception
*/
public void writeElementValue(XmlNamespace xmlNamespace, String localName,
Object value) throws XMLStreamException,
ServiceXmlSerializationException {
this.writeElementValue(xmlNamespace, localName, localName, value);
}
/**
* * Writes the base64-encoded element value.
*
* @param buffer
* The buffer.
* @throws XMLStreamException
* the xML stream exception
*/
public void writeBase64ElementValue(byte[] buffer)
throws XMLStreamException {
String strValue = Base64.encode(buffer);
this.xmlWriter.writeCharacters(strValue);//Base64.encode(buffer));
}
/**
* * Writes the base64-encoded element value.
*
* @param stream
* The stream.
* @throws IOException
* Signals that an I/O exception has occurred.
* @throws XMLStreamException
* the xML stream exception
*/
public void writeBase64ElementValue(InputStream stream) throws IOException,
XMLStreamException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buf = new byte[BufferSize];
try {
for (int readNum; (readNum = stream.read(buf)) != -1;) {
bos.write(buf, 0, readNum);
}
} catch (IOException ex) {
ex.printStackTrace();
} finally {
bos.close();
}
byte[] bytes = bos.toByteArray();
String strValue = Base64.encode(bytes);
this.xmlWriter.writeCharacters(strValue);
}
/***
* Gets the internal XML writer.
*
* @return the internal writer
*/
public XMLStreamWriter getInternalWriter() {
return xmlWriter;
}
/***
* Gets the service.
*
* @return The service.
*/
public ExchangeServiceBase getService() {
return service;
}
/***
* Gets a value indicating whether the time zone SOAP header was emitted
* through this writer.
*
* @return true if the time zone SOAP header was emitted; otherwise false.
*/
public boolean isTimeZoneHeaderEmitted() {
return isTimeZoneHeaderEmitted;
}
/***
* Sets a value indicating whether the time zone SOAP header was emitted
* through this writer.
*
* @param isTimeZoneHeaderEmitted
* true if the time zone SOAP header was emitted; otherwise
* false.
*/
public void setTimeZoneHeaderEmitted(boolean isTimeZoneHeaderEmitted) {
this.isTimeZoneHeaderEmitted = isTimeZoneHeaderEmitted;
}
/**
* Write start document.
*
* @throws XMLStreamException
* the xML stream exception
*/
protected void writeStartDocument() throws XMLStreamException {
this.xmlWriter.writeStartDocument("utf-8", "1.0");
}
}