archive/net.sourceforge.phpeclipse.quantum.sql/src/com/quantum/util/xml/XMLRenderer.java

   1 package com.quantum.util.xml;
   2
   3 import org.w3c.dom.Attr;
   4 import org.w3c.dom.NamedNodeMap;
   5 import org.w3c.dom.Node;
   6 import org.w3c.dom.NodeList;
   7
   8 /**
   9  * @author BC Holmes
  10  */
  11 public class XMLRenderer {
  12
  13     protected boolean insertNewLine = false;
  14     protected int numberOfTabs;
  15
  16     protected final static String LINE_SEPARATOR = System
  17             .getProperty("line.separator");
  18
  19     protected final static String INDENT_STRING = "\t";
  20
  21     /** Returns a sorted list of attributes. */
  22     protected Attr[] sortAttributes(NamedNodeMap attrs) {
  23
  24         int len = (attrs != null) ? attrs.getLength() : 0;
  25         Attr array[] = new Attr[len];
  26         for (int i = 0; i < len; i++) {
  27             array[i] = (Attr) attrs.item(i);
  28         }
  29         for (int i = 0; i < len - 1; i++) {
  30             String name = array[i].getNodeName();
  31             int index = i;
  32             for (int j = i + 1; j < len; j++) {
  33                 String curName = array[j].getNodeName();
  34                 if (curName.compareTo(name) < 0) {
  35                     name = curName;
  36                     index = j;
  37                 }
  38             }
  39             if (index != i) {
  40                 Attr temp = array[i];
  41                 array[i] = array[index];
  42                 array[index] = temp;
  43             }
  44         }
  45
  46         return (array);
  47
  48     }
  49
  50     protected XMLRenderer() {
  51         this.numberOfTabs = 0;
  52         this.insertNewLine = true;
  53     }
  54
  55     protected void newLine(StringBuffer buffer) {
  56         if (this.insertNewLine) {
  57             buffer.append(LINE_SEPARATOR);
  58             for (int i = 0; i < this.numberOfTabs; i++) {
  59                 buffer.append(INDENT_STRING);
  60             }
  61         }
  62     }
  63
  64     /** Prints the specified node, recursively. */
  65     protected void print(Node node, StringBuffer buffer) {
  66         // is there anything to do?
  67         if (node != null) {
  68             int type = node.getNodeType();
  69             switch (type) {
  70
  71             case Node.DOCUMENT_NODE:
  72                 printDocumentNode(node, buffer);
  73                 break;
  74
  75             // print element with attributes
  76             case Node.ELEMENT_NODE:
  77                 printElementNode(node, buffer);
  78                 break;
  79             // handle entity reference nodes
  80             case Node.ENTITY_REFERENCE_NODE:
  81                 printEntityReferenceNode(node, buffer);
  82                 break;
  83
  84             // print cdata sections
  85             case Node.CDATA_SECTION_NODE:
  86                 printCDataSectionNode(node, buffer);
  87                 break;
  88
  89             // print text
  90             case Node.TEXT_NODE:
  91                 printTextNode(node, buffer);
  92                 break;
  93
  94             // print processing instruction
  95             case Node.PROCESSING_INSTRUCTION_NODE:
  96                 printProcessingInstructionNode(node, buffer);
  97                 break;
  98             }
  99         }
 100     }
 101
 102     protected void printProcessingInstructionNode(Node node, StringBuffer buffer) {
 103         buffer.append("<?");
 104         buffer.append(node.getNodeName());
 105         String data = node.getNodeValue();
 106         if (data != null && data.length() > 0) {
 107             buffer.append(' ');
 108             buffer.append(data);
 109         }
 110         buffer.append("?>");
 111     }
 112
 113     protected void printTextNode(Node node, StringBuffer buffer) {
 114         printString(node.getNodeValue(), buffer);
 115         this.insertNewLine = false;
 116     }
 117
 118     protected void printCDataSectionNode(Node node, StringBuffer buffer) {
 119         buffer.append("<![CDATA[");
 120         buffer.append(node.getNodeValue());
 121         buffer.append("]]>");
 122     }
 123
 124     protected void printEntityReferenceNode(Node node, StringBuffer buffer) {
 125         buffer.append('&');
 126         buffer.append(node.getNodeName());
 127         buffer.append(';');
 128     }
 129
 130     protected void printElementNode(Node node, StringBuffer buffer) {
 131         newLine(buffer);
 132         this.numberOfTabs++;
 133         buffer.append('<');
 134         buffer.append(node.getNodeName());
 135         Attr attrs[] = sortAttributes(node.getAttributes());
 136         for (int i = 0; i < attrs.length; i++) {
 137             Attr attr = attrs[i];
 138             buffer.append(' ');
 139             buffer.append(attr.getNodeName());
 140             buffer.append("=\"");
 141             printString(attr.getNodeValue(), buffer);
 142             buffer.append('"');
 143         }
 144
 145         if (!node.hasChildNodes()) {
 146             buffer.append(" />");
 147             this.numberOfTabs--;
 148         } else {
 149             buffer.append(">");
 150             printAllChildNodes(node, buffer);
 151             this.numberOfTabs--;
 152             newLine(buffer);
 153
 154             buffer.append("</");
 155             buffer.append(node.getNodeName());
 156             buffer.append(">");
 157         }
 158         this.insertNewLine = true;
 159     }
 160
 161     protected void printDocumentNode(Node node, StringBuffer buffer) {
 162         buffer.append("<?xml version=\"1.0\" ?>");
 163
 164         printAllChildNodes(node, buffer);
 165     }
 166
 167     protected void printAllChildNodes(Node node, StringBuffer buffer) {
 168         NodeList children = node.getChildNodes();
 169         for (int i = 0; i < children.getLength(); i++) {
 170             print(children.item(i), buffer);
 171         }
 172     }
 173
 174     /** Normalizes the given string. */
 175     protected void printString(String s, StringBuffer buffer) {
 176
 177         int len = (s != null) ? s.length() : 0;
 178         for (int i = 0; i < len; i++) {
 179             char ch = s.charAt(i);
 180             switch (ch) {
 181             case '<': {
 182                 buffer.append("&lt;");
 183                 break;
 184             }
 185             case '>': {
 186                 buffer.append("&gt;");
 187                 break;
 188             }
 189             case '&': {
 190                 buffer.append("&amp;");
 191                 break;
 192             }
 193             case '"':
 194                 buffer.append("&quot;");
 195                 break;
 196             case '\r':
 197             case '\n':
 198             default: {
 199                 buffer.append(ch);
 200             }
 201             }
 202         }
 203     }
 204
 205     public static String render(Node node) {
 206         XMLRenderer renderer = new XMLRenderer();
 207         StringBuffer buffer = new StringBuffer();
 208         renderer.print(node, buffer);
 209
 210         return buffer.toString();
 211     }
 212
 213     /**
 214      * <p>
 215      * Renders a String in a format that it would appear in a text node. That is
 216      * to say, special characters (such as &amp;) are converted into entity
 217      * references (&amp;amp;).
 218      */
 219     public static String render(String string) {
 220         XMLRenderer renderer = new XMLRenderer();
 221         StringBuffer buffer = new StringBuffer();
 222         renderer.printString(string, buffer);
 223         return buffer.toString();
 224     }
 225 }