public STAXEventReader() 
{
                   
        this.factory = DocumentFactory.getInstance();
}

Constructs a default STAXEventReader instance with a default DocumentFactory .

 public STAXEventReader(DocumentFactory factory) 
{
        if (factory != null) {
            this.factory = factory;
        } else {
            this.factory = DocumentFactory.getInstance();
        }
}

Constructs a STAXEventReader instance that uses the specified DocumentFactory to construct DOM4J Node s.

Parameters:

factory - The DocumentFactory to use when constructing DOM4J nodes, or null if a default should be used.

 public Attribute createAttribute(Element elem,
    Attribute attr) 
{
        return factory.createAttribute(elem, createQName(attr.getName()), attr
                .getValue());
}

Constructs a new DOM4J Attribute from the provided StAX Attribute event.

 public CharacterData createCharacterData(Characters characters) 
{
        String data = characters.getData();
        if (characters.isCData()) {
            return factory.createCDATA(data);
        } else {
            return factory.createText(data);
        }
}

Constructs a new DOM4J Text or CDATA object from the provided Characters event.

 public Comment createComment(Comment comment) 
{
        return factory.createComment(comment.getText());
}

Constructs a new DOM4J Comment from the provided StAX Comment event.

 public Element createElement(StartElement startEvent) 
{
        QName qname = startEvent.getName();
        org.dom4j.QName elemName = createQName(qname);
        Element elem = factory.createElement(elemName);
        // create attributes
        for (Iterator i = startEvent.getAttributes(); i.hasNext();) {
            Attribute attr = (Attribute) i.next();
            elem.addAttribute(createQName(attr.getName()), attr.getValue());
        }
        // create namespaces
        for (Iterator i = startEvent.getNamespaces(); i.hasNext();) {
            Namespace ns = (Namespace) i.next();
            elem.addNamespace(ns.getPrefix(), ns.getNamespaceURI());
        }
        return elem;
}

Constructs a new DOM4J Element from the provided StartElement event. All attributes and namespaces will be added to the returned element.

 public Entity createEntity(EntityReference entityRef) 
{
        return factory.createEntity(entityRef.getName(), entityRef
                .getDeclaration().getReplacementText());
}

Constructs a new DOM4J Entity from the provided StAX EntityReference event.

 public Namespace createNamespace(Namespace ns) 
{
        return factory.createNamespace(ns.getPrefix(), ns.getNamespaceURI());
}

Constructs a new DOM4J Namespace from the provided StAX Namespace event.

 public ProcessingInstruction createProcessingInstruction(ProcessingInstruction pi) 
{
        return factory
                .createProcessingInstruction(pi.getTarget(), pi.getData());
}

Constructs a new DOM4J ProcessingInstruction from the provided StAX ProcessingInstruction event.

 public QName createQName(QName qname) 
{
        return factory.createQName(qname.getLocalPart(), qname.getPrefix(),
                qname.getNamespaceURI());
}

Constructs a new DOM4J QName from the provided JAXP QName.

 public Attribute readAttribute(XMLEventReader reader) throws XMLStreamException 
{
        XMLEvent event = reader.peek();
        if (event.isAttribute()) {
            Attribute attr = (Attribute) reader.nextEvent();
            return createAttribute(null, attr);
        } else {
            throw new XMLStreamException("Expected Attribute event, found: "
                    + event);
        }
}

Constructs a DOM4J Attribute from the provided event stream. The stream must be positioned before an Attribute event.

 public CharacterData readCharacters(XMLEventReader reader) throws XMLStreamException 
{
        XMLEvent event = reader.peek();
        if (event.isCharacters()) {
            Characters characters = reader.nextEvent().asCharacters();
            return createCharacterData(characters);
        } else {
            throw new XMLStreamException("Expected Characters event, found: "
                    + event);
        }
}

Constructs a DOM4J Text or CDATA section from the provided event stream. The stream must be positioned before a Characters event.

 public Comment readComment(XMLEventReader reader) throws XMLStreamException 
{
        XMLEvent event = reader.peek();
        if (event instanceof Comment) {
            return createComment((Comment) reader.nextEvent());
        } else {
            throw new XMLStreamException("Expected Comment event, found: "
                    + event);
        }
}

Constructs a DOM4J Comment from the provided event stream. The stream must be positioned before a Comment event.

 public Document readDocument(InputStream is) throws XMLStreamException 
{
        return readDocument(is, null);
}

Constructs a StAX event stream from the provided I/O stream and reads a DOM4J document from it.

 public Document readDocument(Reader reader) throws XMLStreamException 
{
        return readDocument(reader, null);
}

Constructs a StAX event stream from the provided I/O character stream and reads a DOM4J document from it.

 public Document readDocument(XMLEventReader reader) throws XMLStreamException 
{
        Document doc = null;
        while (reader.hasNext()) {
            XMLEvent nextEvent = reader.peek();
            int type = nextEvent.getEventType();
            switch (type) {
                case XMLStreamConstants.START_DOCUMENT:
                    StartDocument event = (StartDocument) reader.nextEvent();
                    if (doc == null) {
                        // create document
                        if (event.encodingSet()) {
                            String encodingScheme = event
                                    .getCharacterEncodingScheme();
                            doc = factory.createDocument(encodingScheme);
                        } else {
                            doc = factory.createDocument();
                        }
                    } else {
                        // duplicate or misplaced xml declaration
                        String msg = "Unexpected StartDocument event";
                        throw new XMLStreamException(msg, event.getLocation());
                    }
                    break;
                case XMLStreamConstants.END_DOCUMENT:
                case XMLStreamConstants.SPACE:
                case XMLStreamConstants.CHARACTERS:
                    // skip end document and space outside the root element
                    reader.nextEvent();
                    break;
                default:
                    if (doc == null) {
                        // create document
                        doc = factory.createDocument();
                    }
                    Node n = readNode(reader);
                    doc.add(n);
            }
        }
        return doc;
}

Reads a DOM4J Document from the provided stream. The stream should be positioned at the start of a document, or before a StartElement event.

 public Document readDocument(InputStream is,
    String systemId) throws XMLStreamException 
{
        XMLEventReader eventReader = inputFactory.createXMLEventReader(
                systemId, is);
        try {
            return readDocument(eventReader);
        } finally {
            eventReader.close();
        }
}

Constructs a StAX event stream from the provided I/O stream and reads a DOM4J document from it.

 public Document readDocument(Reader reader,
    String systemId) throws XMLStreamException 
{
        XMLEventReader eventReader = inputFactory.createXMLEventReader(
                systemId, reader);
        try {
            return readDocument(eventReader);
        } finally {
            eventReader.close();
        }
}

Constructs a StAX event stream from the provided I/O character stream and reads a DOM4J document from it.

 public Element readElement(XMLEventReader eventReader) throws XMLStreamException 
{
        XMLEvent event = eventReader.peek();
        if (event.isStartElement()) {
            // advance the reader and get the StartElement event
            StartElement startTag = eventReader.nextEvent().asStartElement();
            Element elem = createElement(startTag);
            // read element content
            while (true) {
                if (!eventReader.hasNext()) {
                    String msg = "Unexpected end of stream while reading"
                            + " element content";
                    throw new XMLStreamException(msg);
                }
                XMLEvent nextEvent = eventReader.peek();
                if (nextEvent.isEndElement()) {
                    EndElement endElem = eventReader.nextEvent().asEndElement();
                    if (!endElem.getName().equals(startTag.getName())) {
                        throw new XMLStreamException("Expected "
                                + startTag.getName() + " end-tag, but found"
                                + endElem.getName());
                    }
                    break;
                }
                Node child = readNode(eventReader);
                elem.add(child);
            }
            return elem;
        } else {
            throw new XMLStreamException("Expected Element event, found: "
                    + event);
        }
}

Reads a DOM4J Element from the provided event stream. The stream must be positioned before an StartElement event. In addition to the initial start event, all events up to and including the closing EndElement will be read, and included with the returned element.

 public Entity readEntityReference(XMLEventReader reader) throws XMLStreamException 
{
        XMLEvent event = reader.peek();
        if (event.isEntityReference()) {
            EntityReference entityRef = (EntityReference) reader.nextEvent();
            return createEntity(entityRef);
        } else {
            throw new XMLStreamException("Expected EntityRef event, found: "
                    + event);
        }
}

Constructs a DOM4J Entity from the provided event stream. The stream must be positioned before an EntityReference event.

 public Namespace readNamespace(XMLEventReader reader) throws XMLStreamException 
{
        XMLEvent event = reader.peek();
        if (event.isNamespace()) {
            Namespace ns = (Namespace) reader.nextEvent();
            return createNamespace(ns);
        } else {
            throw new XMLStreamException("Expected Namespace event, found: "
                    + event);
        }
}

Constructs a DOM4J Namespace from the provided event stream. The stream must be positioned before a Namespace event.

 public Node readNode(XMLEventReader reader) throws XMLStreamException 
{
        XMLEvent event = reader.peek();
        if (event.isStartElement()) {
            return readElement(reader);
        } else if (event.isCharacters()) {
            return readCharacters(reader);
        } else if (event.isStartDocument()) {
            return readDocument(reader);
        } else if (event.isProcessingInstruction()) {
            return readProcessingInstruction(reader);
        } else if (event.isEntityReference()) {
            return readEntityReference(reader);
        } else if (event.isAttribute()) {
            return readAttribute(reader);
        } else if (event.isNamespace()) {
            return readNamespace(reader);
        } else {
            throw new XMLStreamException("Unsupported event: " + event);
        }
}

Reads a Node from the event stream. If the next event is a StartElement , all events until the closing EndElement will be read, and the resulting nodes will be added to the returned Element .

Pre-Conditions : The stream must be positioned before an event other than an EndElement,EndDocument, or any DTD-related events, which are not currently supported.

 public ProcessingInstruction readProcessingInstruction(XMLEventReader reader) throws XMLStreamException 
{
        XMLEvent event = reader.peek();
        if (event.isProcessingInstruction()) {
            ProcessingInstruction pi = (ProcessingInstruction) reader
                    .nextEvent();
            return createProcessingInstruction(pi);
        } else {
            throw new XMLStreamException("Expected PI event, found: " + event);
        }
}

Constructs a DOM4J ProcessingInstruction from the provided event stream. The stream must be positioned before a ProcessingInstruction event.

 public  void setDocumentFactory(DocumentFactory documentFactory) 
{
        if (documentFactory != null) {
            this.factory = documentFactory;
        } else {
            this.factory = DocumentFactory.getInstance();
        }
}

Sets the DocumentFactory to be used when constructing DOM4J nodes.