KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > dom4j > dom > DOMDocumentFactory


1 /*
2  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
3  *
4  * This software is open source.
5  * See the bottom of this file for the licence.
6  */

7
8 package org.dom4j.dom;
9
10 import java.util.Map JavaDoc;
11
12 import org.dom4j.Attribute;
13 import org.dom4j.CDATA;
14 import org.dom4j.Comment;
15 import org.dom4j.Document;
16 import org.dom4j.DocumentFactory;
17 import org.dom4j.DocumentType;
18 import org.dom4j.Element;
19 import org.dom4j.Entity;
20 import org.dom4j.Namespace;
21 import org.dom4j.ProcessingInstruction;
22 import org.dom4j.QName;
23 import org.dom4j.Text;
24 import org.dom4j.util.SingletonStrategy;
25 import org.w3c.dom.DOMException JavaDoc;
26
27 /**
28  * <p>
29  * <code>DOMDocumentFactory</code> is a factory of DOM4J objects which
30  * implement the W3C DOM API.
31  * </p>
32  *
33  * @author <a HREF="mailto:jstrachan@apache.org">James Strachan </a>
34  * @version $Revision: 1.21 $
35  */

36 public class DOMDocumentFactory extends DocumentFactory implements
37         org.w3c.dom.DOMImplementation JavaDoc {
38
39     /** The Singleton instance */
40     private static SingletonStrategy singleton = null;
41
42     static {
43         try {
44             String JavaDoc defaultSingletonClass = "org.dom4j.util.SimpleSingleton";
45             Class JavaDoc clazz = null;
46             try {
47                 String JavaDoc singletonClass = defaultSingletonClass;
48                 singletonClass = System.getProperty(
49                         "org.dom4j.dom.DOMDocumentFactory.singleton.strategy",
50                         singletonClass);
51                 clazz = Class.forName(singletonClass);
52             } catch (Exception JavaDoc exc1) {
53                 try {
54                     String JavaDoc singletonClass = defaultSingletonClass;
55                     clazz = Class.forName(singletonClass);
56                 } catch (Exception JavaDoc exc2) {
57                 }
58             }
59             singleton = (SingletonStrategy) clazz.newInstance();
60             singleton.setSingletonClassName(DOMDocumentFactory.class.getName());
61         } catch (Exception JavaDoc exc3) {
62         }
63     }
64
65     /**
66      * <p>
67      * Access to the singleton instance of this factory.
68      * </p>
69      *
70      * @return the default singleon instance
71      */

72     public static DocumentFactory getInstance() {
73         DOMDocumentFactory fact = (DOMDocumentFactory) singleton.instance();
74         return fact;
75     }
76
77     // Factory methods
78
public Document createDocument() {
79         DOMDocument answer = new DOMDocument();
80         answer.setDocumentFactory(this);
81
82         return answer;
83     }
84
85     public DocumentType createDocType(String JavaDoc name, String JavaDoc publicId,
86             String JavaDoc systemId) {
87         return new DOMDocumentType(name, publicId, systemId);
88     }
89
90     public Element createElement(QName qname) {
91         return new DOMElement(qname);
92     }
93
94     public Element createElement(QName qname, int attributeCount) {
95         return new DOMElement(qname, attributeCount);
96     }
97
98     public Attribute createAttribute(Element owner, QName qname, String JavaDoc value) {
99         return new DOMAttribute(qname, value);
100     }
101
102     public CDATA createCDATA(String JavaDoc text) {
103         return new DOMCDATA(text);
104     }
105
106     public Comment createComment(String JavaDoc text) {
107         return new DOMComment(text);
108     }
109
110     public Text createText(String JavaDoc text) {
111         return new DOMText(text);
112     }
113
114     public Entity createEntity(String JavaDoc name) {
115         return new DOMEntityReference(name);
116     }
117
118     public Entity createEntity(String JavaDoc name, String JavaDoc text) {
119         return new DOMEntityReference(name, text);
120     }
121
122     public Namespace createNamespace(String JavaDoc prefix, String JavaDoc uri) {
123         return new DOMNamespace(prefix, uri);
124     }
125
126     public ProcessingInstruction createProcessingInstruction(String JavaDoc target,
127             String JavaDoc data) {
128         return new DOMProcessingInstruction(target, data);
129     }
130
131     public ProcessingInstruction createProcessingInstruction(String JavaDoc target,
132             Map JavaDoc data) {
133         return new DOMProcessingInstruction(target, data);
134     }
135
136     // org.w3c.dom.DOMImplementation interface
137
public boolean hasFeature(String JavaDoc feat, String JavaDoc version) {
138         if ("XML".equalsIgnoreCase(feat) || "Core".equalsIgnoreCase(feat)) {
139             return ((version == null) || (version.length() == 0)
140                     || "1.0".equals(version) || "2.0".equals(version));
141         }
142
143         return false;
144     }
145
146     public org.w3c.dom.DocumentType JavaDoc createDocumentType(String JavaDoc qualifiedName,
147             String JavaDoc publicId, String JavaDoc systemId) throws DOMException JavaDoc {
148         return new DOMDocumentType(qualifiedName, publicId, systemId);
149     }
150
151     public org.w3c.dom.Document JavaDoc createDocument(String JavaDoc namespaceURI,
152             String JavaDoc qualifiedName, org.w3c.dom.DocumentType JavaDoc docType)
153             throws org.w3c.dom.DOMException JavaDoc {
154         DOMDocument document;
155
156         if (docType != null) {
157             DOMDocumentType documentType = asDocumentType(docType);
158             document = new DOMDocument(documentType);
159         } else {
160             document = new DOMDocument();
161         }
162
163         document.addElement(createQName(qualifiedName, namespaceURI));
164
165         return document;
166     }
167
168     // Implementation methods
169
protected DOMDocumentType asDocumentType(org.w3c.dom.DocumentType JavaDoc docType) {
170         if (docType instanceof DOMDocumentType) {
171             return (DOMDocumentType) docType;
172         } else {
173             return new DOMDocumentType(docType.getName(),
174                     docType.getPublicId(), docType.getSystemId());
175         }
176     }
177 }
178
179
180
181 /*
182  * Redistribution and use of this software and associated documentation
183  * ("Software"), with or without modification, are permitted provided that the
184  * following conditions are met:
185  *
186  * 1. Redistributions of source code must retain copyright statements and
187  * notices. Redistributions must also contain a copy of this document.
188  *
189  * 2. Redistributions in binary form must reproduce the above copyright notice,
190  * this list of conditions and the following disclaimer in the documentation
191  * and/or other materials provided with the distribution.
192  *
193  * 3. The name "DOM4J" must not be used to endorse or promote products derived
194  * from this Software without prior written permission of MetaStuff, Ltd. For
195  * written permission, please contact dom4j-info@metastuff.com.
196  *
197  * 4. Products derived from this Software may not be called "DOM4J" nor may
198  * "DOM4J" appear in their names without prior written permission of MetaStuff,
199  * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
200  *
201  * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
202  *
203  * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
204  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
205  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
206  * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
207  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
208  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
209  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
210  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
211  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
212  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
213  * POSSIBILITY OF SUCH DAMAGE.
214  *
215  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
216  */
Popular Tags