package com.fasterxml.jackson.dataformat.xml.ser;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import javax.xml.XMLConstants;
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.core.util.JacksonFeatureSet;
import com.fasterxml.jackson.dataformat.xml.XmlPrettyPrinter;
import com.fasterxml.jackson.dataformat.xml.util.DefaultXmlPrettyPrinter;
import com.fasterxml.jackson.dataformat.xml.util.StaxUtil;
public class ToXmlGenerator
extends GeneratorBase
{
protected final static String DEFAULT_UNKNOWN_ELEMENT = "unknown";
public enum Feature implements FormatFeature
{
WRITE_XML_DECLARATION(false),
WRITE_XML_1_1(false),
WRITE_NULLS_AS_XSI_NIL(false)
;
final boolean _defaultState;
final int _mask;
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());
}
@Override public boolean enabledByDefault() { return _defaultState; }
@Override public int getMask() { return _mask; }
@Override public boolean enabledIn(int flags) { return (flags & getMask()) != 0; }
}
final protected XMLStreamWriter2 _xmlWriter;
final protected XMLStreamWriter _originalXmlWriter;
final protected boolean _stax2Emulation;
final protected IOContext _ioContext;
protected int _formatFeatures;
protected XmlPrettyPrinter _xmlPrettyPrinter;
protected boolean _initialized;
protected QName _nextName = null;
protected boolean _nextIsAttribute = false;
protected boolean _nextIsUnwrapped = false;
protected boolean _nextIsCData = false;
protected LinkedList<QName> _elementNameStack = new LinkedList<QName>();
public ToXmlGenerator(IOContext ctxt, int stdFeatures, int xmlFeatures,
ObjectCodec codec, XMLStreamWriter sw)
{
super(stdFeatures, codec);
_formatFeatures = xmlFeatures;
_ioContext = ctxt;
_originalXmlWriter = sw;
_xmlWriter = Stax2WriterAdapter.wrapIfNecessary(sw);
_stax2Emulation = (_xmlWriter != sw);
_xmlPrettyPrinter = (_cfgPrettyPrinter instanceof XmlPrettyPrinter) ?
(XmlPrettyPrinter) _cfgPrettyPrinter : null;
}
public void initGenerator() throws IOException
{
if (_initialized) {
return;
}
_initialized = true;
try {
if (Feature.WRITE_XML_1_1.enabledIn(_formatFeatures)) {
_xmlWriter.writeStartDocument("UTF-8", "1.1");
} else if (Feature.WRITE_XML_DECLARATION.enabledIn(_formatFeatures)) {
_xmlWriter.writeStartDocument("UTF-8", "1.0");
} else {
return;
}
if (_xmlPrettyPrinter != null) {
if (!_stax2Emulation) {
_xmlPrettyPrinter.writePrologLinefeed(_xmlWriter);
}
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
protected PrettyPrinter _constructDefaultPrettyPrinter() {
return new DefaultXmlPrettyPrinter();
}
@Override
public JsonGenerator setPrettyPrinter(PrettyPrinter pp) {
_cfgPrettyPrinter = pp;
_xmlPrettyPrinter = (pp instanceof XmlPrettyPrinter) ?
(XmlPrettyPrinter) pp : null;
return this;
}
@Override
public Object getOutputTarget() {
return _originalXmlWriter;
}
@Override
public int getOutputBuffered() {
return -1;
}
@Override
public int getFormatFeatures() {
return _formatFeatures;
}
@Override
public JsonGenerator overrideFormatFeatures(int values, int mask)
{
int oldF = _formatFeatures;
int newF = (_formatFeatures & ~mask) | (values & mask);
if (oldF != newF) {
_formatFeatures = newF;
}
return this;
}
public ToXmlGenerator enable(Feature f) {
_formatFeatures |= f.getMask();
return this;
}
public ToXmlGenerator disable(Feature f) {
_formatFeatures &= ~f.getMask();
return this;
}
public final boolean isEnabled(Feature f) {
return (_formatFeatures & f.getMask()) != 0;
}
public ToXmlGenerator configure(Feature f, boolean state) {
if (state) {
enable(f);
} else {
disable(f);
}
return this;
}
@Override
public boolean canWriteFormattedNumbers() { return true; }
@Override
public JacksonFeatureSet<StreamWriteCapability> getWriteCapabilities() {
return DEFAULT_TEXTUAL_WRITE_CAPABILITIES;
}
public boolean inRoot() {
return _writeContext.inRoot();
}
public XMLStreamWriter getStaxWriter() {
return _xmlWriter;
}
public void setNextIsAttribute(boolean isAttribute)
{
_nextIsAttribute = isAttribute;
}
public void setNextIsUnwrapped(boolean isUnwrapped)
{
_nextIsUnwrapped = isUnwrapped;
}
public void setNextIsCData(boolean isCData)
{
_nextIsCData = isCData;
}
public final void setNextName(QName name)
{
_nextName = name;
}
public final boolean setNextNameIfMissing(QName name)
{
if (_nextName == null) {
_nextName = name;
return true;
}
return false;
}
public void startWrappedValue(QName wrapperName, QName wrappedName) throws IOException
{
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.throwAsGenerationException(e, this);
}
}
this.setNextName(wrappedName);
}
public void finishWrappedValue(QName wrapperName, QName wrappedName) throws IOException
{
if (wrapperName != null) {
try {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeEndElement(_xmlWriter, _writeContext.getEntryCount());
} else {
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
}
public void writeRepeatedFieldName() throws IOException
{
if (_writeContext.writeFieldName(_nextName.getLocalPart()) == JsonWriteContext.STATUS_EXPECT_VALUE) {
_reportError("Can not write a field name, expecting a value");
}
}
@Override
public final void writeFieldName(String name) throws IOException
{
if (_writeContext.writeFieldName(name) == JsonWriteContext.STATUS_EXPECT_VALUE) {
_reportError("Can not write a field name, expecting a value");
}
String ns = (_nextName == null) ? "" : _nextName.getNamespaceURI();
setNextName(new QName(ns, name));
}
@Override
public final void writeStringField(String fieldName, String value) throws IOException
{
writeFieldName(fieldName);
writeString(value);
}
@Override
public final void writeStartArray() throws IOException
{
_verifyValueWrite("start an array");
_writeContext = _writeContext.createChildArrayContext();
if (_cfgPrettyPrinter != null) {
_cfgPrettyPrinter.writeStartArray(this);
} else {
}
}
@Override
public final void writeEndArray() throws IOException
{
if (!_writeContext.inArray()) {
_reportError("Current context not Array but "+_writeContext.typeDesc());
}
if (_cfgPrettyPrinter != null) {
_cfgPrettyPrinter.writeEndArray(this, _writeContext.getEntryCount());
} else {
}
_writeContext = _writeContext.getParent();
}
@Override
public final void writeStartObject() throws IOException
{
_verifyValueWrite("start an object");
_writeContext = _writeContext.createChildObjectContext();
if (_cfgPrettyPrinter != null) {
_cfgPrettyPrinter.writeStartObject(this);
} else {
_handleStartObject();
}
}
@Override
public final void writeEndObject() throws IOException
{
if (!_writeContext.inObject()) {
_reportError("Current context not Object but "+_writeContext.typeDesc());
}
_writeContext = _writeContext.getParent();
if (_cfgPrettyPrinter != null) {
int count = _nextIsAttribute ? 0 : _writeContext.getEntryCount();
_cfgPrettyPrinter.writeEndObject(this, count);
} else {
_handleEndObject();
}
}
public final void _handleStartObject() throws IOException
{
if (_nextName == null) {
handleMissingName();
}
_elementNameStack.addLast(_nextName);
try {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
public final void _handleEndObject() throws IOException
{
if (_elementNameStack.isEmpty()) {
throw new JsonGenerationException("Can not write END_ELEMENT without open START_ELEMENT", this);
}
_nextName = _elementNameStack.removeLast();
try {
_nextIsAttribute = false;
_xmlWriter.writeEndElement();
if (_elementNameStack.isEmpty() && (_xmlPrettyPrinter != null)) {
if (!_stax2Emulation) {
_xmlPrettyPrinter.writePrologLinefeed(_xmlWriter);
}
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeFieldName(SerializableString name) throws IOException
{
writeFieldName(name.getValue());
}
@Override
public void writeString(String text) throws IOException
{
if (text == null) {
writeNull();
return;
}
_verifyValueWrite("write String value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeAttribute(_nextName.getNamespaceURI(), _nextName.getLocalPart(), text);
} else if (checkNextIsUnwrapped()) {
if(_nextIsCData) {
_xmlWriter.writeCData(text);
} else {
_xmlWriter.writeCharacters(text);
}
} else if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
text, _nextIsCData);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
if(_nextIsCData) {
_xmlWriter.writeCData(text);
} else {
_xmlWriter.writeCharacters(text);
}
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeString(char[] text, int offset, int len) throws IOException
{
_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()) {
if(_nextIsCData) {
_xmlWriter.writeCData(text, offset, len);
} else {
_xmlWriter.writeCharacters(text, offset, len);
}
} else if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
text, offset, len, _nextIsCData);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
if(_nextIsCData) {
_xmlWriter.writeCData(text, offset, len);
} else {
_xmlWriter.writeCharacters(text, offset, len);
}
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeString(SerializableString text) throws IOException {
writeString(text.getValue());
}
@Override
public void writeRawUTF8String(byte[] text, int offset, int length) throws IOException
{
_reportUnsupportedOperation();
}
@Override
public void writeUTF8String(byte[] text, int offset, int length) throws IOException
{
_reportUnsupportedOperation();
}
@Override
public void writeRawValue(String text) throws IOException {
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRawValue");
}
try {
_verifyValueWrite("write raw value");
if (_nextName == null) {
handleMissingName();
}
if (_nextIsAttribute) {
_xmlWriter.writeAttribute(_nextName.getNamespaceURI(), _nextName.getLocalPart(), text);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeRaw(text);
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeRawValue(String text, int offset, int len) throws IOException {
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRawValue");
}
try {
_verifyValueWrite("write raw value");
if (_nextName == null) {
handleMissingName();
}
if (_nextIsAttribute) {
_xmlWriter.writeAttribute(_nextName.getNamespaceURI(), _nextName.getLocalPart(), text.substring(offset, offset + len));
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeRaw(text, offset, len);
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeRawValue(char[] text, int offset, int len) throws IOException {
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRawValue");
}
_verifyValueWrite("write raw value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeAttribute(_nextName.getNamespaceURI(), _nextName.getLocalPart(), new String(text, offset, len));
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeRaw(text, offset, len);
_xmlWriter.writeEndElement();
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeRawValue(SerializableString text) throws IOException {
_reportUnsupportedOperation();
}
@Override
public void writeRaw(String text) throws IOException
{
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRaw");
}
try {
_xmlWriter.writeRaw(text);
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeRaw(String text, int offset, int len) throws IOException
{
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRaw");
}
try {
_xmlWriter.writeRaw(text, offset, len);
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeRaw(char[] text, int offset, int len) throws IOException
{
if (_stax2Emulation) {
_reportUnimplementedStax2("writeRaw");
}
try {
_xmlWriter.writeRaw(text, offset, len);
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeRaw(char c) throws IOException
{
writeRaw(String.valueOf(c));
}
@Override
public void writeBinary(Base64Variant b64variant,
byte[] data, int offset, int len) throws IOException
{
if (data == null) {
writeNull();
return;
}
_verifyValueWrite("write Binary value");
if (_nextName == null) {
handleMissingName();
}
final org.codehaus.stax2.typed.Base64Variant stax2base64v = StaxUtil.toStax2Base64Variant(b64variant);
try {
if (_nextIsAttribute) {
byte[] fullBuffer = toFullBuffer(data, offset, len);
_xmlWriter.writeBinaryAttribute(stax2base64v,
"", _nextName.getNamespaceURI(), _nextName.getLocalPart(), fullBuffer);
} else if (checkNextIsUnwrapped()) {
_xmlWriter.writeBinary(stax2base64v, data, offset, len);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
stax2base64v, data, offset, len);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeBinary(stax2base64v, data, offset, len);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public int writeBinary(Base64Variant b64variant, InputStream data, int dataLength) throws IOException
{
if (data == null) {
writeNull();
return 0;
}
_verifyValueWrite("write Binary value");
if (_nextName == null) {
handleMissingName();
}
final org.codehaus.stax2.typed.Base64Variant stax2base64v = StaxUtil.toStax2Base64Variant(b64variant);
try {
if (_nextIsAttribute) {
byte[] fullBuffer = toFullBuffer(data, dataLength);
_xmlWriter.writeBinaryAttribute(stax2base64v,
"", _nextName.getNamespaceURI(), _nextName.getLocalPart(), fullBuffer);
} else if (checkNextIsUnwrapped()) {
writeStreamAsBinary(stax2base64v, data, dataLength);
} else {
if (_xmlPrettyPrinter != null) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
stax2base64v, toFullBuffer(data, dataLength), 0, dataLength);
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
writeStreamAsBinary(stax2base64v, data, dataLength);
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
return dataLength;
}
private void writeStreamAsBinary(org.codehaus.stax2.typed.Base64Variant stax2base64v,
InputStream data, int len) throws IOException, XMLStreamException
{
byte[] tmp = new byte[3];
int offset = 0;
int read;
while((read = data.read(tmp, offset, Math.min(3 - offset, len))) != -1) {
offset += read;
len -= read;
if(offset == 3) {
offset = 0;
_xmlWriter.writeBinary(stax2base64v, tmp, 0, 3);
}
if (len == 0) {
break;
}
}
if(offset > 0) {
_xmlWriter.writeBinary(stax2base64v, tmp, 0, offset);
}
}
private byte[] toFullBuffer(byte[] data, int offset, int len)
{
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;
}
private byte[] toFullBuffer(InputStream data, final int len) throws IOException
{
byte[] result = new byte[len];
int offset = 0;
for (; offset < len; ) {
int count = data.read(result, offset, len - offset);
if (count < 0) {
_reportError("Too few bytes available: missing "+(len - offset)+" bytes (out of "+len+")");
}
offset += count;
}
return result;
}
@Override
public void writeBoolean(boolean value) throws IOException
{
_verifyValueWrite("write boolean value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeBooleanAttribute(null, _nextName.getNamespaceURI(), _nextName.getLocalPart(), value);
} else if (checkNextIsUnwrapped()) {
_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.throwAsGenerationException(e, this);
}
}
@Override
public void writeNull() throws IOException
{
_verifyValueWrite("write null value");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
} else if (checkNextIsUnwrapped()) {
} else {
final boolean asXsiNil = isEnabled(Feature.WRITE_NULLS_AS_XSI_NIL);
if (_xmlPrettyPrinter != null) {
if (asXsiNil && (_xmlPrettyPrinter instanceof DefaultXmlPrettyPrinter)) {
((DefaultXmlPrettyPrinter) _xmlPrettyPrinter).writeLeafXsiNilElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart());
} else {
_xmlPrettyPrinter.writeLeafNullElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart());
}
} else {
if (asXsiNil) {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
_xmlWriter.writeAttribute("xsi", XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI, "nil", "true");
_xmlWriter.writeEndElement();
} else {
_xmlWriter.writeEmptyElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
}
}
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeNumber(int i) throws IOException
{
_verifyValueWrite("write number");
if (_nextName == null) {
handleMissingName();
}
try {
if (_nextIsAttribute) {
_xmlWriter.writeIntAttribute(null, _nextName.getNamespaceURI(), _nextName.getLocalPart(), i);
} else if (checkNextIsUnwrapped()) {
_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.throwAsGenerationException(e, this);
}
}
@Override
public void writeNumber(long l) throws IOException
{
_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.throwAsGenerationException(e, this);
}
}
@Override
public void writeNumber(double d) throws IOException
{
_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.throwAsGenerationException(e, this);
}
}
@Override
public void writeNumber(float f) throws IOException
{
_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.throwAsGenerationException(e, this);
}
}
@Override
public void writeNumber(BigDecimal dec) throws IOException
{
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) {
if (usePlain) {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
dec.toPlainString(), false);
} else {
_xmlPrettyPrinter.writeLeafElement(_xmlWriter,
_nextName.getNamespaceURI(), _nextName.getLocalPart(),
dec);
}
} else {
_xmlWriter.writeStartElement(_nextName.getNamespaceURI(), _nextName.getLocalPart());
if (usePlain) {
_xmlWriter.writeCharacters(dec.toPlainString());
} else {
_xmlWriter.writeDecimal(dec);
}
_xmlWriter.writeEndElement();
}
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
public void writeNumber(BigInteger value) throws IOException
{
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.throwAsGenerationException(e, this);
}
}
@Override
public void writeNumber(String encodedValue) throws IOException, UnsupportedOperationException
{
writeString(encodedValue);
}
@Override
protected final void _verifyValueWrite(String typeMsg) throws IOException
{
int status = _writeContext.writeValue();
if (status == JsonWriteContext.STATUS_EXPECT_NAME) {
_reportError("Can not "+typeMsg+", expecting field name");
}
}
@Override
public void flush() throws IOException
{
if (isEnabled(JsonGenerator.Feature.FLUSH_PASSED_TO_STREAM)) {
try {
_xmlWriter.flush();
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
}
@Override
public void close() throws IOException
{
super.close();
if (isEnabled(JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT)) {
try {
while (true) {
JsonStreamContext ctxt = _writeContext;
if (ctxt.inArray()) {
writeEndArray();
} else if (ctxt.inObject()) {
writeEndObject();
} else {
break;
}
}
} catch (ArrayIndexOutOfBoundsException e) {
throw new JsonGenerationException(e, this);
}
}
try {
if (_ioContext.isResourceManaged() || isEnabled(JsonGenerator.Feature.AUTO_CLOSE_TARGET)) {
_xmlWriter.closeCompletely();
} else {
_xmlWriter.close();
}
} catch (XMLStreamException e) {
StaxUtil.throwAsGenerationException(e, this);
}
}
@Override
protected void _releaseBuffers() {
}
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");
}
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",
this);
}
}