/* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.xmlbeans.impl.richParser;
import org.apache.xmlbeans.GDate;
import org.apache.xmlbeans.GDateBuilder;
import org.apache.xmlbeans.GDuration;
import org.apache.xmlbeans.XmlCalendar;
import org.apache.xmlbeans.impl.common.XMLChar;
import org.apache.xmlbeans.impl.util.XsTypeConverter;
import org.apache.xmlbeans.impl.util.Base64;
import org.apache.xmlbeans.impl.util.HexBin;
import org.apache.xmlbeans.impl.common.InvalidLexicalValueException;
import org.apache.xmlbeans.impl.common.XmlWhitespace;
import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;
import javax.xml.stream.Location;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
/**
* Author: Cezar Andrei (cezar.andrei at bea.com)
* Date: Nov 17, 2003
*/
public class XMLStreamReaderExtImpl
implements XMLStreamReaderExt
{
private final XMLStreamReader _xmlStream;
private final CharSeqTrimWS _charSeq;
private String _defaultValue;
public XMLStreamReaderExtImpl(XMLStreamReader xmlStream)
{
if (xmlStream==null)
throw new IllegalArgumentException();
_xmlStream = xmlStream;
_charSeq = new CharSeqTrimWS(this);
}
public XMLStreamReader getUnderlyingXmlStream()
{
return _xmlStream;
}
// XMLStreamReaderExt methods
public String getStringValue()
throws XMLStreamException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_PRESERVE);
return _charSeq.toString();
}
public String getStringValue(int wsStyle)
throws XMLStreamException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_PRESERVE);
//REVIEW zieg 2004-01-11 - we should write a collapse method
//that takes a CharSequence to void creating this extra String object
return XmlWhitespace.collapse(_charSeq.toString(), wsStyle);
}
public boolean getBooleanValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexBoolean(_charSeq);
}
catch(InvalidLexicalValueException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public byte getByteValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexByte(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public short getShortValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexShort(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public int getIntValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexInt(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public long getLongValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexLong(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public BigInteger getBigIntegerValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexInteger(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public BigDecimal getBigDecimalValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexDecimal(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public float getFloatValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexFloat(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public double getDoubleValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexDouble(_charSeq);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public InputStream getHexBinaryValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
String text = _charSeq.toString();
byte[] buf = HexBin.decode(text.getBytes());
if (buf!=null)
return new ByteArrayInputStream(buf);
else
throw new InvalidLexicalValueException("invalid hexBinary value", _charSeq.getLocation());
}
public InputStream getBase64Value()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
String text = _charSeq.toString();
byte[] buf = Base64.decode(text.getBytes());
if (buf!=null)
return new ByteArrayInputStream(buf);
else
throw new InvalidLexicalValueException("invalid base64Binary value", _charSeq.getLocation());
}
public XmlCalendar getCalendarValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return new GDateBuilder(_charSeq).getCalendar();
}
catch( IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public Date getDateValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return new GDateBuilder(_charSeq).getDate();
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public GDate getGDateValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexGDate(_charSeq);
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public GDuration getGDurationValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return new GDuration(_charSeq);
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public QName getQNameValue()
throws XMLStreamException, InvalidLexicalValueException
{
_charSeq.reload(CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexQName(_charSeq, _xmlStream.getNamespaceContext());
}
catch(InvalidLexicalValueException e)
{
throw new InvalidLexicalValueException(e.getMessage(), _charSeq.getLocation());
}
}
public String getAttributeStringValue(int index) throws XMLStreamException
{
return _xmlStream.getAttributeValue(index);
}
public String getAttributeStringValue(int index, int wsStyle) throws XMLStreamException
{
return XmlWhitespace.collapse(_xmlStream.getAttributeValue(index), wsStyle);
}
public boolean getAttributeBooleanValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexBoolean(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(InvalidLexicalValueException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public byte getAttributeByteValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexByte(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public short getAttributeShortValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexShort(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public int getAttributeIntValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexInt(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public long getAttributeLongValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexLong(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public BigInteger getAttributeBigIntegerValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexInteger(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public BigDecimal getAttributeBigDecimalValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexDecimal(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public float getAttributeFloatValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexFloat(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public double getAttributeDoubleValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexDouble(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public InputStream getAttributeHexBinaryValue(int index) throws XMLStreamException
{
String text = _charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM).toString();
byte[] buf = HexBin.decode(text.getBytes());
if (buf!=null)
return new ByteArrayInputStream(buf);
else
throw new InvalidLexicalValueException("invalid hexBinary value", _charSeq.getLocation());
}
public InputStream getAttributeBase64Value(int index) throws XMLStreamException
{
String text = _charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM).toString();
byte[] buf = Base64.decode(text.getBytes());
if (buf!=null)
return new ByteArrayInputStream(buf);
else
throw new InvalidLexicalValueException("invalid base64Binary value", _charSeq.getLocation());
}
public XmlCalendar getAttributeCalendarValue(int index) throws XMLStreamException
{
try
{
return new GDateBuilder(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM)).
getCalendar();
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public Date getAttributeDateValue(int index) throws XMLStreamException
{
try
{
return new GDateBuilder(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM))
.getDate();
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public GDate getAttributeGDateValue(int index) throws XMLStreamException
{
try
{
return new GDate(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public GDuration getAttributeGDurationValue(int index) throws XMLStreamException
{
try
{
return new GDuration(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public QName getAttributeQNameValue(int index) throws XMLStreamException
{
try
{
return XsTypeConverter.lexQName(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM),
_xmlStream.getNamespaceContext());
}
catch(InvalidLexicalValueException e)
{
throw new InvalidLexicalValueException(e.getMessage(), _charSeq.getLocation());
}
}
public String getAttributeStringValue(String uri, String local) throws XMLStreamException
{
return _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_PRESERVE).toString();
}
public String getAttributeStringValue(String uri, String local, int wsStyle) throws XMLStreamException
{
return XmlWhitespace.collapse(_xmlStream.getAttributeValue(uri, local), wsStyle);
}
public boolean getAttributeBooleanValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexBoolean(cs);
}
catch(InvalidLexicalValueException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public byte getAttributeByteValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexByte(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public short getAttributeShortValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexShort(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public int getAttributeIntValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexInt(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public long getAttributeLongValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexLong(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public BigInteger getAttributeBigIntegerValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexInteger(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public BigDecimal getAttributeBigDecimalValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexDecimal(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public float getAttributeFloatValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexFloat(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public double getAttributeDoubleValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexDouble(cs);
}
catch(NumberFormatException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public InputStream getAttributeHexBinaryValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
String text = cs.toString();
byte[] buf = HexBin.decode(text.getBytes());
if (buf!=null)
return new ByteArrayInputStream(buf);
else
throw new InvalidLexicalValueException("invalid hexBinary value", _charSeq.getLocation());
}
public InputStream getAttributeBase64Value(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
String text = cs.toString();
byte[] buf = Base64.decode(text.getBytes());
if (buf!=null)
return new ByteArrayInputStream(buf);
else
throw new InvalidLexicalValueException("invalid base64Binary value", _charSeq.getLocation());
}
public XmlCalendar getAttributeCalendarValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return new GDateBuilder(cs).getCalendar();
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public Date getAttributeDateValue(String uri, String local) throws XMLStreamException
{
try
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
return new GDateBuilder(cs).getDate();
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public GDate getAttributeGDateValue(String uri, String local) throws XMLStreamException
{
try
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
return new GDate(cs);
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public GDuration getAttributeGDurationValue(String uri, String local) throws XMLStreamException
{
try
{
return new GDuration(_charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM));
}
catch(IllegalArgumentException e)
{
throw new InvalidLexicalValueException(e, _charSeq.getLocation());
}
}
public QName getAttributeQNameValue(String uri, String local) throws XMLStreamException
{
CharSequence cs = _charSeq.reloadAtt(uri, local, CharSeqTrimWS.XMLWHITESPACE_TRIM);
try
{
return XsTypeConverter.lexQName(cs, _xmlStream.getNamespaceContext());
}
catch (InvalidLexicalValueException e)
{
throw new InvalidLexicalValueException(e.getMessage(), _charSeq.getLocation());
}
}
public void setDefaultValue(String defaultValue) throws XMLStreamException
{
_defaultValue = defaultValue;
}
/**
* Only trims the XML whaitspace at edges, it should not be used for WS collapse
* Used for int, short, byte
*/
private static class CharSeqTrimWS
implements CharSequence
{
final static int XMLWHITESPACE_PRESERVE = 1;
final static int XMLWHITESPACE_TRIM = 2;
private static int INITIAL_SIZE = 100;
private char[] _buf = new char[INITIAL_SIZE];
private int _start, _length = 0;
private int _nonWSStart = 0;
private int _nonWSEnd = 0;
private String _toStringValue;
private XMLStreamReaderExtImpl _xmlSteam;
//private boolean _supportForGetTextCharacters = true;
private final ExtLocation _location;
private boolean _hasText;
CharSeqTrimWS(XMLStreamReaderExtImpl xmlSteam)
{
_xmlSteam = xmlSteam;
_location = new ExtLocation();
}
void reload(int style)
throws XMLStreamException
{
_toStringValue = null;
_location.reset();
_hasText = false;
fillBuffer();
if (style==XMLWHITESPACE_PRESERVE)
{
_nonWSStart = 0;
_nonWSEnd = _length;
// takes defaultValue only if there wasn't any text
if (!_hasText && _xmlSteam._defaultValue!=null)
{
_length = 0;
fillBufferFromString(_xmlSteam._defaultValue);
}
}
else if (style==XMLWHITESPACE_TRIM)
{
for (_nonWSStart=0; _nonWSStart<_length; _nonWSStart++)
if (!XMLChar.isSpace(_buf[_nonWSStart]))
break;
for (_nonWSEnd=_length; _nonWSEnd>_nonWSStart; _nonWSEnd--)
if (!XMLChar.isSpace(_buf[_nonWSEnd-1]))
break;
// takes defaultValue if length after triming is 0
if (length()==0 && _xmlSteam._defaultValue!=null)
{
_length = 0;
fillBufferFromString(_xmlSteam._defaultValue);
//apply whispace rule on the default value
for (_nonWSStart=0; _nonWSStart<_length; _nonWSStart++)
if (!XMLChar.isSpace(_buf[_nonWSStart]))
break;
for (_nonWSEnd=_length; _nonWSEnd>_nonWSStart; _nonWSEnd--)
if (!XMLChar.isSpace(_buf[_nonWSEnd-1]))
break;
}
}
_xmlSteam._defaultValue = null;
}
private void fillBuffer()
throws XMLStreamException
{
_length = 0;
if (_xmlSteam.getEventType() == XMLStreamReader.START_DOCUMENT)
_xmlSteam.next();
if (_xmlSteam.isStartElement())
_xmlSteam.next();
int depth = 0;
String error = null;
int eventType = _xmlSteam.getEventType();
loop:
while(true)
{
switch(eventType)
{
case XMLStreamReader.CDATA:
case XMLStreamReader.CHARACTERS:
case XMLStreamReader.SPACE:
_location.set(_xmlSteam.getLocation());
if (depth==0)
addTextToBuffer();
break;
case XMLStreamReader.ATTRIBUTE:
case XMLStreamReader.COMMENT:
case XMLStreamReader.DTD:
case XMLStreamReader.ENTITY_DECLARATION:
case XMLStreamReader.NAMESPACE:
case XMLStreamReader.NOTATION_DECLARATION:
case XMLStreamReader.PROCESSING_INSTRUCTION:
case XMLStreamReader.START_DOCUMENT:
// ignore
break;
case XMLStreamReader.END_DOCUMENT:
_location.set(_xmlSteam.getLocation());
break loop;
case XMLStreamReader.END_ELEMENT:
_location.set(_xmlSteam.getLocation());
depth--;
if (depth<0)
break loop;
break;
case XMLStreamReader.ENTITY_REFERENCE:
_location.set(_xmlSteam.getLocation());
addEntityToBuffer();
break;
case XMLStreamReader.START_ELEMENT:
depth++;
error = "Unexpected element '" + _xmlSteam.getName() + "' in text content.";
_location.set(_xmlSteam.getLocation());
break;
}
eventType = _xmlSteam.next();
}
if (error!=null)
throw new XMLStreamException(error);
}
private void ensureBufferLength(int lengthToAdd)
{
if (_length + lengthToAdd>_buf.length)
{
char[] newBuf = new char[_length + lengthToAdd];
if (_length>0)
System.arraycopy(_buf, 0, newBuf, 0, _length);
_buf = newBuf;
}
}
private void fillBufferFromString(CharSequence value)
{
int textLength = value.length();
ensureBufferLength(textLength);
for (int i=0; i<textLength; i++)
{
_buf[i] = value.charAt(i);
}
_length = textLength;
}
private void addTextToBuffer()
{
_hasText = true;
int textLength = _xmlSteam.getTextLength();
ensureBufferLength(textLength);
/*
Commented out as part of the receipt of the more up to date
jsr173_1.0_ri.jar. getTextCharacters(int, char[], int, int)
used to throw UnsupportedOperationException always. Now it no longer
does, but getTextCharacters(int, char[], int, int) does not return what
we expect. So reverting to always calling getTextCharacters() until
we can work out whether it's us that's wrong or them.
if (_supportForGetTextCharacters)
try
{
_length = _xmlSteam.getTextCharacters(0, _buf, _length, textLength);
}
catch(Exception e)
{
_supportForGetTextCharacters = false;
}
*/
// if(!_supportForGetTextCharacters)
//{
System.arraycopy(_xmlSteam.getTextCharacters(), _xmlSteam.getTextStart(), _buf, _length, textLength);
_length = _length + textLength;
//}
}
private void addEntityToBuffer()
{
String text = _xmlSteam.getText();
int textLength = text.length();
ensureBufferLength(textLength);
text.getChars(0, text.length(), _buf, _length);
_length = _length + text.length();
}
CharSequence reloadAtt(int index, int style)
throws XMLStreamException
{
_location.reset();
_location.set(_xmlSteam.getLocation());
String value = _xmlSteam.getAttributeValue(index);
if (value==null && _xmlSteam._defaultValue!=null)
value = _xmlSteam._defaultValue;
_xmlSteam._defaultValue = null;
int length = value.length();
if (style==XMLWHITESPACE_PRESERVE)
{
return value;
}
else if (style==XMLWHITESPACE_TRIM)
{
int nonWSStart, nonWSEnd;
for (nonWSStart=0; nonWSStart<length; nonWSStart++)
if (!XMLChar.isSpace(value.charAt(nonWSStart)))
break;
for (nonWSEnd=length; nonWSEnd>nonWSStart; nonWSEnd--)
if (!XMLChar.isSpace(value.charAt(nonWSEnd-1)))
break;
if (nonWSStart==0 && nonWSEnd==length)
return value;
else
return value.subSequence(nonWSStart, nonWSEnd);
}
throw new IllegalStateException("unknown style");
}
CharSequence reloadAtt(String uri, String local, int style)
throws XMLStreamException
{
_location.reset();
_location.set(_xmlSteam.getLocation());
String value = _xmlSteam.getAttributeValue(uri, local);
if (value==null && _xmlSteam._defaultValue!=null)
value = _xmlSteam._defaultValue;
_xmlSteam._defaultValue = null;
int length = value.length();
if (style==XMLWHITESPACE_PRESERVE)
{
return value;
}
else if (style==XMLWHITESPACE_TRIM)
{
for (_nonWSStart=0; _nonWSStart<length; _nonWSStart++)
if (!XMLChar.isSpace(value.charAt(_nonWSStart)))
break;
for (_nonWSEnd=length; _nonWSEnd>_nonWSStart; _nonWSEnd--)
if (!XMLChar.isSpace(value.charAt(_nonWSEnd-1)))
break;
if (_nonWSStart==0 && _nonWSEnd==length)
return value;
else
return value.subSequence(_nonWSStart, _nonWSEnd);
}
throw new IllegalStateException("unknown style");
}
Location getLocation()
{
ExtLocation loc = new ExtLocation();
loc.set(_location);
return loc;
}
public int length()
{
return _nonWSEnd - _nonWSStart;
}
public char charAt(int index)
{
// for each char, this has to be fast, using assert instead of if throw
assert (index<_nonWSEnd-_nonWSStart && -1<index) :
"Index " + index + " must be >-1 and <" + (_nonWSEnd - _nonWSStart);
return _buf[_nonWSStart + index];
}
public CharSequence subSequence(int start, int end)
{
return new String(_buf, _nonWSStart + start, end - start);
}
public String toString()
{
if (_toStringValue!=null)
return _toStringValue;
_toStringValue = new String(_buf, _nonWSStart, _nonWSEnd - _nonWSStart);
return _toStringValue;
}
private static class ExtLocation implements Location
{
private int _line;
private int _col;
private int _off;
private String _pid;
private String _sid;
private boolean _isSet;
ExtLocation()
{
_isSet = false;
}
public int getLineNumber()
{
if (_isSet)
return _line;
else
throw new IllegalStateException();
}
public int getColumnNumber()
{
if (_isSet)
return _col;
else
throw new IllegalStateException();
}
public int getCharacterOffset()
{
if (_isSet)
return _off;
else
throw new IllegalStateException();
}
public String getPublicId()
{
if (_isSet)
return _pid;
else
throw new IllegalStateException();
}
public String getSystemId()
{
if (_isSet)
return _sid;
else
throw new IllegalStateException();
}
void set(Location loc)
{
if (_isSet)
return;
_isSet = true;
_line = loc.getLineNumber();
_col = loc.getColumnNumber();
_off = loc.getCharacterOffset();
_pid = loc.getPublicId();
_sid = loc.getSystemId();
}
void reset()
{
_isSet = false;
}
}
}
// XMLStreamReader methods
public Object getProperty(String s)
throws IllegalArgumentException
{
return _xmlStream.getProperty(s);
}
public int next()
throws XMLStreamException
{
return _xmlStream.next();
}
public void require(int i, String s, String s1)
throws XMLStreamException
{
_xmlStream.require(i, s, s1);
}
public String getElementText() throws XMLStreamException
{
return _xmlStream.getElementText();
}
public int nextTag() throws XMLStreamException
{
return _xmlStream.nextTag();
}
public boolean hasNext() throws XMLStreamException
{
return _xmlStream.hasNext();
}
public void close() throws XMLStreamException
{
_xmlStream.close();
}
public String getNamespaceURI(String s)
{
return _xmlStream.getNamespaceURI(s);
}
public boolean isStartElement()
{
return _xmlStream.isStartElement();
}
public boolean isEndElement()
{
return _xmlStream.isEndElement();
}
public boolean isCharacters()
{
return _xmlStream.isCharacters();
}
public boolean isWhiteSpace()
{
return _xmlStream.isWhiteSpace();
}
public String getAttributeValue(String s, String s1)
{
return _xmlStream.getAttributeValue(s, s1);
}
public int getAttributeCount()
{
return _xmlStream.getAttributeCount();
}
public QName getAttributeName(int i)
{
return _xmlStream.getAttributeName(i);
}
public String getAttributeNamespace(int i)
{
return _xmlStream.getAttributeNamespace(i);
}
public String getAttributeLocalName(int i)
{
return _xmlStream.getAttributeLocalName(i);
}
public String getAttributePrefix(int i)
{
return _xmlStream.getAttributePrefix(i);
}
public String getAttributeType(int i)
{
return _xmlStream.getAttributeType(i);
}
public String getAttributeValue(int i)
{
return _xmlStream.getAttributeValue(i);
}
public boolean isAttributeSpecified(int i)
{
return _xmlStream.isAttributeSpecified(i);
}
public int getNamespaceCount()
{
return _xmlStream.getNamespaceCount();
}
public String getNamespacePrefix(int i)
{
return _xmlStream.getNamespacePrefix(i);
}
public String getNamespaceURI(int i)
{
return _xmlStream.getNamespaceURI(i);
}
public NamespaceContext getNamespaceContext()
{
return _xmlStream.getNamespaceContext();
}
public int getEventType()
{
return _xmlStream.getEventType();
}
public String getText()
{
return _xmlStream.getText();
}
public char[] getTextCharacters()
{
return _xmlStream.getTextCharacters();
}
public int getTextCharacters(int i, char[] chars, int i1, int i2)
throws XMLStreamException
{
return _xmlStream.getTextCharacters(i, chars, i1, i2);
}
public int getTextStart()
{
return _xmlStream.getTextStart();
}
public int getTextLength()
{
return _xmlStream.getTextLength();
}
public String getEncoding()
{
return _xmlStream.getEncoding();
}
public boolean hasText()
{
return _xmlStream.hasText();
}
public Location getLocation()
{
return _xmlStream.getLocation();
}
public QName getName()
{
return _xmlStream.getName();
}
public String getLocalName()
{
return _xmlStream.getLocalName();
}
public boolean hasName()
{
return _xmlStream.hasName();
}
public String getNamespaceURI()
{
return _xmlStream.getNamespaceURI();
}
public String getPrefix()
{
return _xmlStream.getPrefix();
}
public String getVersion()
{
return _xmlStream.getVersion();
}
public boolean isStandalone()
{
return _xmlStream.isStandalone();
}
public boolean standaloneSet()
{
return _xmlStream.standaloneSet();
}
public String getCharacterEncodingScheme()
{
return _xmlStream.getCharacterEncodingScheme();
}
public String getPITarget()
{
return _xmlStream.getPITarget();
}
public String getPIData()
{
return _xmlStream.getPIData();
}
}