FileDocCategorySizeDatePackage
IndentPrinter.javaAPI DocApache Xerces 3.0.112415Fri Sep 14 20:33:52 BST 2007org.apache.xml.serialize

IndentPrinter

public class IndentPrinter extends Printer
Extends {@link Printer} and adds support for indentation and line wrapping.
deprecated
This class was deprecated in Xerces 2.9.0. It is recommended that new applications use the DOM Level 3 LSSerializer or JAXP's Transformation API for XML (TrAX) for serializing XML. See the Xerces documentation for more information.
version
$Revision: 476047 $ $Date: 2006-11-16 23:27:45 -0500 (Thu, 16 Nov 2006) $
author
Assaf Arkin

Fields Summary
private StringBuffer
_line
Holds the currently accumulating text line. This buffer will constantly be reused by deleting its contents instead of reallocating it.
private StringBuffer
_text
Holds the currently accumulating text that follows {@link #_line}. When the end of the part is identified by a call to {@link #printSpace} or {@link #breakLine}, this part is added to the accumulated line.
private int
_spaces
Counts how many white spaces come between the accumulated line and the current accumulated text. Multiple spaces at the end of the a line will not be printed.
private int
_thisIndent
Holds the indentation for the current line that is now accumulating in memory and will be sent for printing shortly.
private int
_nextIndent
Holds the indentation for the next line to be printed. After this line is printed, {@link #_nextIndent} is assigned to {@link #_thisIndent}.
Constructors Summary
public IndentPrinter(Writer writer, OutputFormat format)

        super( writer, format );
        // Initialize everything for a first/second run.
        _line = new StringBuffer( 80 );
        _text = new StringBuffer( 20 );
        _spaces = 0;
        _thisIndent = _nextIndent = 0;
    
Methods Summary
public voidbreakLine(boolean preserveSpace)

        // Equivalent to calling printSpace and forcing a flushLine.
        if ( _text.length() > 0 ) {
            while ( _spaces > 0 ) {
                _line.append( ' " );
                --_spaces;
            }
            _line.append( _text );
            _text = new StringBuffer( 20 );
        }
        flushLine( preserveSpace );
        try {
            // Print line and new line, then zero the line contents.
            _writer.write( _format.getLineSeparator() );
        } catch ( IOException except ) {
            // We don't throw an exception, but hold it
            // until the end of the document.
            if ( _exception == null )
                _exception = except;
        }
    
public voidbreakLine()
Called to print a line consisting of the text accumulated so far. This is equivalent to calling {@link #printSpace} but forcing the line to print and starting a new line ({@link #printSpace} will only start a new line if the current line is long enough).

        breakLine( false );
    
public voidenterDTD()
Called by any of the DTD handlers to enter DTD mode. Once entered, all output will be accumulated in a string that can be printed as part of the document's DTD. This method may be called any number of time but will only have affect the first time it's called. To exist DTD state and get the accumulated DTD, call {@link #leaveDTD}.

        // Can only enter DTD state once. Once we're out of DTD
        // state, can no longer re-enter it.
        if ( _dtdWriter == null ) {
            _line.append( _text );
            _text = new StringBuffer( 20 );
            flushLine( false );
            _dtdWriter = new StringWriter();
            _docWriter = _writer;
            _writer = _dtdWriter;
        }
    
public voidflush()
Flush the output stream. Must be called when done printing the document, otherwise some text might be buffered.

        if ( _line.length() > 0 || _text.length() > 0 )
            breakLine();
        try {
            _writer.flush();
        } catch ( IOException except ) {
            // We don't throw an exception, but hold it
            // until the end of the document.
            if ( _exception == null )
                _exception = except;
        }
    
public voidflushLine(boolean preserveSpace)
Flushes the line accumulated so far to the writer and get ready to accumulate the next line. This method is called by {@link #printText} and {@link #printSpace} when the accumulated line plus accumulated text are two long to fit on a given line. At the end of this method _line is empty and _spaces is zero.

        int     indent;
        
        if ( _line.length() > 0 ) {
            try {
                
                if ( _format.getIndenting() && ! preserveSpace ) {
                    // Make sure the indentation does not blow us away.
                    indent = _thisIndent;
                    if ( ( 2 * indent ) > _format.getLineWidth() && _format.getLineWidth() > 0 )
                        indent = _format.getLineWidth() / 2;
                    // Print the indentation as spaces and set the current
                    // indentation to the next expected indentation.
                    while ( indent > 0 ) {
                        _writer.write( ' " );
                        --indent;
                    }
                }
                _thisIndent = _nextIndent;
                
                // There is no need to print the spaces at the end of the line,
                // they are simply stripped and replaced with a single line
                // separator.
                _spaces = 0;
                _writer.write( _line.toString() );
                
                _line = new StringBuffer( 40 );
            } catch ( IOException except ) {
                // We don't throw an exception, but hold it
                // until the end of the document.
                if ( _exception == null )
                    _exception = except;
            }
        }
    
public intgetNextIndent()

        return _nextIndent;
    
public voidindent()
Increment the indentation for the next line.

        _nextIndent += _format.getIndent();
    
public java.lang.StringleaveDTD()
Called by the root element to leave DTD mode and if any DTD parts were printer, will return a string with their textual content.

        // Only works if we're going out of DTD mode.
        if ( _writer == _dtdWriter ) {
            _line.append( _text );
            _text = new StringBuffer( 20 );
            flushLine( false );
            _writer = _docWriter;
            return _dtdWriter.toString();
        }
        return null;
    
public voidprintSpace()
Called to print a single space between text parts that may be broken into separate lines. Must not be called to print a space when preserving spaces. The text accumulated so far with {@link #printText} will be added to the accumulated line, and a space separator will be counted. If the line accumulated so far is long enough, it will be printed.

        // The line consists of the text accumulated in _line,
        // followed by one or more spaces as counted by _spaces,
        // followed by more space accumulated in _text:
        // -  Text is printed and accumulated into _text.
        // -  A space is printed, so _text is added to _line and
        //    a space is counted.
        // -  More text is printed and accumulated into _text.
        // -  A space is printed, the previous spaces are added
        //    to _line, the _text is added to _line, and a new
        //    space is counted.
        
        // If text was accumulated with printText(), then the space
        // means we have to move that text into the line and
        // start accumulating new text with printText().
        if ( _text.length() > 0 ) {
            // If the text breaks a line bounary, wrap to the next line.
            // The printed line size consists of the indentation we're going
            // to use next, the accumulated line so far, some spaces and the
            // accumulated text so far.
            if ( _format.getLineWidth() > 0 &&
                 _thisIndent + _line.length() + _spaces + _text.length() > _format.getLineWidth() ) {
                flushLine( false );
                try {
                    // Print line and new line, then zero the line contents.
                    _writer.write( _format.getLineSeparator() );
                } catch ( IOException except ) {
                    // We don't throw an exception, but hold it
                    // until the end of the document.
                    if ( _exception == null )
                        _exception = except;
                }
            }
            
            // Add as many spaces as we accumulaed before.
            // At the end of this loop, _spaces is zero.
            while ( _spaces > 0 ) {
                _line.append( ' " );
                --_spaces;
            }
            _line.append( _text );
            _text = new StringBuffer( 20 );
        }
        // Starting a new word: accumulate the text between the line
        // and this new word; not a new word: just add another space.
        ++_spaces;
    
public voidprintText(java.lang.String text)
Called to print additional text. Each time this method is called it accumulates more text. When a space is printed ({@link #printSpace}) all the accumulated text becomes one part and is added to the accumulate line. When a line is long enough, it can be broken at its text boundary.

param
text The text to print

        _text.append( text );
    
public voidprintText(java.lang.StringBuffer text)

        _text.append( text.toString() );
    
public voidprintText(char ch)

        _text.append( ch );
    
public voidprintText(char[] chars, int start, int length)

        _text.append( chars, start, length );
    
public voidsetNextIndent(int indent)

        _nextIndent = indent;
    
public voidsetThisIndent(int indent)

        _thisIndent = indent;
    
public voidunindent()
Decrement the indentation for the next line.

        _nextIndent -= _format.getIndent();
        if ( _nextIndent < 0 )
            _nextIndent = 0;
        // If there is no current line and we're de-identing then
        // this indentation level is actually the next level.
        if ( ( _line.length() + _spaces + _text.length() ) == 0 )
            _thisIndent = _nextIndent;