## com.icl.saxon.output
Class ContentHandlerProxy

    java.lang.Object
      com.icl.saxon.output.Emitter
          com.icl.saxon.output.ContentHandlerProxy

All Implemented Interfaces:
  org.xml.sax.Locator, Result

public class ContentHandlerProxy
extends Emitter
implements org.xml.sax.Locator

A ContentHandlerProxy is an Emitter that filters data before passing it to an underlying SAX2 ContentHandler. Relevant events (notably comments) can also be fed to a LexicalHandler. Note that in general the output passed to an Emitter 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.

Field Summary
`protected org.xml.sax.ContentHandler` `handler`
`protected org.xml.sax.ext.LexicalHandler` `lexicalHandler`
`protected org.xml.sax.Locator` `locator`
`protected boolean` `requireWellFormed`

Fields inherited from class com.icl.saxon.output.Emitter
`namePool, outputProperties, outputStream, systemId, writer`

Fields inherited from interface javax.xml.transform.Result
`PI_DISABLE_OUTPUT_ESCAPING, PI_ENABLE_OUTPUT_ESCAPING`

Constructor Summary
`ContentHandlerProxy()`

Method Summary
`void` `characters(char[] chars, int start, int len)` Character data
`void` `comment(char[] ch, int start, int length)` Output a comment.
`void` `endDocument()` End of document
`void` `endElement(int nameCode)` End of element
`int` `getColumnNumber()`
`int` `getLineNumber()`
`java.lang.String` `getPublicId()`
`protected void` `notifyNotWellFormed()` The following function notifies the content handler, by means of a processing instruction, that the output is not a well-formed document.
`void` `processingInstruction(java.lang.String target, java.lang.String data)` Processing Instruction
`void` `setDocumentLocator(org.xml.sax.Locator locator)` Set Document Locator
`void` `setEscaping(boolean escaping)` Switch escaping on or off.
`void` `setLexicalHandler(org.xml.sax.ext.LexicalHandler handler)` Set the Lexical Handler to be used.
`void` `setRequireWellFormed(boolean wellFormed)` Indicate 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.
`void` `setUnderlyingContentHandler(org.xml.sax.ContentHandler handler)` Set the underlying content handler.
`void` `startDocument()` Start of document
`void` `startElement(int nameCode, org.xml.sax.Attributes atts, int[] namespaces, int nscount)` Start of element

Methods inherited from class com.icl.saxon.output.Emitter
`getNamePool, getOutputProperties, getOutputStream, getSystemId, getWriter, makeEmitter, setNamePool, setOutputProperties, setOutputStream, setSystemId, setUnparsedEntity, setWriter, usesWriter`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface org.xml.sax.Locator
`getSystemId`

Field Detail

### handler

    protected org.xml.sax.ContentHandler handler

### lexicalHandler

    protected org.xml.sax.ext.LexicalHandler lexicalHandler

### locator

    protected org.xml.sax.Locator locator

### requireWellFormed

    protected boolean requireWellFormed

Constructor Detail

### ContentHandlerProxy

    public ContentHandlerProxy()

Method Detail

### setUnderlyingContentHandler

    public void setUnderlyingContentHandler(org.xml.sax.ContentHandler handler)

  Set the underlying content handler. This call is mandatory before using the Emitter.

### setLexicalHandler

    public void setLexicalHandler(org.xml.sax.ext.LexicalHandler handler)

  Set the Lexical Handler to be used. If called, this must be called AFTER setUnderlyingContentHandler()

### setRequireWellFormed

    public void setRequireWellFormed(boolean wellFormed)

  Indicate 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.

### setDocumentLocator

    public void setDocumentLocator(org.xml.sax.Locator locator)

  Set Document Locator

  Overrides:
    `setDocumentLocator` in class `Emitter`

### startDocument

    public void startDocument()
                       throws TransformerException

  Start of document

  Specified by:
    `startDocument` in class `Emitter`
  Throws:
    `TransformerException`

### endDocument

    public void endDocument()
                     throws TransformerException

  End of document

  Specified by:
    `endDocument` in class `Emitter`
  Throws:
    `TransformerException`

### startElement

    public void startElement(int nameCode,
                             org.xml.sax.Attributes atts,
                             int[] namespaces,
                             int nscount)
                      throws TransformerException

  Start of element

  Specified by:
    `startElement` in class `Emitter`
  Parameters:
    `namespaces` - Array of namespace codes identifying the namespace prefix/uri pairs associated with this element
    `nscount` - Number of significant entries within namespaces array
  Throws:
    `TransformerException`

### endElement

    public void endElement(int nameCode)
                    throws TransformerException

  End of element

  Specified by:
    `endElement` in class `Emitter`
  Throws:
    `TransformerException`

### characters

    public void characters(char[] chars,
                           int start,
                           int len)
                    throws TransformerException

  Character data

  Specified by:
    `characters` in class `Emitter`
  Throws:
    `TransformerException`

### notifyNotWellFormed

    protected void notifyNotWellFormed()
                                throws org.xml.sax.SAXException

  The following function notifies the content handler, by means of a processing instruction, that the output is not a well-formed document. If the content handler responds with an exception containing the message "continue" (this is the only way it can get information back) then further events are notified, otherwise they are suppressed.

  Throws:
    `org.xml.sax.SAXException`

### processingInstruction

    public void processingInstruction(java.lang.String target,
                                      java.lang.String data)
                               throws TransformerException

  Processing Instruction

  Specified by:
    `processingInstruction` in class `Emitter`
  Throws:
    `TransformerException`

### comment

    public void comment(char[] ch,
                        int start,
                        int length)
                 throws TransformerException

  Output a comment. Passes it on to the ContentHandler provided that the ContentHandler is also a SAX2 LexicalHandler.

  Specified by:
    `comment` in class `Emitter`
  Throws:
    `TransformerException`

### setEscaping

    public void setEscaping(boolean escaping)

  Switch escaping on or off. This is called when the XSLT disable-output-escaping attribute is used to switch escaping on or off. It is not called for other sections of output (e.g. element names) where escaping is inappropriate. The action, as defined in JAXP 1.1, is to notify the request to the Content Handler using a processing instruction.

  Overrides:
    `setEscaping` in class `Emitter`

### getPublicId

    public java.lang.String getPublicId()

  Specified by:
    `getPublicId` in interface `org.xml.sax.Locator`

### getLineNumber

    public int getLineNumber()

  Specified by:
    `getLineNumber` in interface `org.xml.sax.Locator`

### getColumnNumber

    public int getColumnNumber()

  Specified by:
    `getColumnNumber` in interface `org.xml.sax.Locator`