public BeanWriter() 
{
    
        this( System.out );
}

Constructor uses System.out for output.

 public BeanWriter(OutputStream out) 
{
        this.writer = new BufferedWriter( new OutputStreamWriter( out ) );
        this.autoFlush = true;
}

Constuctor uses given OutputStream for output.

Parameters:

out - write out representations to this stream

 public BeanWriter(Writer writer) 
{
        this.writer = writer;
}

Constructor sets writer used for output.

Parameters:

writer - write out representations to this writer

 public BeanWriter(OutputStream out,
    String enc) throws UnsupportedEncodingException 
{
        this.writer = new BufferedWriter( new OutputStreamWriter( out, enc ) );
        this.autoFlush = true;
}

Constuctor uses given OutputStream for output and allows encoding to be set.

Parameters:

out - write out representations to this stream

enc - the name of the encoding to be used. This should be compatible with the encoding types described in java.io

Throws:

UnsupportedEncodingException - if the given encoding is not supported

 protected  void bodyText(WriteContext context,
    String text) throws IOException 
{
        if ( text == null ) {
            // XXX This is probably a programming error
            log.error( "[expressBodyText]Body text is null" );
        } else {
            if ( !closedStartTag ) {
                writer.write( ' >" );
                closedStartTag = true;
            }
            writer.write( 
                mixedContentEncodingStrategy.encode(
                    text, 
                    context.getCurrentDescriptor()) );
            currentElementIsEmpty = false;
            currentElementHasBodyText = true;
        }
}

Write element body text

 public  void close() throws IOException 
{
        writer.close();
}

Closes the underlying output stream

 public  void enablePrettyPrint() 
{
        endOfLine = EOL;
        indent = "  ";
}

Switch on formatted output. This sets the end of line and the indent. The default is adding 2 spaces and a newline

 protected  void endElement(WriteContext context,
    String uri,
    String localName,
    String qualifiedName) throws IOException, SAXException 
{
        if ( 
            !addEndTagForEmptyElement
            && !closedStartTag 
            && currentElementIsEmpty ) {
            writer.write( "/ >" );
            closedStartTag = true;
        } else {
            if (
                    addEndTagForEmptyElement
                    && !closedStartTag ) {
                 writer.write( " >" );
                 closedStartTag = true;                 
            }
            else if (!currentElementHasBodyText) {
                indent();
            }
            writer.write( "< /" );
            writer.write( qualifiedName );
            writer.write( ' >" );
        }
        indentLevel--;
        printLine();
        currentElementHasBodyText = false;
}

Writes the end tag for an element

 protected String escapeAttributeValue(Object value) 
{
        return XMLUtils.escapeAttributeValue(value);
}

Escape the toString of the given object. For use in an attribute value.

 protected String escapeBodyValue(Object value) 
{
        return XMLUtils.escapeBodyValue(value);
}

Escape the toString of the given object. For use as body text.

 protected  void expressAttribute(String qualifiedName,
    String value) throws IOException 
{
        if ( value == null ) {
            // XXX probably a programming error
            log.error( "Null attribute value." );
            return;
        }
        if ( qualifiedName == null ) {
            // XXX probably a programming error
            log.error( "Null attribute value." );
            return;
        }
        writer.write( ' " );
        writer.write( qualifiedName );
        writer.write( "=\"" );
        writer.write( XMLUtils.escapeAttributeValue(value) );
        writer.write( '\"" );
}

Writes an attribute to the stream.

 protected  void expressBodyText(String text) throws IOException 
{
        if ( text == null ) {
            // XXX This is probably a programming error
            log.error( "[expressBodyText]Body text is null" );
        } else {
            writer.write( XMLUtils.escapeBodyValue(text) );
        }
}

Write element body text

 protected  void expressElementEnd() throws IOException 
{
        writer.write( "/ >" );
}

Write an empty element end to the stream

 protected  void expressElementEnd(String qualifiedName) throws IOException 
{
        if (qualifiedName == null) {
            // XXX this indicates a programming error
            log.fatal( "[expressElementEnd]Qualified name is null." );
            throw new RuntimeException( "Qualified name is null." );
        }
        writer.write( "< /" );
        writer.write( qualifiedName );
        writer.write( ' >" );
}

Write an element end tag to the stream

 protected  void expressElementStart(String qualifiedName) throws IOException 
{
        if ( qualifiedName == null ) {
            // XXX this indicates a programming error
            log.fatal( "[expressElementStart]Qualified name is null." );
            throw new RuntimeException( "Qualified name is null." );
        }
        writePrintln();
        writeIndent();
        writer.write( '< " );
        writer.write( qualifiedName );
}

Express an element tag start using given qualified name

 protected  void expressTagClose() throws IOException 
{
        writer.write( ' >" );
}

Write a tag close to the stream

 public  void flush() throws IOException 
{
        writer.flush();
}

Allows output to be flushed on the underlying output stream

 public String getEndOfLine() 
{
        return endOfLine;
}

Gets the string used to mark end of lines.

 public String getIndent() 
{
        return indent;
}

Gets the indent string

 public int getInitialIndentLevel() 
{
        return initialIndentLevel;
}

Gets the initial indent level

 public Log getLog() 
{
        return log;
}

Set the log implementation used.

 public MixedContentEncodingStrategy getMixedContentEncodingStrategy() 
{
        return mixedContentEncodingStrategy;
}

Gets the encoding strategy for mixed content. This is used to process body content before it is written to the textual output.

 public boolean isEndTagForEmptyElement() 
{
        return addEndTagForEmptyElement;
}

Should an end tag be added for each empty element?

When this property is false then empty elements will be written as <element-name/gt;. When this property is true then empty elements will be written as <element-namegt; </element-namegt;.

 public  void setEndOfLine(String endOfLine) 
{
        this.endOfLine = endOfLine;
        for (int i = 0; i <  endOfLine.length(); i++) {
            if (!Character.isWhitespace(endOfLine.charAt(i))) {
                log.warn("Invalid EndOfLine character(s)");
                break;
            }
        }
}

Sets the string used for end of lines Produces a warning the specified value contains an invalid whitespace character

 public  void setEndTagForEmptyElement(boolean addEndTagForEmptyElement) 
{
        this.addEndTagForEmptyElement = addEndTagForEmptyElement;
}

Sets when an an end tag be added for each empty element. When this property is false then empty elements will be written as <element-name/gt;. When this property is true then empty elements will be written as <element-namegt; </element-namegt;.

 public  void setIndent(String indent) 
{
        this.indent = indent;
}

Sets the string used for pretty print indents

 public  void setInitialIndentLevel(int initialIndentLevel) 
{
        this.initialIndentLevel = initialIndentLevel;
}

Sets the initial indent level used for pretty print indents

 public  void setLog(Log log) 
{
        this.log = log;
}

Set the log implementation used.

 public  void setMixedContentEncodingStrategy(MixedContentEncodingStrategy strategy) 
{
        mixedContentEncodingStrategy = strategy;
}

Sets the encoding strategy for mixed content. This is used to process body content before it is written to the textual output.

 protected  void startElement(WriteContext context,
    String uri,
    String localName,
    String qualifiedName,
    Attributes attr) throws IOException, SAXException 
{
        if ( !closedStartTag ) {
            writer.write( ' >" );
            printLine();
        }
        indentLevel++;
        indent();
        writer.write( '< " );
        writer.write( qualifiedName );
        for ( int i=0; i<  attr.getLength(); i++ ) {
            writer.write( ' " );
            writer.write( attr.getQName(i) );
            writer.write( "=\"" );
            writer.write( XMLUtils.escapeAttributeValue( attr.getValue(i) ) );
            writer.write( '\"" );
        }
        closedStartTag = false;
        currentElementIsEmpty = true;
        currentElementHasBodyText = false;
}

Writes the start tag for an element.

 public  void write(Object bean) throws IntrospectionException, IOException, SAXException 
{
        super.write(bean);
        if ( autoFlush ) {
            writer.flush();
        }
}

Write the given object to the stream (and then flush).

 protected  void writeIndent() throws IOException 
{
        if ( indent != null ) {
            for ( int i = 0; i <  indentLevel; i++ ) {
                writer.write( getIndent() );
            }
        }
}

Writes out indent's to the current indentLevel

 protected  void writePrintln() throws IOException 
{
        if ( endOfLine != null ) {
            writer.write( endOfLine );
        }
}

Writes out an empty line. Uses current endOfLine.

 public  void writeXmlDeclaration(String xmlDeclaration) throws IOException 
{
        writer.write( xmlDeclaration );
        printLine();
}

A helper method that allows you to write the XML Declaration. This should only be called once before you output any beans.