public XMLStreamReaderExtImpl(XMLStreamReader xmlStream) 
{
        if (xmlStream==null)
            throw new IllegalArgumentException();
        _xmlStream = xmlStream;
        _charSeq = new CharSeqTrimWS(this);
}

 public  void close() throws XMLStreamException 
{
        _xmlStream.close();
}

 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 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 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 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 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 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 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 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(int index) throws XMLStreamException 
{
        try
        {
            return XsTypeConverter.lexByte(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
        }
        catch(NumberFormatException 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 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 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 int getAttributeCount() 
{
        return _xmlStream.getAttributeCount();
}

 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 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 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 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 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 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 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 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(int index) throws XMLStreamException 
{
        try
        {
            return new GDuration(_charSeq.reloadAtt(index, CharSeqTrimWS.XMLWHITESPACE_TRIM));
        }
        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 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 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 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 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 String getAttributeLocalName(int i) 
{
        return _xmlStream.getAttributeLocalName(i);
}

 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 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 QName getAttributeName(int i) 
{
        return _xmlStream.getAttributeName(i);
}

 public String getAttributeNamespace(int i) 
{
        return _xmlStream.getAttributeNamespace(i);
}

 public String getAttributePrefix(int i) 
{
        return _xmlStream.getAttributePrefix(i);
}

 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 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 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 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 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 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 String getAttributeType(int i) 
{
        return _xmlStream.getAttributeType(i);
}

 public String getAttributeValue(int i) 
{
        return _xmlStream.getAttributeValue(i);
}

 public String getAttributeValue(String s,
    String s1) 
{
        return _xmlStream.getAttributeValue(s, s1);
}

 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 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 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 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 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 String getCharacterEncodingScheme() 
{
        return _xmlStream.getCharacterEncodingScheme();
}

 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 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 String getElementText() throws XMLStreamException 
{
        return _xmlStream.getElementText();
}

 public String getEncoding() 
{
        return _xmlStream.getEncoding();
}

 public int getEventType() 
{
        return _xmlStream.getEventType();
}

 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 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 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 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 String getLocalName() 
{
        return _xmlStream.getLocalName();
}

 public Location getLocation() 
{
        return _xmlStream.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 QName getName() 
{
        return _xmlStream.getName();
}

 public NamespaceContext getNamespaceContext() 
{
        return _xmlStream.getNamespaceContext();
}

 public int getNamespaceCount() 
{
        return _xmlStream.getNamespaceCount();
}

 public String getNamespacePrefix(int i) 
{
        return _xmlStream.getNamespacePrefix(i);
}

 public String getNamespaceURI() 
{
        return _xmlStream.getNamespaceURI();
}

 public String getNamespaceURI(String s) 
{
        return _xmlStream.getNamespaceURI(s);
}

 public String getNamespaceURI(int i) 
{
        return _xmlStream.getNamespaceURI(i);
}

 public String getPIData() 
{
        return _xmlStream.getPIData();
}

 public String getPITarget() 
{
        return _xmlStream.getPITarget();
}

 public String getPrefix() 
{
        return _xmlStream.getPrefix();
}

 public Object getProperty(String s) throws IllegalArgumentException 
{
        return _xmlStream.getProperty(s);
}

 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 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 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 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 getTextLength() 
{
        return _xmlStream.getTextLength();
}

 public int getTextStart() 
{
        return _xmlStream.getTextStart();
}

 public XMLStreamReader getUnderlyingXmlStream() 
{
        return _xmlStream;
}

 public String getVersion() 
{
        return _xmlStream.getVersion();
}

 public boolean hasName() 
{
        return _xmlStream.hasName();
}

 public boolean hasNext() throws XMLStreamException 
{
        return _xmlStream.hasNext();
}

 public boolean hasText() 
{
        return _xmlStream.hasText();
}

 public boolean isAttributeSpecified(int i) 
{
        return _xmlStream.isAttributeSpecified(i);
}

 public boolean isCharacters() 
{
        return _xmlStream.isCharacters();
}

 public boolean isEndElement() 
{
        return _xmlStream.isEndElement();
}

 public boolean isStandalone() 
{
        return _xmlStream.isStandalone();
}

 public boolean isStartElement() 
{
        return _xmlStream.isStartElement();
}

 public boolean isWhiteSpace() 
{
        return _xmlStream.isWhiteSpace();
}

 public int next() throws XMLStreamException 
{
        return _xmlStream.next();
}

 public int nextTag() throws XMLStreamException 
{
        return _xmlStream.nextTag();
}

 public  void require(int i,
    String s,
    String s1) throws XMLStreamException 
{
        _xmlStream.require(i, s, s1);
}

 public  void setDefaultValue(String defaultValue) throws XMLStreamException 
{
        _defaultValue = defaultValue;
}

 public boolean standaloneSet() 
{
        return _xmlStream.standaloneSet();
}