public DOMWriter(boolean canonical) throws UnsupportedEncodingException 
{
        this( getWriterEncoding(), canonical);
}

Default constructor.

 public DOMWriter(String encoding,
    boolean canonical) throws UnsupportedEncodingException 
{
                      
        out = new PrintWriter(new OutputStreamWriter(System.out, encoding));
        this.canonical = canonical;
}

 public static String getWriterEncoding() 
{
        return(PRINTWRITER_ENCODING);
}

 public static boolean isValidJavaEncoding(String encoding) 
{
        for ( int i = 0; i <  MIME2JAVA_ENCODINGS.length; i++ )
            if ( encoding.equals( MIME2JAVA_ENCODINGS[i] ) )
                return(true);
        return(false);
}

 public static  void main(String[] argv) 
{
        Arguments argopt = new Arguments();
        argopt.setUsage( new String[] {
                             "usage: java dom.DOMWriter (options) uri ...","",
                             "options:",
                             "  -n | -N  Turn on/off namespace [default=on]",
                             "  -v | -V  Turn on/off validation [default=on]",
                             "  -s | -S  Turn on/off Schema support [default=on]",
                             "  -d | -D  Turn on/off deferred DOM [default=on]",
                             "  -c       Canonical XML output.",
                             "  -h       This help screen.",
                             "  -e       Output Java Encoding.",
                             "           Default encoding: UTF-8"} );
        // is there anything to do?
        if ( argv.length == 0 ) {
            argopt.printUsage();
            System.exit(1);
        }
        // vars
        String  parserName = DEFAULT_PARSER_NAME;
        boolean canonical  = false;
        String  encoding   = "UTF8"; // default encoding
        argopt.parseArgumentTokens(argv, new char[] { 'p", 'e"} );
        int   c;
        String arg = null; 
        while ( ( arg =  argopt.getlistFiles() ) != null ) {
            outer:
            while ( (c =  argopt.getArguments()) != -1 ){
                switch (c) {
                case 'c":
                    canonical = true;
                    break;
                case 'e":
                    encoding      = argopt.getStringParameter();
                    if ( encoding != null && isValidJavaEncoding( encoding ) )
                        setWriterEncoding( encoding );
                    else {
                        printValidJavaEncoding();
                        System.exit( 1 );
                    }
                    break;
                case 'v":
                    setValidation = true;
                    break;
                case 'V":
                    setValidation = false;
                    break;
                case 'N":
                    setNameSpaces = false;
                    break;
                case 'n":
                    setNameSpaces = true;
                    break;
                case 'p":
                    parserName    = argopt.getStringParameter();
                    break;
                case 'd":
                    setDeferredDOM = true;
                    break;
                case 'D":
                    setDeferredDOM = false;
                    break;
                case 's":
                    setSchemaSupport = true;
                    break;
                case 'S":
                    setSchemaSupport = false;
                    break;
                case '?":
                case 'h":
                case '-":
                    argopt.printUsage();
                    System.exit(1);
                    break;
                case -1:
                    break outer;
                default:
                    break;
                }
            }
            // print uri
             // print uri
            System.err.println(arg+':");
            print(parserName, arg, canonical );
            System.err.println();
        }
}

Main program entry point.

 protected String normalize(String s) 
{
        StringBuffer str = new StringBuffer();
        int len = (s != null) ? s.length() : 0;
        for ( int i = 0; i <  len; i++ ) {
            char ch = s.charAt(i);
            switch ( ch ) {
            case '< ": {
                    str.append("<");
                    break;
                }
            case ' >": {
                    str.append(">");
                    break;
                }
            case '&": {
                    str.append("&");
                    break;
                }
            case '"": {
                    str.append(""");
                    break;
                }
            case '\r":
            case '\n": {
                    if ( canonical ) {
                        str.append("&#");
                        str.append(Integer.toString(ch));
                        str.append(';");
                        break;
                    }
                    // else, default append char
                }
            default: {
                    str.append(ch);
                }
            }
        }
        return(str.toString());
}

Normalizes the given string.

 public  void print(Node node) 
{
        // is there anything to do?
        if ( node == null ) {
            return;
        }
        int type = node.getNodeType();
        switch ( type ) {
        // print document
        case Node.DOCUMENT_NODE: {
                if ( !canonical ) {
                    String  Encoding = this.getWriterEncoding();
                    if ( Encoding.equalsIgnoreCase( "DEFAULT" ) )
                        Encoding = "UTF-8";
                    else if ( Encoding.equalsIgnoreCase( "Unicode" ) )
                        Encoding = "UTF-16";
                    else
                        Encoding = MIME2Java.reverse( Encoding );
                    out.println("< ?xml version=\"1.0\" encoding=\""+
                                Encoding + "\"? >");
                }
                print(((Document)node).getDocumentElement());
                out.flush();
                break;
            }
            // print element with attributes
        case Node.ELEMENT_NODE: {
                out.print('< ");
                out.print(node.getNodeName());
                Attr attrs[] = sortAttributes(node.getAttributes());
                for ( int i = 0; i <  attrs.length; i++ ) {
                    Attr attr = attrs[i];
                    out.print(' ");
                    out.print(attr.getNodeName());
                    out.print("=\"");
                    out.print(normalize(attr.getNodeValue()));
                    out.print('"");
                }
                out.print(' >");
                NodeList children = node.getChildNodes();
                if ( children != null ) {
                    int len = children.getLength();
                    for ( int i = 0; i <  len; i++ ) {
                        print(children.item(i));
                    }
                }
                break;
            }
            // handle entity reference nodes
        case Node.ENTITY_REFERENCE_NODE: {
                if ( canonical ) {
                    NodeList children = node.getChildNodes();
                    if ( children != null ) {
                        int len = children.getLength();
                        for ( int i = 0; i <  len; i++ ) {
                            print(children.item(i));
                        }
                    }
                } else {
                    out.print('&");
                    out.print(node.getNodeName());
                    out.print(';");
                }
                break;
            }
            // print cdata sections
        case Node.CDATA_SECTION_NODE: {
                if ( canonical ) {
                    out.print(normalize(node.getNodeValue()));
                } else {
                    out.print("< ![CDATA[");
                    out.print(node.getNodeValue());
                    out.print("]] >");
                }
                break;
            }
            // print text
        case Node.TEXT_NODE: {
                out.print(normalize(node.getNodeValue()));
                break;
            }
            // print processing instruction
        case Node.PROCESSING_INSTRUCTION_NODE: {
                out.print("< ?");
                out.print(node.getNodeName());
                String data = node.getNodeValue();
                if ( data != null && data.length()  > 0 ) {
                    out.print(' ");
                    out.print(data);
                }
                out.print("? >");
                break;
            }
        }
        if ( type == Node.ELEMENT_NODE ) {
            out.print("< /");
            out.print(node.getNodeName());
            out.print(' >");
        }
        out.flush();
}

Prints the specified node, recursively.

 public static  void print(String parserWrapperName,
    String uri,
    boolean canonical) 
{
        try {
            DOMParserWrapper parser = 
            (DOMParserWrapper)Class.forName(parserWrapperName).newInstance();
            parser.setFeature( "http://apache.org/xml/features/dom/defer-node-expansion",
                               setDeferredDOM );
            parser.setFeature( "http://xml.org/sax/features/validation", 
                               setValidation );
            parser.setFeature( "http://xml.org/sax/features/namespaces",
                               setNameSpaces );
            parser.setFeature( "http://apache.org/xml/features/validation/schema",
                               setSchemaSupport );
            Document document = parser.parse(uri);
            DOMWriter writer = new DOMWriter(canonical);
            writer.print(document);
        } catch ( Exception e ) {
            //e.printStackTrace(System.err);
        }
}

Prints the resulting document tree.

 public static  void setWriterEncoding(String encoding) 
{
        if ( encoding.equalsIgnoreCase( "DEFAULT" ) )
            PRINTWRITER_ENCODING  = "UTF8";
        else if ( encoding.equalsIgnoreCase( "UTF-16" ) )
            PRINTWRITER_ENCODING  = "Unicode";
        else
            PRINTWRITER_ENCODING = MIME2Java.convert( encoding );
}

 protected Attr[] sortAttributes(NamedNodeMap attrs) 
{
        int len = (attrs != null) ? attrs.getLength() : 0;
        Attr array[] = new Attr[len];
        for ( int i = 0; i <  len; i++ ) {
            array[i] = (Attr)attrs.item(i);
        }
        for ( int i = 0; i <  len - 1; i++ ) {
            String name  = array[i].getNodeName();
            int    index = i;
            for ( int j = i + 1; j <  len; j++ ) {
                String curName = array[j].getNodeName();
                if ( curName.compareTo(name) <  0 ) {
                    name  = curName;
                    index = j;
                }
            }
            if ( index != i ) {
                Attr temp    = array[i];
                array[i]     = array[index];
                array[index] = temp;
            }
        }
        return(array);
}

Returns a sorted list of attributes.