public ValidatingXMLInputStream(XMLInputStream xis,
    SchemaTypeLoader typeLoader,
    SchemaType sType,
    XmlOptions options) throws XMLStreamException 
{
        _source = xis;
        // Figure out the root type
        options = XmlOptions.maskNull( options );
        SchemaType type = (SchemaType) options.get( XmlOptions.DOCUMENT_TYPE );
        if (type == null)
            type = sType;
        if (type == null)
        {
            type = BuiltinSchemaTypeSystem.ST_ANY_TYPE;
            xis = xis.getSubStream();
            if (xis.skip( XMLEvent.START_ELEMENT ))
            {
                SchemaType docType =
                    typeLoader.findDocumentType(
                        XMLNameHelper.getQName( xis.next().getName() ) );
                if (docType != null)
                    type = docType;
            }
            xis.close();
        }
        // Create the validator
        _validator =
            new Validator(
                type, null, typeLoader, options, new ExceptionXmlErrorListener() );
        nextEvent( ValidatorListener.BEGIN );
}

 public Location getLocation() 
{
        try
        {
            final org.apache.xmlbeans.xml.stream.Location xeLoc = _source.peek().getLocation();
            if (xeLoc==null)
                return null;
            javax.xml.stream.Location loc = new javax.xml.stream.Location()
            {
                public int getLineNumber()
                { return xeLoc.getLineNumber(); }
                public int getColumnNumber()
                { return xeLoc.getColumnNumber(); }
                public int getCharacterOffset()
                { return -1;}
                public String getPublicId()
                { return xeLoc.getPublicId(); }
                public String getSystemId()
                { return xeLoc.getSystemId(); }
            };
            return loc;
        }
        catch (XMLStreamException e)
        {
            return null;
        }
}

 public XmlCursor getLocationAsCursor() 
{
        return null;
}

 public QName getName() 
{
        return XMLNameHelper.getQName( _name );
}

 public String getNamespaceForPrefix(String prefix) 
{
        if (_startElement == null)
            return null;
        Map map = _startElement.getNamespaceMap();
        if (map == null)
            return null;
        return (String) map.get( prefix );
}

 public String getText() 
{
        return _text.toString();
}

 public String getText(int wsr) 
{
        return XmlWhitespace.collapse( _text.toString(), wsr );
}

 public String getXsiLoc() 
{
        return _xsiLoc;
}

 public String getXsiNil() 
{
        return _xsiNil;
}

 public String getXsiNoLoc() 
{
        return _xsiNoLoc;
}

 public String getXsiType() 
{
        return _xsiType;
}

 protected XMLEvent nextEvent() throws XMLStreamException 
{
        XMLEvent e = _source.next();
        if (e == null)
        {
            if (!_finished)
            {
                flushText();
                nextEvent( ValidatorListener.END );
                _finished = true;
            }
        }
        else
        {
            switch ( e.getType() )
            {
            case XMLEvent.CHARACTER_DATA :
            case XMLEvent.SPACE :
            {
                CharacterData cd = (CharacterData) e;
                if (cd.hasContent())
                    _text.append( cd.getContent() );
                break;
            }
            case XMLEvent.START_ELEMENT :
            {
                StartElement se = (StartElement) e;
                flushText();
                // Used for prefix to namespace mapping
                _startElement = se;
                // Prepare the xsi:* values
                AttributeIterator attrs = se.getAttributes();
                while ( attrs.hasNext() )
                {
                    Attribute attr = attrs.next();
                    XMLName attrName = attr.getName();
                    if ("http://www.w3.org/2001/XMLSchema-instance".equals(
                            attrName.getNamespaceUri() ))
                    {
                        String local = attrName.getLocalName();
                        if (local.equals( "type" ))
                            _xsiType = attr.getValue();
                        else if (local.equals( "nil" ))
                            _xsiNil = attr.getValue();
                        else if (local.equals( "schemaLocation" ))
                            _xsiLoc = attr.getValue();
                        else if (local.equals( "noNamespaceSchemaLocation" ))
                            _xsiNoLoc = attr.getValue();
                    }
                }
                // Emit the START
                // TODO - should delay the aquisition of the name
                _name = e.getName();
                nextEvent( ValidatorListener.BEGIN );
                // Emit the attrs
                attrs = se.getAttributes();
                while ( attrs.hasNext() )
                {
                    Attribute attr = attrs.next();
                    XMLName attrName = attr.getName();
                    if ("http://www.w3.org/2001/XMLSchema-instance".equals(
                            attrName.getNamespaceUri() ))
                    {
                        String local = attrName.getLocalName();
                        if (local.equals( "type" ))
                            continue;
                        else if (local.equals( "nil" ))
                            continue;
                        else if (local.equals( "schemaLocation" ))
                            continue;
                        else if (local.equals( "noNamespaceSchemaLocation" ))
                            continue;
                    }
                    // TODO - God, this is lame :-)
                    _text.append( attr.getValue() );
                    _name = attr.getName();
                    nextEvent( ValidatorListener.ATTR );
                }
                clearText();
                _startElement = null;
                break;
            }
            case XMLEvent.END_ELEMENT :
            {
                flushText();
                nextEvent( ValidatorListener.END );
                break;
            }
            }
        }
        return e;
}

 public boolean textIsWhitespace() 
{
        for ( int i = 0 ; i <  _text.length() ; i++ )
        {
            switch ( _text.charAt( i ) )
            {
                case ' ':
                case '\n':
                case '\r':
                case '\t':
                    break;
                default :
                    return false;
            }
        }
        return true;
}