1   
2   
3   
4   
5   
6   
7   
8   package org.dom4j.tree;
9   
10  import java.io.IOException;
11  import java.io.StringWriter;
12  import java.io.Writer;
13  import java.util.Iterator;
14  import java.util.List;
15  import java.util.Map;
16  
17  import org.dom4j.Comment;
18  import org.dom4j.Document;
19  import org.dom4j.DocumentType;
20  import org.dom4j.Element;
21  import org.dom4j.IllegalAddException;
22  import org.dom4j.Node;
23  import org.dom4j.ProcessingInstruction;
24  import org.dom4j.QName;
25  import org.dom4j.Text;
26  import org.dom4j.Visitor;
27  import org.dom4j.io.OutputFormat;
28  import org.dom4j.io.XMLWriter;
29  
30  /***
31   * <p>
32   * <code>AbstractDocument</code> is an abstract base class for tree
33   * implementors to use for implementation inheritence.
34   * </p>
35   * 
36   * @author <a href="mailto:jstrachan@apache.org">James Strachan </a>
37   * @version $Revision: 1.33 $
38   */
39  public abstract class AbstractDocument extends AbstractBranch implements
40          Document {
41  
42      /*** The encoding of this document as stated in the XML declaration */
43      protected String encoding;
44  
45      public AbstractDocument() {
46      }
47  
48      public short getNodeType() {
49          return DOCUMENT_NODE;
50      }
51  
52      public String getPath(Element context) {
53          return "/";
54      }
55  
56      public String getUniquePath(Element context) {
57          return "/";
58      }
59  
60      public Document getDocument() {
61          return this;
62      }
63  
64      public String getXMLEncoding() {
65          return null;
66      }
67  
68      public String getStringValue() {
69          Element root = getRootElement();
70  
71          return (root != null) ? root.getStringValue() : "";
72      }
73  
74      public String asXML() {
75          OutputFormat format = new OutputFormat();
76          format.setEncoding(encoding);
77          
78          try {
79              StringWriter out = new StringWriter();
80              XMLWriter writer = new XMLWriter(out, format);
81              writer.write(this);
82              writer.flush();
83  
84              return out.toString();
85          } catch (IOException e) {
86              throw new RuntimeException("IOException while generating textual "
87                      + "representation: " + e.getMessage());
88          }
89      }
90  
91      public void write(Writer out) throws IOException {
92          OutputFormat format = new OutputFormat();
93          format.setEncoding(encoding);
94          
95          XMLWriter writer = new XMLWriter(out, format);
96          writer.write(this);
97      }
98  
99      /***
100      * <p>
101      * <code>accept</code> method is the <code>Visitor Pattern</code>
102      * method.
103      * </p>
104      * 
105      * @param visitor
106      *            <code>Visitor</code> is the visitor.
107      */
108     public void accept(Visitor visitor) {
109         visitor.visit(this);
110 
111         DocumentType docType = getDocType();
112 
113         if (docType != null) {
114             visitor.visit(docType);
115         }
116 
117         
118         List content = content();
119 
120         if (content != null) {
121             for (Iterator iter = content.iterator(); iter.hasNext();) {
122                 Object object = iter.next();
123 
124                 if (object instanceof String) {
125                     Text text = getDocumentFactory()
126                             .createText((String) object);
127                     visitor.visit(text);
128                 } else {
129                     Node node = (Node) object;
130                     node.accept(visitor);
131                 }
132             }
133         }
134     }
135 
136     public String toString() {
137         return super.toString() + " [Document: name " + getName() + "]";
138     }
139 
140     public void normalize() {
141         Element element = getRootElement();
142 
143         if (element != null) {
144             element.normalize();
145         }
146     }
147 
148     public Document addComment(String comment) {
149         Comment node = getDocumentFactory().createComment(comment);
150         add(node);
151 
152         return this;
153     }
154 
155     public Document addProcessingInstruction(String target, String data) {
156         ProcessingInstruction node = getDocumentFactory()
157                 .createProcessingInstruction(target, data);
158         add(node);
159 
160         return this;
161     }
162 
163     public Document addProcessingInstruction(String target, Map data) {
164         ProcessingInstruction node = getDocumentFactory()
165                 .createProcessingInstruction(target, data);
166         add(node);
167 
168         return this;
169     }
170 
171     public Element addElement(String name) {
172         Element element = getDocumentFactory().createElement(name);
173         add(element);
174 
175         return element;
176     }
177 
178     public Element addElement(String qualifiedName, String namespaceURI) {
179         Element element = getDocumentFactory().createElement(qualifiedName,
180                 namespaceURI);
181         add(element);
182 
183         return element;
184     }
185 
186     public Element addElement(QName qName) {
187         Element element = getDocumentFactory().createElement(qName);
188         add(element);
189 
190         return element;
191     }
192 
193     public void setRootElement(Element rootElement) {
194         clearContent();
195 
196         if (rootElement != null) {
197             super.add(rootElement);
198             rootElementAdded(rootElement);
199         }
200     }
201 
202     public void add(Element element) {
203         checkAddElementAllowed(element);
204         super.add(element);
205         rootElementAdded(element);
206     }
207 
208     public boolean remove(Element element) {
209         boolean answer = super.remove(element);
210         Element root = getRootElement();
211 
212         if ((root != null) && answer) {
213             setRootElement(null);
214         }
215 
216         element.setDocument(null);
217 
218         return answer;
219     }
220 
221     public Node asXPathResult(Element parent) {
222         return this;
223     }
224 
225     protected void childAdded(Node node) {
226         if (node != null) {
227             node.setDocument(this);
228         }
229     }
230 
231     protected void childRemoved(Node node) {
232         if (node != null) {
233             node.setDocument(null);
234         }
235     }
236 
237     protected void checkAddElementAllowed(Element element) {
238         Element root = getRootElement();
239 
240         if (root != null) {
241             throw new IllegalAddException(this, element,
242                     "Cannot add another element to this "
243                             + "Document as it already has a root "
244                             + "element of: " + root.getQualifiedName());
245         }
246     }
247 
248     /***
249      * Called to set the root element variable
250      * 
251      * @param rootElement
252      *            DOCUMENT ME!
253      */
254     protected abstract void rootElementAdded(Element rootElement);
255 
256     public void setXMLEncoding(String enc) {
257         this.encoding = enc;
258     }
259 }
260 
261 
262 
263 
264 
265 
266 
267 
268 
269 
270 
271 
272 
273 
274 
275 
276 
277 
278 
279 
280 
281 
282 
283 
284 
285 
286 
287 
288 
289 
290 
291 
292 
293 
294 
295 
296