## com.icl.saxon.output
Class Outputter

    java.lang.Object
      com.icl.saxon.output.Outputter

Direct Known Subclasses:
  GeneralOutputter, StringOutputter

public abstract class Outputter
extends java.lang.Object

This class allows output to be generated. It channels output requests to an Emitter which does the actual writing. This is an abstract class, there are concrete implementions for XML output and text output.

Field Summary
`protected Emitter` `emitter`

Constructor Summary
`Outputter()`

Method Summary
`abstract int` `checkAttributePrefix(int nameCode)` Check that the prefix for an attribute is acceptable, returning a substitute prefix if not.
`abstract void` `close()` Close the output
`abstract void` `copyNamespaceNode(int nscode)` Copy a namespace node to the current element node (Rules defined in XSLT 1.0 errata)
`Emitter` `getEmitter()` Get emitter.
`abstract java.util.Properties` `getOutputProperties()`
`void` `open()` Start the output process
`abstract void` `reset()` Synchronize the state of the Outputter with that of the underlying Emitter
`void` `setEscaping(boolean escaping)` Switch escaping (of special characters) on or off.
`abstract boolean` `thereIsAnOpenStartTag()` Test whether there is an open start tag.
`abstract void` `write(java.lang.String s)` Produce literal output.
`void` `writeAttribute(int nameCode, java.lang.String value)` Output an attribute value.
`abstract void` `writeAttribute(int nameCode, java.lang.String value, boolean noEscape)` Output an attribute value.
`abstract void` `writeComment(java.lang.String comment)` Write a comment
`abstract void` `writeContent(char[] chars, int start, int length)` Produce text content output.
`abstract void` `writeContent(java.lang.String s)` Produce text content output.
`abstract void` `writeEndTag(int nameCode)` Output an element end tag.
`abstract void` `writeNamespaceDeclaration(int nscode)` Output a namespace declaration.
`abstract void` `writePI(java.lang.String target, java.lang.String data)` Write a processing instruction
`abstract void` `writeStartTag(int nameCode)` Output an element start tag.

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

Field Detail

### emitter

    protected Emitter emitter

Constructor Detail

### Outputter

    public Outputter()

Method Detail

### getEmitter

    public Emitter getEmitter()
                       throws TransformerException

  Get emitter. This is used by xsl:copy-of, a fragment is copied directly to the Emitter rather than going via the Outputter.

  Throws:
    `TransformerException`

### reset

    public abstract void reset()
                        throws TransformerException

  Synchronize the state of the Outputter with that of the underlying Emitter

  Throws:
    `TransformerException`

### getOutputProperties

    public abstract java.util.Properties getOutputProperties()

### setEscaping

    public final void setEscaping(boolean escaping)
                           throws TransformerException

  Switch escaping (of special characters) on or off.

  Throws:
    `TransformerException`

### open

    public final void open()
                    throws TransformerException

  Start the output process

  Throws:
    `TransformerException`

### write

    public abstract void write(java.lang.String s)
                        throws TransformerException

  Produce literal output. This is written as is, without any escaping. The method is provided for Java applications that wish to output literal HTML text. It is not used by the XSL system, which always writes using specific methods such as writeStartTag().

  Throws:
    `TransformerException`

### writeContent

    public abstract void writeContent(java.lang.String s)
                               throws TransformerException

  Produce text content output.
  Special characters are escaped using XML/HTML conventions if the output format requires it.

  Parameters:
    `s` - The String to be output
  Throws:
    `TransformerException` - for any failure

### writeContent

    public abstract void writeContent(char[] chars,
                                      int start,
                                      int length)
                               throws TransformerException

  Produce text content output.
  Special characters are escaped using XML/HTML conventions if the output format requires it.

  Parameters:
    `chars` - Character array to be output
    `start` - start position of characters to be output
    `length` - number of characters to be output
  Throws:
    `TransformerException` - for any failure

### writeStartTag

    public abstract void writeStartTag(int nameCode)
                                throws TransformerException

  Output an element start tag.
  The actual output of the tag is deferred until all attributes have been output using writeAttribute().

  Parameters:
    `nameCode` - The element name code
  Throws:
    `TransformerException`

### checkAttributePrefix

    public abstract int checkAttributePrefix(int nameCode)
                                      throws TransformerException

  Check that the prefix for an attribute is acceptable, returning a substitute prefix if not. The prefix is acceptable unless a namespace declaration has been written that assignes this prefix to a different namespace URI. This method also checks that the attribute namespace has been declared, and declares it if not.

  Throws:
    `TransformerException`

### writeNamespaceDeclaration

    public abstract void writeNamespaceDeclaration(int nscode)
                                            throws TransformerException

  Output a namespace declaration.
  This is added to a list of pending namespaces for the current start tag. If there is already another declaration of the same prefix, this one is ignored. Note that unlike SAX2 startPrefixMapping(), this call is made AFTER writing the start tag.

  Parameters:
    `nscode` - The namespace code
  Throws:
    `TransformerException` - if there is no start tag to write to (created using writeStartTag), or if character content has been written since the start tag was written.

### copyNamespaceNode

    public abstract void copyNamespaceNode(int nscode)
                                    throws TransformerException

  Copy a namespace node to the current element node (Rules defined in XSLT 1.0 errata)

  Throws:
    `TransformerException`

### thereIsAnOpenStartTag

    public abstract boolean thereIsAnOpenStartTag()

  Test whether there is an open start tag. This determines whether it is possible to write an attribute node at this point.

### writeAttribute

    public void writeAttribute(int nameCode,
                               java.lang.String value)
                        throws TransformerException

  Output an attribute value.
  This is added to a list of pending attributes for the current start tag, overwriting any previous attribute with the same name.
  This method should NOT be used to output namespace declarations.

  Parameters:
    `nameCode` - The name code of the attribute
    `value` - The value of the attribute
  Throws:
    `TransformerException` - if there is no start tag to write to (created using writeStartTag), or if character content has been written since the start tag was written.

### writeAttribute

    public abstract void writeAttribute(int nameCode,
                                        java.lang.String value,
                                        boolean noEscape)
                                 throws TransformerException

  Output an attribute value.
  This is added to a list of pending attributes for the current start tag, overwriting any previous attribute with the same name.
  This method should NOT be used to output namespace declarations.
  Before calling this, checkAttributePrefix() should be called to ensure the namespace is OK.

  Parameters:
    `value` - The value of the attribute
    `noEscape` - True if it's known there are no special characters in the value. If unsure, set this to false.
  Throws:
    `TransformerException` - if there is no start tag to write to (created using writeStartTag), or if character content has been written since the start tag was written.

### writeEndTag

    public abstract void writeEndTag(int nameCode)
                              throws TransformerException

  Output an element end tag.

  Parameters:
    `nameCode` - The element name code
  Throws:
    `TransformerException`

### writeComment

    public abstract void writeComment(java.lang.String comment)
                               throws TransformerException

  Write a comment

  Throws:
    `TransformerException`

### writePI

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

  Write a processing instruction

  Throws:
    `TransformerException`

### close

    public abstract void close()
                        throws TransformerException

  Close the output

  Throws:
    `TransformerException`