OutputFormat (intarsys runtime library)

java.lang.Object
- de.intarsys.tools.infoset.OutputFormat

All Implemented Interfaces:

Cloneable
```
public class OutputFormat
extends Object
implements Cloneable
```
OutputFormat represents the format configuration used by and its base classes to format the XML output

Version:

$Revision: 1.1 $

Constructor Summary

Constructors
Constructor and Description
`OutputFormat()` Creates an `OutputFormat` with no additional whitespace (indent or new lines) added.
`OutputFormat(String indent)` Creates an `OutputFormat` with the given indent added but no new lines added.
`OutputFormat(String indent, boolean newlines)` Creates an `OutputFormat` with the given indent added with optional newlines between the Elements.
`OutputFormat(String indent, boolean newlines, String encoding)` Creates an `OutputFormat` with the given indent added with optional newlines between the Elements and the given encoding format.

Method Summary

Methods
Modifier and Type	Method and Description
`static OutputFormat`	`createCompactFormat()` A static helper method to create the default compact format.
`static OutputFormat`	`createPrettyPrint()` A static helper method to create the default pretty printing format.
`char`	`getAttributeQuoteCharacter()`
`String`	`getEncoding()`
`String`	`getIndent()`
`String`	`getLineSeparator()`
`int`	`getNewLineAfterNTags()`
`boolean`	`isEscapeText()` DOCUMENT ME!
`boolean`	`isExpandEmptyElements()`
`boolean`	`isNewLineAfterDeclaration()` DOCUMENT ME!
`boolean`	`isNewlines()`
`boolean`	`isOmitEncoding()`
`boolean`	`isSuppressDeclaration()` DOCUMENT ME!
`boolean`	`isTrimText()`
`boolean`	`isXHTML()` Whether or not to use the XHTML standard: like HTML but passes an XML parser with real, closed tags.
`void`	`setAttributeQuoteCharacter(char quoteChar)` Sets the character used to quote attribute values.
`void`	`setEncoding(String encoding)` DOCUMENT ME!
`void`	`setEscapeText(boolean escapeText)` Sets whether text output should be escaped or not.
`void`	`setExpandEmptyElements(boolean expandEmptyElements)` This will set whether empty elements are expanded from `<tagName>` to `<tagName></tagName>`.
`void`	`setIndent(boolean doIndent)` Set the indent on or off.
`void`	`setIndent(String indent)` This will set the indent `String` to use; this is usually a `String` of empty spaces.
`void`	`setIndentSize(int indentSize)` This will set the indent `String`'s size; an indentSize of 4 would result in the indention being equivalent to the `String` " " (four space characters).
`void`	`setLineSeparator(String separator)` This will set the new-line separator.
`void`	`setNewLineAfterDeclaration(boolean newLineAfterDeclaration)` This will set whether a new line is printed after the XML declaration (assuming it is not supressed.)
`void`	`setNewLineAfterNTags(int tagCount)` Controls output of a line.separator every tagCount tags when isNewlines is false.
`void`	`setNewlines(boolean newlines)` DOCUMENT ME!
`void`	`setOmitEncoding(boolean omitEncoding)` This will set whether the XML declaration (`<?`
`void`	`setSuppressDeclaration(boolean suppressDeclaration)` This will set whether the XML declaration (`<?`
`void`	`setTrimText(boolean trimText)` This will set whether the text is output verbatim (false) or with whitespace stripped as per `org.dom4j.Element#getTextTrim()`.
`void`	`setXHTML(boolean xhtml)` This will set whether or not to use the XHTML standard: like HTML but passes an XML parser with real, closed tags.

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

- Constructor Detail
  - OutputFormat
```
public OutputFormat()
```
    Creates an OutputFormat with no additional whitespace (indent or new lines) added. The whitespace from the element text content is fully preserved.
  - OutputFormat
```
public OutputFormat(String indent)
```
    Creates an OutputFormat with the given indent added but no new lines added. All whitespace from element text will be included.
    
    Parameters:
    indent - is the indent string to be used for indentation (usually a number of spaces).
  - OutputFormat
```
public OutputFormat(String indent,
            boolean newlines)
```
    Creates an OutputFormat with the given indent added with optional newlines between the Elements. All whitespace from element text will be included.
    
    Parameters:
    indent - is the indent string to be used for indentation (usually a number of spaces).
    newlines - whether new lines are added to layout the
  - OutputFormat
```
public OutputFormat(String indent,
            boolean newlines,
            String encoding)
```
    Creates an OutputFormat with the given indent added with optional newlines between the Elements and the given encoding format.
    
    Parameters:
    indent - is the indent string to be used for indentation (usually a number of spaces).
    newlines - whether new lines are added to layout the
    encoding - is the text encoding to use for writing the XML
- Method Detail
  - createCompactFormat
```
public static OutputFormat createCompactFormat()
```
    A static helper method to create the default compact format. This format does not have any indentation or newlines after an alement and all other whitespace trimmed
    
    Returns:
    DOCUMENT ME!
  - createPrettyPrint
```
public static OutputFormat createPrettyPrint()
```
    A static helper method to create the default pretty printing format. This format consists of an indent of 2 spaces, newlines after each element and all other whitespace trimmed, and XMTML is false.
    
    Returns:
    DOCUMENT ME!
  - getAttributeQuoteCharacter
```
public char getAttributeQuoteCharacter()
```
  - getEncoding
```
public String getEncoding()
```
  - getIndent
```
public String getIndent()
```
  - getLineSeparator
```
public String getLineSeparator()
```
  - getNewLineAfterNTags
```
public int getNewLineAfterNTags()
```
  - isEscapeText
```
public boolean isEscapeText()
```
    DOCUMENT ME!
    
    Returns:
    true if text thats output should be escaped. This is enabled by default. It could be disabled if the output format is textual, like in XSLT where we can have xml, html or text output.
  - isExpandEmptyElements
```
public boolean isExpandEmptyElements()
```
  - isNewLineAfterDeclaration
```
public boolean isNewLineAfterDeclaration()
```
    DOCUMENT ME!
    
    Returns:
    true if a new line should be printed following XML declaration
  - isNewlines
```
public boolean isNewlines()
```
  - isOmitEncoding
```
public boolean isOmitEncoding()
```
  - isSuppressDeclaration
```
public boolean isSuppressDeclaration()
```
    DOCUMENT ME!
    
    Returns:
    true if the output of the XML declaration (<?xml version="1.0"?>) should be suppressed else false.
  - isTrimText
```
public boolean isTrimText()
```
  - isXHTML
```
public boolean isXHTML()
```
    Whether or not to use the XHTML standard: like HTML but passes an XML parser with real, closed tags. Also, XHTML CDATA sections will be output with the CDATA delimiters: ( " <![CDATA[ " and " ]]> " ) otherwise, the class HTMLWriter will output the CDATA text, but not the delimiters.
    
    Default is false
    
    Returns:
    DOCUMENT ME!
  - setAttributeQuoteCharacter
```
public void setAttributeQuoteCharacter(char quoteChar)
```
    Sets the character used to quote attribute values. The specified character must be a valid XML attribute quote character, otherwise an IllegalArgumentException will be thrown.
    
    Parameters:
    quoteChar - The character to use when quoting attribute values.
    
    Throws:
    
    IllegalArgumentException - If the specified character is not a valid XML attribute quote character.
  - setEncoding
```
public void setEncoding(String encoding)
```
    DOCUMENT ME!
    
    Parameters:
    encoding - encoding format
  - setEscapeText
```
public void setEscapeText(boolean escapeText)
```
    Sets whether text output should be escaped or not. This is enabled by default. It could be disabled if the output format is textual, like in XSLT where we can have xml, html or text output.
    
    Parameters:
    escapeText - DOCUMENT ME!
  - setExpandEmptyElements
```
public void setExpandEmptyElements(boolean expandEmptyElements)
```
    This will set whether empty elements are expanded from <tagName> to <tagName></tagName>.
    
    Parameters:
    expandEmptyElements - boolean indicating whether or not empty elements should be expanded.
  - setIndent
```
public void setIndent(boolean doIndent)
```
    Set the indent on or off. If setting on, will use the value of STANDARD_INDENT, which is usually two spaces.
    
    Parameters:
    doIndent - if true, set indenting on; if false, set indenting off
  - setIndent
```
public void setIndent(String indent)
```
    This will set the indent String to use; this is usually a String of empty spaces. If you pass null, or the empty string (""), then no indentation will happen.
    Default: none (null)
    
    Parameters:
    indent - String to use for indentation.
  - setIndentSize
```
public void setIndentSize(int indentSize)
```
    This will set the indent String's size; an indentSize of 4 would result in the indention being equivalent to the String " " (four space characters).
    
    Parameters:
    indentSize - int number of spaces in indentation.
  - setLineSeparator
```
public void setLineSeparator(String separator)
```
    This will set the new-line separator. The default is \n. Note that if the "newlines" property is false, this value is irrelevant. To make it output the system default line ending string, call setLineSeparator(System.getProperty("line.separator"))
    
    Parameters:
    separator - String line separator to use.
    See Also:
    setNewlines(boolean)
  - setNewLineAfterDeclaration
```
public void setNewLineAfterDeclaration(boolean newLineAfterDeclaration)
```
    This will set whether a new line is printed after the XML declaration (assuming it is not supressed.)
    
    Parameters:
    newLineAfterDeclaration - boolean indicating whether or not to print new line following the XML declaration. The default is true.
  - setNewLineAfterNTags
```
public void setNewLineAfterNTags(int tagCount)
```
    Controls output of a line.separator every tagCount tags when isNewlines is false. If tagCount equals zero, it means don't do anything special. If greater than zero, then a line.separator will be output after tagCount tags have been output. Used when you would like to squeeze the html as much as possible, but some browsers don't like really long lines. A tag count of 10 would produce a line.separator in the output after 10 close tags (including single tags).
    
    Parameters:
    tagCount - DOCUMENT ME!
  - setNewlines
```
public void setNewlines(boolean newlines)
```
    DOCUMENT ME!
    
    Parameters:
    newlines - true indicates new lines should be printed, else new lines are ignored (compacted).
    See Also:
    setLineSeparator(String)
  - setOmitEncoding
```
public void setOmitEncoding(boolean omitEncoding)
```
    This will set whether the XML declaration (<?xml version="1.0" encoding="UTF-8"?>) includes the encoding of the document. It is common to suppress this in protocols such as WML and SOAP.
    
    Parameters:
    omitEncoding - boolean indicating whether or not the XML declaration should indicate the document encoding.
  - setSuppressDeclaration
```
public void setSuppressDeclaration(boolean suppressDeclaration)
```
    This will set whether the XML declaration (<?xml version="1.0" encoding="UTF-8"?>) is included or not. It is common to suppress this in protocols such as WML and SOAP.
    
    Parameters:
    suppressDeclaration - boolean indicating whether or not the XML declaration should be suppressed.
  - setTrimText
```
public void setTrimText(boolean trimText)
```
    This will set whether the text is output verbatim (false) or with whitespace stripped as per org.dom4j.Element#getTextTrim().
    
    Default: false
    
    Parameters:
    trimText - boolean true=>trim the whitespace, false=>use text verbatim
  - setXHTML
```
public void setXHTML(boolean xhtml)
```
    This will set whether or not to use the XHTML standard: like HTML but passes an XML parser with real, closed tags. Also, XHTML CDATA sections will be output with the CDATA delimiters: ( " <[CDATA[ " and " ]]< ) otherwise, the class HTMLWriter will output the CDATA text, but not the delimiters.
    
    Default: false
    
    Parameters:
    xhtml - boolean true=>conform to XHTML, false=>conform to HTML, can have unclosed tags, etc.

Class OutputFormat

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

OutputFormat

OutputFormat

OutputFormat

OutputFormat

Method Detail

createCompactFormat

createPrettyPrint

getAttributeQuoteCharacter

getEncoding

getIndent

getLineSeparator

getNewLineAfterNTags

isEscapeText

isExpandEmptyElements

isNewLineAfterDeclaration

isNewlines

isOmitEncoding

isSuppressDeclaration

isTrimText

isXHTML

setAttributeQuoteCharacter

setEncoding

setEscapeText

setExpandEmptyElements

setIndent

setIndent

setIndentSize

setLineSeparator

setNewLineAfterDeclaration

setNewLineAfterNTags

setNewlines

setOmitEncoding

setSuppressDeclaration

setTrimText

setXHTML