com.fasterxml.jackson.dataformat.xml.ser.ToXmlGenerator Maven / Gradle / Ivy
Show all versions of swagger-all Show documentation
package com.fasterxml.jackson.dataformat.xml.ser;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.codehaus.stax2.XMLStreamWriter2;
import org.codehaus.stax2.ri.Stax2WriterAdapter;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.core.base.GeneratorBase;
import com.fasterxml.jackson.core.io.IOContext;
import com.fasterxml.jackson.core.json.JsonWriteContext;
import com.fasterxml.jackson.dataformat.xml.XmlPrettyPrinter;
import com.fasterxml.jackson.dataformat.xml.util.DefaultXmlPrettyPrinter;
import com.fasterxml.jackson.dataformat.xml.util.StaxUtil;
/**
* {@link JsonGenerator} that outputs JAXB-style XML output instead of JSON content.
* Operation requires calling code (usually either standard Jackson serializers,
* or in some cases (like BeanSerializer) customised ones) to do
* additional configuration calls beyond regular {@link JsonGenerator} API,
* mostly to pass namespace information.
*/
public final class ToXmlGenerator
extends GeneratorBase
{
/**
* If we support optional definition of element names, this is the element
* name to use...
*/
protected final static String DEFAULT_UNKNOWN_ELEMENT = "unknown";
/**
* Enumeration that defines all togglable extra XML-specific features
*/
public enum Feature {
/**
* Feature that controls whether XML declaration should be written before
* when generator is initialized (true) or not (false)
*/
WRITE_XML_DECLARATION(false),
/**
* Feature that controls whether output should be done as XML 1.1; if so,
* certain aspects may differ from default (1.0) processing: for example,
* XML declaration will be automatically added (regardless of setting
* WRITE_XML_DECLARATION) as this is required for reader to
* know to use 1.1 compliant handling. XML 1.1 can be used to allow quoted
* control characters (Ascii codes 0 through 31) as well as additional linefeeds
* and name characters.
*/
WRITE_XML_1_1(false)
;
final boolean _defaultState;
final int _mask;
/**
* Method that calculates bit set (flags) of all features that
* are enabled by default.
*/
public static int collectDefaults()
{
int flags = 0;
for (Feature f : values()) {
if (f.enabledByDefault()) {
flags |= f.getMask();
}
}
return flags;
}
private Feature(boolean defaultState) {
_defaultState = defaultState;
_mask = (1 << ordinal());
}
public boolean enabledByDefault() { return _defaultState; }
public int getMask() { return _mask; }
}
/*
/**********************************************************
/* Configuration
/**********************************************************
*/
final protected XMLStreamWriter2 _xmlWriter;
final protected XMLStreamWriter _originalXmlWriter;
/**
* Marker flag set if the underlying stream writer has to emulate
* Stax2 API: this is problematic if trying to use {@link #writeRaw} calls.
*/
final protected boolean _stax2Emulation;
final protected IOContext _ioContext;
/**
* Bit flag composed of bits that indicate which
* {@link ToXmlGenerator.Feature}s
* are enabled.
*/
protected int _xmlFeatures;
/**
* We may need to use XML-specific indentation as well
*/
protected XmlPrettyPrinter _xmlPrettyPrinter;
/*
/**********************************************************
/* XML Output state
/**********************************************************
*/
/**
* Marker set when {@link #initGenerator()} has been called or not.
*
* @since 2.2
*/
protected boolean _initialized;
/**
* Element or attribute name to use for next output call.
* Assigned by either code that initiates serialization
* or bean serializer.
*/
protected QName _nextName = null;
/**
* Marker flag that indicates whether next name to write
* implies an attribute (true) or element (false)
*/
protected boolean _nextIsAttribute = false;
/**
* Marker flag used to indicate that the next write of a (property)
* value should be done without using surrounding start/end
* elements. Flag is to be cleared once unwrapping has been triggered
* once.
*/
protected boolean _nextIsUnwrapped = false;
/**
* To support proper serialization of arrays it is necessary to keep
* stack of element names, so that we can "revert" to earlier
*/
protected LinkedList _elementNameStack = new LinkedList();
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public ToXmlGenerator(IOContext ctxt, int genericGeneratorFeatures, int xmlFeatures,
ObjectCodec codec, XMLStreamWriter sw)
{
super(genericGeneratorFeatures, codec);
_xmlFeatures = xmlFeatures;
_ioContext = ctxt;
_originalXmlWriter = sw;
_xmlWriter = Stax2WriterAdapter.wrapIfNecessary(sw);
_stax2Emulation = (_xmlWriter != sw);
_xmlPrettyPrinter = (_cfgPrettyPrinter instanceof XmlPrettyPrinter) ?
(XmlPrettyPrinter) _cfgPrettyPrinter : null;
}
/**
* Method called before writing any other output, to optionally
* output XML declaration.
*/
public void initGenerator() throws IOException, JsonGenerationException
{
if (_initialized) {
return;
}
_initialized = true;
try {
if ((_xmlFeatures & Feature.WRITE_XML_1_1.getMask()) != 0) {
_xmlWriter.writeStartDocument("UTF-8", "1.1");
} else if ((_xmlFeatures & Feature.WRITE_XML_DECLARATION.getMask()) != 0) {
_xmlWriter.writeStartDocument("UTF-8", "1.0");
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
/*
/**********************************************************
/* Extended API, configuration
/**********************************************************
*/
public ToXmlGenerator enable(Feature f) {
_xmlFeatures |= f.getMask();
return this;
}
public ToXmlGenerator disable(Feature f) {
_xmlFeatures &= ~f.getMask();
return this;
}
public final boolean isEnabled(Feature f) {
return (_xmlFeatures & f.getMask()) != 0;
}
public ToXmlGenerator configure(Feature f, boolean state) {
if (state) {
enable(f);
} else {
disable(f);
}
return this;
}
/*
/**********************************************************
/* Extended API, access to some internal components
/**********************************************************
*/
/**
* Method that allows application direct access to underlying
* Stax {@link XMLStreamWriter}. Note that use of writer is
* discouraged, and may interfere with processing of this writer;
* however, occasionally it may be necessary.
*
* Note: writer instance will always be of type
* {@link org.codehaus.stax2.XMLStreamWriter2} (including
* Typed Access API) so upcasts are safe.
*/
public XMLStreamWriter getStaxWriter() {
return _xmlWriter;
}
/*
/**********************************************************
/* Extended API, passing XML specific settings
/**********************************************************
*/
public void setNextIsAttribute(boolean isAttribute)
{
_nextIsAttribute = isAttribute;
}
public void setNextIsUnwrapped(boolean isUnwrapped)
{
_nextIsUnwrapped = isUnwrapped;
}
public final void setNextName(QName name)
{
_nextName = name;
}
/**
* Method that does same as {@link #setNextName}, unless
* a name has already been set.
*
* @since 2.1.2
*/
public final boolean setNextNameIfMissing(QName name)
{
if (_nextName == null) {
_nextName = name;
return true;
}
return false;
}
/**
* Methdod called when a structured (collection, array, map) is being
* output.
*
* @param wrapperName Element used as wrapper around elements, if any (null if none)
* @param wrappedName Element used around individual content items (can not
* be null)
*/
public void startWrappedValue(QName wrapperName, QName wrappedName) throws IOException, JsonGenerationException
{
if (wrapperName != null) {
try {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeStartElement(_xmlWriter,
wrapperName.getNamespaceURI(), wrapperName.getLocalPart());
} else {
_xmlWriter.writeStartElement(wrapperName.getNamespaceURI(), wrapperName.getLocalPart());
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
this.setNextName(wrappedName);
}
/**
* Method called after a structured collection output has completed
*/
public void finishWrappedValue(QName wrapperName, QName wrappedName) throws IOException, JsonGenerationException
{
// First: wrapper to close?
if (wrapperName != null) {
try {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeEndElement(_xmlWriter, _writeContext.getEntryCount());
} else {
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
}
/**
* Trivial helper method called when to add a replicated wrapper name
*
* @since 2.2
*/
public void writeRepeatedFieldName() throws IOException, JsonGenerationException
{
if (_writeContext.writeFieldName(_nextName.getLocalPart()) == JsonWriteContext.STATUS_EXPECT_VALUE) {
_reportError("Can not write a field name, expecting a value");
}
}
/*
/**********************************************************
/* JsonGenerator method overrides
/**********************************************************
*/
/* Most overrides in this section are just to make methods final,
* to allow better inlining...
*/
@Override
public final void writeFieldName(String name) throws IOException, JsonGenerationException
{
if (_writeContext.writeFieldName(name) == JsonWriteContext.STATUS_EXPECT_VALUE) {
_reportError("Can not write a field name, expecting a value");
}
// Should this ever get called?
String ns = (_nextName == null) ? "" : _nextName.getNamespaceURI();
setNextName(new QName(ns, name));
}
@Override
public final void writeStringField(String fieldName, String value)
throws IOException, JsonGenerationException
{
writeFieldName(fieldName);
writeString(value);
}
/*
/**********************************************************
/* JsonGenerator output method implementations, structural
/**********************************************************
*/
@Override
public final void writeStartArray() throws IOException, JsonGenerationException
{
_verifyValueWrite("start an array");
_writeContext = _writeContext.createChildArrayContext();
if (_cfgPrettyPrinter != null) {
_cfgPrettyPrinter.writeStartArray(this);
} else {
// nothing to do here; no-operation
}
}
@Override
public final void writeEndArray() throws IOException, JsonGenerationException
{
if (!_writeContext.inArray()) {
_reportError("Current context not an ARRAY but "+_writeContext.getTypeDesc());
}
if (_cfgPrettyPrinter != null) {
_cfgPrettyPrinter.writeEndArray(this, _writeContext.getEntryCount());
} else {
// nothing to do here; no-operation
}
_writeContext = _writeContext.getParent();
}
@Override
public final void writeStartObject() throws IOException, JsonGenerationException
{
_verifyValueWrite("start an object");
_writeContext = _writeContext.createChildObjectContext();
if (_cfgPrettyPrinter != null) {
_cfgPrettyPrinter.writeStartObject(this);
} else {
_handleStartObject();
}
}
@Override
public final void writeEndObject() throws IOException, JsonGenerationException
{
if (!_writeContext.inObject()) {
_reportError("Current context not an object but "+_writeContext.getTypeDesc());
}
_writeContext = _writeContext.getParent();
if (_cfgPrettyPrinter != null) {
// as per [Issue#45], need to suppress indentation if only attributes written:
int count = _nextIsAttribute ? 0 : _writeContext.getEntryCount();
_cfgPrettyPrinter.writeEndObject(this, count);
} else {
_handleEndObject();
}
}
// note: public just because pretty printer needs to make a callback
public final void _handleStartObject() throws IOException, JsonGenerationException
{
if (_nextName == null) {
handleMissingName();
}
// Need to keep track of names to make Lists work correctly
_elementNameStack.addLast(_nextName);
try {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
// note: public just because pretty printer needs to make a callback
public final void _handleEndObject() throws IOException, JsonGenerationException
{
// We may want to repeat same element, so:
if (_elementNameStack.isEmpty()) {
throw new JsonGenerationException("Can not write END_ELEMENT without open START_ELEMENT");
}
_nextName = _elementNameStack.removeLast();
try {
// note: since attributes don't nest, can only have one attribute active, so:
_nextIsAttribute = false;
_xmlWriter.writeEndElement();
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
/*
/**********************************************************
/* Output method implementations, textual
/**********************************************************
*/
@Override
public void writeFieldName(SerializableString name)
throws IOException, JsonGenerationException
{
writeFieldName(name.getValue());
}
@Override
public void writeString(String text) throws IOException,JsonGenerationException
{
_verifyValueWrite("write String value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) { // must write attribute name and value with one call
_xmlWriter.writeAttribute(_nextName.getNamespaceURI(), _nextName.getLocalPart(), text);
} else if (checkNextIsUnwrapped()) {
// [Issue#56] Should figure out how to prevent indentation for end element
// but for now, let's just make sure structure is correct
//if (_xmlPrettyPrinter != null) { ... }
_xmlWriter.writeCharacters(text);
} else if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
text);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeCharacters(text);
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeString(char[] text, int offset, int len) throws IOException, JsonGenerationException
{
_verifyValueWrite("write String value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeAttribute(_nextName.getNamespaceURI(), _nextName.getLocalPart(), new String(text, offset, len));
} else if (checkNextIsUnwrapped()) {
// should we consider pretty-printing or not?
_xmlWriter.writeCharacters(text, offset, len);
} else if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
text, offset, len);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeCharacters(text, offset, len);
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeString(SerializableString text) throws IOException, JsonGenerationException {
writeString(text.getValue());
}
@Override
public void writeRawUTF8String(byte[] text, int offset, int length)
throws IOException, JsonGenerationException
{
// could add support for this case if we really want it (and can make Stax2 support it)
_reportUnsupportedOperation();
}
@Override
public void writeUTF8String(byte[] text, int offset, int length)
throws IOException, JsonGenerationException
{
// could add support for this case if we really want it (and can make Stax2 support it)
_reportUnsupportedOperation();
}
/*
/**********************************************************
/* Output method implementations, unprocessed ("raw")
/**********************************************************
*/
@Override
public void writeRaw(String text) throws IOException, JsonGenerationException
{
// [Issue#39]
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRaw");
}
try {
_xmlWriter.writeRaw(text);
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeRaw(String text, int offset, int len) throws IOException, JsonGenerationException
{
// [Issue#39]
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRaw");
}
try {
_xmlWriter.writeRaw(text, offset, len);
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeRaw(char[] text, int offset, int len) throws IOException, JsonGenerationException
{
// [Issue#39]
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRaw");
}
try {
_xmlWriter.writeRaw(text, offset, len);
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeRaw(char c) throws IOException, JsonGenerationException
{
writeRaw(String.valueOf(c));
}
/*
/**********************************************************
/* Output method implementations, base64-encoded binary
/**********************************************************
*/
@Override
public void writeBinary(Base64Variant b64variant,
byte[] data, int offset, int len)
throws IOException, JsonGenerationException
{
if (data == null) {
writeNull();
return;
}
_verifyValueWrite("write Binary value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
// Stax2 API only has 'full buffer' write method:
byte[] fullBuffer = toFullBuffer(data, offset, len);
_xmlWriter.writeBinaryAttribute("", _nextName.getNamespaceURI(), _nextName.getLocalPart(), fullBuffer);
} else if (checkNextIsUnwrapped()) {
// should we consider pretty-printing or not?
_xmlWriter.writeBinary(data, offset, len);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
data, offset, len);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeBinary(data, offset, len);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
private byte[] toFullBuffer(byte[] data, int offset, int len)
{
// might already be ok:
if (offset == 0 && len == data.length) {
return data;
}
byte[] result = new byte[len];
if (len > 0) {
System.arraycopy(data, offset, result, 0, len);
}
return result;
}
/*
/**********************************************************
/* Output method implementations, primitive
/**********************************************************
*/
@Override
public void writeBoolean(boolean value) throws IOException, JsonGenerationException
{
_verifyValueWrite("write boolean value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeBooleanAttribute(null, _nextName.getNamespaceURI(), _nextName.getLocalPart(), value);
} else if (checkNextIsUnwrapped()) {
// should we consider pretty-printing or not?
_xmlWriter.writeBoolean(value);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
value);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeBoolean(value);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNull() throws IOException, JsonGenerationException
{
_verifyValueWrite("write null value");
if (_nextName == null) {
handleMissingName();
}
// !!! TODO: proper use of 'xsd:isNil' ?
try {
if (_nextIsAttribute) {
/* With attributes, best just leave it out, right? (since there's no way
* to use 'xsi:nil')
*/
} else if (checkNextIsUnwrapped()) {
// as with above, best left unwritten?
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafNullElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart());
} else {
_xmlWriter.writeEmptyElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNumber(int i) throws IOException, JsonGenerationException
{
_verifyValueWrite("write number");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeIntAttribute(null, _nextName.getNamespaceURI(), _nextName.getLocalPart(), i);
} else if (checkNextIsUnwrapped()) {
// should we consider pretty-printing or not?
_xmlWriter.writeInt(i);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
i);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeInt(i);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNumber(long l) throws IOException, JsonGenerationException
{
_verifyValueWrite("write number");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeLongAttribute(null, _nextName.getNamespaceURI(), _nextName.getLocalPart(), l);
} else if (checkNextIsUnwrapped()) {
_xmlWriter.writeLong(l);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
l);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeLong(l);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNumber(double d) throws IOException, JsonGenerationException
{
_verifyValueWrite("write number");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeDoubleAttribute(null, _nextName.getNamespaceURI(), _nextName.getLocalPart(), d);
} else if (checkNextIsUnwrapped()) {
_xmlWriter.writeDouble(d);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
d);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeDouble(d);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNumber(float f) throws IOException, JsonGenerationException
{
_verifyValueWrite("write number");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeFloatAttribute(null, _nextName.getNamespaceURI(), _nextName.getLocalPart(), f);
} else if (checkNextIsUnwrapped()) {
_xmlWriter.writeFloat(f);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
f);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeFloat(f);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNumber(BigDecimal dec) throws IOException, JsonGenerationException
{
if (dec == null) {
writeNull();
return;
}
_verifyValueWrite("write number");
if (_nextName == null) {
handleMissingName();
}
boolean usePlain = isEnabled(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN);
try {
if (_nextIsAttribute) {
if (usePlain) {
_xmlWriter.writeAttribute("", _nextName.getNamespaceURI(), _nextName.getLocalPart(),
dec.toPlainString());
} else {
_xmlWriter.writeDecimalAttribute("", _nextName.getNamespaceURI(), _nextName.getLocalPart(), dec);
}
} else if (checkNextIsUnwrapped()) {
if (usePlain) {
_xmlWriter.writeCharacters(dec.toPlainString());
} else {
_xmlWriter.writeDecimal(dec);
}
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
dec);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
if (usePlain) {
_xmlWriter.writeDecimal(dec);
} else {
_xmlWriter.writeCharacters(dec.toPlainString());
}
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNumber(BigInteger value)
throws IOException, JsonGenerationException
{
if (value == null) {
writeNull();
return;
}
_verifyValueWrite("write number");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeIntegerAttribute("",
_nextName.getNamespaceURI(), _nextName.getLocalPart(), value);
} else if (checkNextIsUnwrapped()) {
_xmlWriter.writeInteger(value);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
value);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeInteger(value);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
public void writeNumber(String encodedValue) throws IOException,JsonGenerationException, UnsupportedOperationException
{
writeString(encodedValue);
}
/*
/**********************************************************
/* Implementations, overrides for other methods
/**********************************************************
*/
@Override
protected final void _verifyValueWrite(String typeMsg)
throws IOException, JsonGenerationException
{
int status = _writeContext.writeValue();
if (status == JsonWriteContext.STATUS_EXPECT_NAME) {
_reportError("Can not "+typeMsg+", expecting field name");
}
}
/**
* Standard JSON indenter does not work well with XML, use
* default XML indenter instead.
*/
@Override
public final JsonGenerator useDefaultPrettyPrinter()
{
return setPrettyPrinter(new DefaultXmlPrettyPrinter());
}
@Override
public JsonGenerator setPrettyPrinter(PrettyPrinter pp) {
_cfgPrettyPrinter = pp;
_xmlPrettyPrinter = (pp instanceof XmlPrettyPrinter) ?
(XmlPrettyPrinter) pp : null;
return this;
}
/*
/**********************************************************
/* Low-level output handling
/**********************************************************
*/
@Override
public final void flush() throws IOException
{
if (isEnabled(JsonGenerator.Feature.FLUSH_PASSED_TO_STREAM)) {
try {
_xmlWriter.flush();
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
}
@Override
public void close() throws IOException
{
// boolean wasClosed = _closed;
super.close();
/* 05-Dec-2008, tatu: To add [JACKSON-27], need to close open
* scopes.
*/
// First: let's see that we still have buffers...
if (isEnabled(JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT)) {
try {
while (true) {
JsonStreamContext ctxt = getOutputContext();
if (ctxt.inArray()) {
writeEndArray();
} else if (ctxt.inObject()) {
writeEndObject();
} else {
break;
}
}
} catch (ArrayIndexOutOfBoundsException e) {
/* 29-Nov-2010, tatu: Stupid, stupid SJSXP doesn't do array checks, so we get
* hit by this as a collateral problem in some cases. Yuck.
*/
throw new JsonGenerationException(e);
}
}
try {
if (_ioContext.isResourceManaged() || isEnabled(JsonGenerator.Feature.AUTO_CLOSE_TARGET)) {
_xmlWriter.closeCompletely();
} else {
_xmlWriter.close();
}
} catch (XMLStreamException e) {
StaxUtil.throwXmlAsIOException(e);
}
}
@Override
protected void _releaseBuffers() {
// Nothing to do here, as we have no buffers
}
/*
/**********************************************************
/* Internal methods
/**********************************************************
*/
/**
* Method called to see if unwrapping is required; and if so,
* clear the flag (so further calls will return 'false' unless
* state is re-set)
*/
protected boolean checkNextIsUnwrapped()
{
if (_nextIsUnwrapped) {
_nextIsUnwrapped = false;
return true;
}
return false;
}
protected void handleMissingName()
{
throw new IllegalStateException("No element/attribute name specified when trying to output element");
}
/**
* Method called
*/
protected void _reportUnimplementedStax2(String missingMethod) throws IOException
{
throw new JsonGenerationException("Underlying Stax XMLStreamWriter (of type "
+_originalXmlWriter.getClass().getName()
+") does not implement Stax2 API natively and is missing method '"
+missingMethod+"': this breaks functionality such as indentation that relies on it. "
+"You need to upgrade to using compliant Stax implementation like Woodstox or Aalto");
}
}