net.sf.saxon.event

Class ContentHandlerProxy

public class ContentHandlerProxy extends Object implements Receiver

A ContentHandlerProxy is a Receiver that converts events into the form expected by an underlying SAX2 ContentHandler. Relevant events (notably comments) can also be fed to a LexicalHandler.

Note that in general the output passed to a Receiver corresponds to an External General Parsed Entity. A SAX2 ContentHandler only expects to deal with well-formed XML documents, so we only pass it the contents of the first element encountered, unless the saxon:require-well-formed output property is set to "no".

This ContentHandlerProxy provides no access to type information. For a ContentHandler that makes type information available, see com.saxonica.jaxp.TypedContentHandler

The ContentHandlerProxy can also be nominated as a TraceListener, to receive notification of trace events. This will be done automatically if the option setTraceListener(
Nested Class Summary
classContentHandlerProxy.ContentHandlerProxyTraceListener
Create a TraceListener that will collect information about the current location in the source document.
Field Summary
protected ContentHandlerhandler
protected LexicalHandlerlexicalHandler
protected AttributeCollectionImplpendingAttributes
Method Summary
voidattribute(int nameCode, int typeCode, CharSequence value, int locationId, int properties)
Notify an attribute.
voidcharacters(CharSequence chars, int locationId, int properties)
Character data
voidclose()
Notify the end of the event stream
voidcomment(CharSequence chars, int locationId, int properties)
Output a comment.
voidendDocument()
Notify the end of the document
voidendElement()
End of element
ConfigurationgetConfiguration()
Get the Saxon configuration
longgetCurrentLocationId()
Get the current location identifier
LocationProvidergetLocationProvider()
Get the location provider
PipelineConfigurationgetPipelineConfiguration()
Get the pipeline configuration
StringgetSystemId()
Get the System ID of the destination tree
ContentHandlerProxy.ContentHandlerProxyTraceListenergetTraceListener()
Get the associated TraceListener that receives notification of trace events
ContentHandlergetUnderlyingContentHandler()
Get the underlying content handler
booleanisRequireWellFormed()
Ask whether the content handler can handle a stream of events that is merely well-balanced, or whether it can only handle a well-formed sequence.
booleanisUndeclareNamespaces()
Ask whether namespace undeclaration events (for a non-null prefix) should be notified.
voidnamespace(int namespaceCode, int properties)
Notify a namespace.
protected voidnotifyNotWellFormed()
The following function is called when it is found that the output is not a well-formed document.
voidopen()
Notify the start of the event stream
voidprocessingInstruction(String target, CharSequence data, int locationId, int properties)
Processing Instruction
voidsetLexicalHandler(LexicalHandler handler)
Set the Lexical Handler to be used.
voidsetOutputProperties(Properties details)
Set the output details.
voidsetPipelineConfiguration(PipelineConfiguration pipe)
Set the pipeline configuration
voidsetRequireWellFormed(boolean wellFormed)
Set whether the content handler can handle a stream of events that is merely well-balanced, or whether it can only handle a well-formed sequence.
voidsetSystemId(String systemId)
Set the System ID of the destination tree
voidsetUndeclareNamespaces(boolean undeclareNamespaces)
Set whether namespace undeclaration events (for a non-null prefix) should be notified.
voidsetUnderlyingContentHandler(ContentHandler handler)
Set the underlying content handler.
voidsetUnparsedEntity(String name, String systemID, String publicID)
Notify an unparsed entity URI.
voidstartContent()
Notify the start of the content, that is, the completion of all attributes and namespaces.
voidstartDocument(int properties)
Notify the start of the document.
voidstartElement(int nameCode, int typeCode, int locationId, int properties)
Notify the start of an element
booleanusesTypeAnnotations()
Ask whether this Receiver (or the downstream pipeline) makes any use of the type annotations supplied on element and attribute events

Field Detail

handler

protected ContentHandler handler

lexicalHandler

protected LexicalHandler lexicalHandler

pendingAttributes

protected AttributeCollectionImpl pendingAttributes

Method Detail

attribute

public void attribute(int nameCode, int typeCode, CharSequence value, int locationId, int properties)
Notify an attribute. Attributes are notified after the startElement event, and before any children.

characters

public void characters(CharSequence chars, int locationId, int properties)
Character data

close

public void close()
Notify the end of the event stream

comment

public void comment(CharSequence chars, int locationId, int properties)
Output a comment. Passes it on to the ContentHandler provided that the ContentHandler is also a SAX2 LexicalHandler.

endDocument

public void endDocument()
Notify the end of the document

endElement

public void endElement()
End of element

getConfiguration

public Configuration getConfiguration()
Get the Saxon configuration

Returns: the Saxon configuration

getCurrentLocationId

public long getCurrentLocationId()
Get the current location identifier

Returns: the location identifier of the most recent event. This can be translated to real location information by passing it to the location provider.

getLocationProvider

public LocationProvider getLocationProvider()
Get the location provider

Returns: the location provider, used to map location ids to actual URIs and line numbers

getPipelineConfiguration

public PipelineConfiguration getPipelineConfiguration()
Get the pipeline configuration

getSystemId

public String getSystemId()
Get the System ID of the destination tree

Returns: the system ID (effectively the base URI)

getTraceListener

public ContentHandlerProxy.ContentHandlerProxyTraceListener getTraceListener()
Get the associated TraceListener that receives notification of trace events

Returns: the trace listener. If there is no existing trace listener, then a new one will be created.

getUnderlyingContentHandler

public ContentHandler getUnderlyingContentHandler()
Get the underlying content handler

Returns: the SAX content handler to which all events are being directed

isRequireWellFormed

public boolean isRequireWellFormed()
Ask whether the content handler can handle a stream of events that is merely well-balanced, or whether it can only handle a well-formed sequence.

Returns: true if the content handler requires the event stream to represent a well-formed XML document (containing exactly one top-level element node and no top-level text nodes)

isUndeclareNamespaces

public boolean isUndeclareNamespaces()
Ask whether namespace undeclaration events (for a non-null prefix) should be notified. The default is no, because some ContentHandlers (e.g. JDOM) can't cope with them.

Returns: true if namespace undeclarations (xmlns:p="") are to be output

namespace

public void namespace(int namespaceCode, int properties)
Notify a namespace. Namespaces are notified after the startElement event, and before any children for the element.

notifyNotWellFormed

protected void notifyNotWellFormed()
The following function is called when it is found that the output is not a well-formed document. Unless the ContentHandler accepts "balanced content", this is a fatal error.

open

public void open()
Notify the start of the event stream

processingInstruction

public void processingInstruction(String target, CharSequence data, int locationId, int properties)
Processing Instruction

setLexicalHandler

public void setLexicalHandler(LexicalHandler handler)
Set the Lexical Handler to be used. If called, this must be called AFTER setUnderlyingContentHandler()

Parameters: handler the SAX lexical handler to which lexical events (such as comments) will be notified.

setOutputProperties

public void setOutputProperties(Properties details)
Set the output details.

Parameters: details the serialization properties. The only values used by this implementation are REQUIRE_WELL_FORMED and UNDECLARE_PREFIXES.

setPipelineConfiguration

public void setPipelineConfiguration(PipelineConfiguration pipe)
Set the pipeline configuration

Parameters: pipe the pipeline configuration

setRequireWellFormed

public void setRequireWellFormed(boolean wellFormed)
Set whether the content handler can handle a stream of events that is merely well-balanced, or whether it can only handle a well-formed sequence. The default is false.

Parameters: wellFormed set to true if the content handler requires the event stream to represent a well-formed XML document (containing exactly one top-level element node and no top-level text nodes). Otherwise, multiple top-level elements and text nodes are allowed, as in the XDM model.

setSystemId

public void setSystemId(String systemId)
Set the System ID of the destination tree

Parameters: systemId the system ID (effectively the base URI)

setUndeclareNamespaces

public void setUndeclareNamespaces(boolean undeclareNamespaces)
Set whether namespace undeclaration events (for a non-null prefix) should be notified. The default is no, because some ContentHandlers (e.g. JDOM) can't cope with them.

Parameters: undeclareNamespaces true if namespace undeclarations (xmlns:p="") are to be output

setUnderlyingContentHandler

public void setUnderlyingContentHandler(ContentHandler handler)
Set the underlying content handler. This call is mandatory before using this Receiver. If the content handler is an instance of LexicalHandler, then it will also receive notification of lexical events such as comments.

Parameters: handler the SAX content handler to which all events will be directed

setUnparsedEntity

public void setUnparsedEntity(String name, String systemID, String publicID)
Notify an unparsed entity URI. This implementation does nothing: the event is ignored.

Parameters: name The name of the unparsed entity systemID The system identifier of the unparsed entity publicID The public identifier of the unparsed entity

startContent

public void startContent()
Notify the start of the content, that is, the completion of all attributes and namespaces. Note that the initial receiver of output from XSLT instructions will not receive this event, it has to detect it itself. Note that this event is reported for every element even if it has no attributes, no namespaces, and no content.

startDocument

public void startDocument(int properties)
Notify the start of the document.

startElement

public void startElement(int nameCode, int typeCode, int locationId, int properties)
Notify the start of an element

usesTypeAnnotations

public boolean usesTypeAnnotations()
Ask whether this Receiver (or the downstream pipeline) makes any use of the type annotations supplied on element and attribute events

Returns: true if the Receiver makes any use of this information. If false, the caller may supply untyped nodes instead of supplying the type annotation