Java > Open Source Codes > org > dom4j > io > SAXWriter


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.io;
9
10 import java.io.IOException ;
11 import java.util.HashMap ;
12 import java.util.Iterator ;
13 import java.util.List ;
14 import java.util.Map ;
15
16 import org.dom4j.Attribute;
17 import org.dom4j.Branch;
18 import org.dom4j.CDATA;
19 import org.dom4j.CharacterData;
20 import org.dom4j.Comment;
21 import org.dom4j.Document;
22 import org.dom4j.DocumentType;
23 import org.dom4j.Element;
24 import org.dom4j.Entity;
25 import org.dom4j.Namespace;
26 import org.dom4j.Node;
27 import org.dom4j.ProcessingInstruction;
28 import org.dom4j.Text;
29 import org.dom4j.tree.NamespaceStack;
30
31 import org.xml.sax.Attributes ;
32 import org.xml.sax.ContentHandler ;
33 import org.xml.sax.DTDHandler ;
34 import org.xml.sax.EntityResolver ;
35 import org.xml.sax.ErrorHandler ;
36 import org.xml.sax.InputSource ;
37 import org.xml.sax.SAXException ;
38 import org.xml.sax.SAXNotRecognizedException ;
39 import org.xml.sax.SAXNotSupportedException ;
40 import org.xml.sax.XMLReader ;
41 import org.xml.sax.ext.LexicalHandler ;
42 import org.xml.sax.helpers.AttributesImpl ;
43 import org.xml.sax.helpers.LocatorImpl ;
44
45 /**
46  * <p>
47  * <code>SAXWriter</code> writes a DOM4J tree to a SAX ContentHandler.
48  * </p>
49  *
50  * @author <a HREF="mailto:james.strachan@metastuff.com">James Strachan </a>
51  * @version $Revision: 1.24 $
52  */
53 public class SAXWriter implements XMLReader {
54     protected static final String [] LEXICAL_HANDLER_NAMES = {
55             "http://xml.org/sax/properties/lexical-handler",
56             "http://xml.org/sax/handlers/LexicalHandler" };
57
58     protected static final String FEATURE_NAMESPACE_PREFIXES
59             = "http://xml.org/sax/features/namespace-prefixes";
60
61     protected static final String FEATURE_NAMESPACES
62             = "http://xml.org/sax/features/namespaces";
63
64     /** <code>ContentHandler</code> to which SAX events are raised */
65     private ContentHandler contentHandler;
66
67     /** <code>DTDHandler</code> fired when a document has a DTD */
68     private DTDHandler dtdHandler;
69
70     /** <code>EntityResolver</code> fired when a document has a DTD */
71     private EntityResolver entityResolver;
72
73     private ErrorHandler errorHandler;
74
75     /** <code>LexicalHandler</code> fired on Entity and CDATA sections */
76     private LexicalHandler lexicalHandler;
77
78     /** <code>AttributesImpl</code> used when generating the Attributes */
79     private AttributesImpl attributes = new AttributesImpl ();
80
81     /** Stores the features */
82     private Map features = new HashMap ();
83
84     /** Stores the properties */
85     private Map properties = new HashMap ();
86
87     /** Whether namespace declarations are exported as attributes or not */
88     private boolean declareNamespaceAttributes;
89
90     public SAXWriter() {
91         properties.put(FEATURE_NAMESPACE_PREFIXES, Boolean.FALSE);
92         properties.put(FEATURE_NAMESPACE_PREFIXES, Boolean.TRUE);
93     }
94
95     public SAXWriter(ContentHandler contentHandler) {
96         this();
97         this.contentHandler = contentHandler;
98     }
99
100     public SAXWriter(ContentHandler contentHandler,
101             LexicalHandler lexicalHandler) {
102         this();
103         this.contentHandler = contentHandler;
104         this.lexicalHandler = lexicalHandler;
105     }
106
107     public SAXWriter(ContentHandler contentHandler,
108             LexicalHandler lexicalHandler, EntityResolver entityResolver) {
109         this();
110         this.contentHandler = contentHandler;
111         this.lexicalHandler = lexicalHandler;
112         this.entityResolver = entityResolver;
113     }
114
115     /**
116      * A polymorphic method to write any Node to this SAX stream
117      *
118      * @param node
119      * DOCUMENT ME!
120      *
121      * @throws SAXException
122      * DOCUMENT ME!
123      */
124     public void write(Node node) throws SAXException {
125         int nodeType = node.getNodeType();
126
127         switch (nodeType) {
128             case Node.ELEMENT_NODE:
129                 write((Element) node);
130
131                 break;
132
133             case Node.ATTRIBUTE_NODE:
134                 write((Attribute) node);
135
136                 break;
137
138             case Node.TEXT_NODE:
139                 write(node.getText());
140
141                 break;
142
143             case Node.CDATA_SECTION_NODE:
144                 write((CDATA) node);
145
146                 break;
147
148             case Node.ENTITY_REFERENCE_NODE:
149                 write((Entity) node);
150
151                 break;
152
153             case Node.PROCESSING_INSTRUCTION_NODE:
154                 write((ProcessingInstruction) node);
155
156                 break;
157
158             case Node.COMMENT_NODE:
159                 write((Comment) node);
160
161                 break;
162
163             case Node.DOCUMENT_NODE:
164                 write((Document) node);
165
166                 break;
167
168             case Node.DOCUMENT_TYPE_NODE:
169                 write((DocumentType) node);
170
171                 break;
172
173             case Node.NAMESPACE_NODE:
174
175                 // Will be output with attributes
176 // write((Namespace) node);
177 break;
178
179             default:
180                 throw new SAXException ("Invalid node type: " + node);
181         }
182     }
183
184     /**
185      * Generates SAX events for the given Document and all its content
186      *
187      * @param document
188      * is the Document to parse
189      *
190      * @throws SAXException
191      * if there is a SAX error processing the events
192      */
193     public void write(Document document) throws SAXException {
194         if (document != null) {
195             checkForNullHandlers();
196
197             documentLocator(document);
198             startDocument();
199             entityResolver(document);
200             dtdHandler(document);
201
202             writeContent(document, new NamespaceStack());
203             endDocument();
204         }
205     }
206
207     /**
208      * Generates SAX events for the given Element and all its content
209      *
210      * @param element
211      * is the Element to parse
212      *
213      * @throws SAXException
214      * if there is a SAX error processing the events
215      */
216     public void write(Element element) throws SAXException {
217         write(element, new NamespaceStack());
218     }
219
220     /**
221      * <p>
222      * Writes the opening tag of an {@link Element}, including its {@link
223      * Attribute}s but without its content.
224      * </p>
225      *
226      * @param element
227      * <code>Element</code> to output.
228      *
229      * @throws SAXException
230      * DOCUMENT ME!
231      */
232     public void writeOpen(Element element) throws SAXException {
233         startElement(element, null);
234     }
235
236     /**
237      * <p>
238      * Writes the closing tag of an {@link Element}
239      * </p>
240      *
241      * @param element
242      * <code>Element</code> to output.
243      *
244      * @throws SAXException
245      * DOCUMENT ME!
246      */
247     public void writeClose(Element element) throws SAXException {
248         endElement(element);
249     }
250
251     /**
252      * Generates SAX events for the given text
253      *
254      * @param text
255      * is the text to send to the SAX ContentHandler
256      *
257      * @throws SAXException
258      * if there is a SAX error processing the events
259      */
260     public void write(String text) throws SAXException {
261         if (text != null) {
262             char[] chars = text.toCharArray();
263             contentHandler.characters(chars, 0, chars.length);
264         }
265     }
266
267     /**
268      * Generates SAX events for the given CDATA
269      *
270      * @param cdata
271      * is the CDATA to parse
272      *
273      * @throws SAXException
274      * if there is a SAX error processing the events
275      */
276     public void write(CDATA cdata) throws SAXException {
277         String text = cdata.getText();
278
279         if (lexicalHandler != null) {
280             lexicalHandler.startCDATA();
281             write(text);
282             lexicalHandler.endCDATA();
283         } else {
284             write(text);
285         }
286     }
287
288     /**
289      * Generates SAX events for the given Comment
290      *
291      * @param comment
292      * is the Comment to parse
293      *
294      * @throws SAXException
295      * if there is a SAX error processing the events
296      */
297     public void write(Comment comment) throws SAXException {
298         if (lexicalHandler != null) {
299             String text = comment.getText();
300             char[] chars = text.toCharArray();
301             lexicalHandler.comment(chars, 0, chars.length);
302         }
303     }
304
305     /**
306      * Generates SAX events for the given Entity
307      *
308      * @param entity
309      * is the Entity to parse
310      *
311      * @throws SAXException
312      * if there is a SAX error processing the events
313      */
314     public void write(Entity entity) throws SAXException {
315         String text = entity.getText();
316
317         if (lexicalHandler != null) {
318             String name = entity.getName();
319             lexicalHandler.startEntity(name);
320             write(text);
321             lexicalHandler.endEntity(name);
322         } else {
323             write(text);
324         }
325     }
326
327     /**
328      * Generates SAX events for the given ProcessingInstruction
329      *
330      * @param pi
331      * is the ProcessingInstruction to parse
332      *
333      * @throws SAXException
334      * if there is a SAX error processing the events
335      */
336     public void write(ProcessingInstruction pi) throws SAXException {
337         String target = pi.getTarget();
338         String text = pi.getText();
339         contentHandler.processingInstruction(target, text);
340     }
341
342     /**
343      * Should namespace declarations be converted to "xmlns" attributes. This
344      * property defaults to <code>false</code> as per the SAX specification.
345      * This property is set via the SAX feature
346      * "http://xml.org/sax/features/namespace-prefixes"
347      *
348      * @return DOCUMENT ME!
349      */
350     public boolean isDeclareNamespaceAttributes() {
351         return declareNamespaceAttributes;
352     }
353
354     /**
355      * Sets whether namespace declarations should be exported as "xmlns"
356      * attributes or not. This property is set from the SAX feature
357      * "http://xml.org/sax/features/namespace-prefixes"
358      *
359      * @param declareNamespaceAttrs
360      * DOCUMENT ME!
361      */
362     public void setDeclareNamespaceAttributes(boolean declareNamespaceAttrs) {
363         this.declareNamespaceAttributes = declareNamespaceAttrs;
364     }
365
366     // XMLReader methods
367 // -------------------------------------------------------------------------
368
369     /**
370      * DOCUMENT ME!
371      *
372      * @return the <code>ContentHandler</code> called when SAX events are
373      * raised
374      */
375     public ContentHandler getContentHandler() {
376         return contentHandler;
377     }
378
379     /**
380      * Sets the <code>ContentHandler</code> called when SAX events are raised
381      *
382      * @param contentHandler
383      * is the <code>ContentHandler</code> called when SAX events
384      * are raised
385      */
386     public void setContentHandler(ContentHandler contentHandler) {
387         this.contentHandler = contentHandler;
388     }
389
390     /**
391      * DOCUMENT ME!
392      *
393      * @return the <code>DTDHandler</code>
394      */
395     public DTDHandler getDTDHandler() {
396         return dtdHandler;
397     }
398
399     /**
400      * Sets the <code>DTDHandler</code>.
401      *
402      * @param handler
403      * DOCUMENT ME!
404      */
405     public void setDTDHandler(DTDHandler handler) {
406         this.dtdHandler = handler;
407     }
408
409     /**
410      * DOCUMENT ME!
411      *
412      * @return the <code>ErrorHandler</code>
413      */
414     public ErrorHandler getErrorHandler() {
415         return errorHandler;
416     }
417
418     /**
419      * Sets the <code>ErrorHandler</code>.
420      *
421      * @param errorHandler
422      * DOCUMENT ME!
423      */
424     public void setErrorHandler(ErrorHandler errorHandler) {
425         this.errorHandler = errorHandler;
426     }
427
428     /**
429      * DOCUMENT ME!
430      *
431      * @return the <code>EntityResolver</code> used when a Document contains a
432      * DTD
433      */
434     public EntityResolver getEntityResolver() {
435         return entityResolver;
436     }
437
438     /**
439      * Sets the <code>EntityResolver</code>.
440      *
441      * @param entityResolver
442      * is the <code>EntityResolver</code>
443      */
444     public void setEntityResolver(EntityResolver entityResolver) {
445         this.entityResolver = entityResolver;
446     }
447
448     /**
449      * DOCUMENT ME!
450      *
451      * @return the <code>LexicalHandler</code> used when a Document contains a
452      * DTD
453      */
454     public LexicalHandler getLexicalHandler() {
455         return lexicalHandler;
456     }
457
458     /**
459      * Sets the <code>LexicalHandler</code>.
460      *
461      * @param lexicalHandler
462      * is the <code>LexicalHandler</code>
463      */
464     public void setLexicalHandler(LexicalHandler lexicalHandler) {
465         this.lexicalHandler = lexicalHandler;
466     }
467
468     /**
469      * Sets the <code>XMLReader</code> used to write SAX events to
470      *
471      * @param xmlReader
472      * is the <code>XMLReader</code>
473      */
474     public void setXMLReader(XMLReader xmlReader) {
475         setContentHandler(xmlReader.getContentHandler());
476         setDTDHandler(xmlReader.getDTDHandler());
477         setEntityResolver(xmlReader.getEntityResolver());
478         setErrorHandler(xmlReader.getErrorHandler());
479     }
480
481     /**
482      * Looks up the value of a feature.
483      *
484      * @param name
485      * DOCUMENT ME!
486      *
487      * @return DOCUMENT ME!
488      *
489      * @throws SAXNotRecognizedException
490      * DOCUMENT ME!
491      * @throws SAXNotSupportedException
492      * DOCUMENT ME!
493      */
494     public boolean getFeature(String name) throws SAXNotRecognizedException ,
495             SAXNotSupportedException {
496         Boolean answer = (Boolean ) features.get(name);
497
498         return (answer != null) && answer.booleanValue();
499     }
500
501     /**
502      * This implementation does actually use any features but just stores them
503      * for later retrieval
504      *
505      * @param name
506      * DOCUMENT ME!
507      * @param value
508      * DOCUMENT ME!
509      *
510      * @throws SAXNotRecognizedException
511      * DOCUMENT ME!
512      * @throws SAXNotSupportedException
513      * DOCUMENT ME!
514      */
515     public void setFeature(String name, boolean value)
516             throws SAXNotRecognizedException , SAXNotSupportedException {
517         if (FEATURE_NAMESPACE_PREFIXES.equals(name)) {
518             setDeclareNamespaceAttributes(value);
519         } else if (FEATURE_NAMESPACE_PREFIXES.equals(name)) {
520             if (!value) {
521                 String msg = "Namespace feature is always supported in dom4j";
522                 throw new SAXNotSupportedException (msg);
523             }
524         }
525
526         features.put(name, (value) ? Boolean.TRUE : Boolean.FALSE);
527     }
528
529     /**
530      * Sets the given SAX property
531      *
532      * @param name
533      * DOCUMENT ME!
534      * @param value
535      * DOCUMENT ME!
536      */
537     public void setProperty(String name, Object value) {
538         for (int i = 0; i < LEXICAL_HANDLER_NAMES.length; i++) {
539             if (LEXICAL_HANDLER_NAMES[i].equals(name)) {
540                 setLexicalHandler((LexicalHandler ) value);
541
542                 return;
543             }
544         }
545
546         properties.put(name, value);
547     }
548
549     /**
550      * Gets the given SAX property
551      *
552      * @param name
553      * DOCUMENT ME!
554      *
555      * @return DOCUMENT ME!
556      *
557      * @throws SAXNotRecognizedException
558      * DOCUMENT ME!
559      * @throws SAXNotSupportedException
560      * DOCUMENT ME!
561      */
562     public Object getProperty(String name) throws SAXNotRecognizedException ,
563             SAXNotSupportedException {
564         for (int i = 0; i < LEXICAL_HANDLER_NAMES.length; i++) {
565             if (LEXICAL_HANDLER_NAMES[i].equals(name)) {
566                 return getLexicalHandler();
567             }
568         }
569
570         return properties.get(name);
571     }
572
573     /**
574      * This method is not supported.
575      *
576      * @param systemId
577      * DOCUMENT ME!
578      *
579      * @throws SAXNotSupportedException
580      * DOCUMENT ME!
581      */
582     public void parse(String systemId) throws SAXNotSupportedException {
583         throw new SAXNotSupportedException ("This XMLReader can only accept"
584                 + " <dom4j> InputSource objects");
585     }
586
587     /**
588      * Parses an XML document. This method can only accept DocumentInputSource
589      * inputs otherwise a {@link SAXNotSupportedException}exception is thrown.
590      *
591      * @param input
592      * DOCUMENT ME!
593      *
594      * @throws SAXException
595      * DOCUMENT ME!
596      * @throws SAXNotSupportedException
597      * if the input source is not wrapping a dom4j document
598      */
599     public void parse(InputSource input) throws SAXException {
600         if (input instanceof DocumentInputSource) {
601             DocumentInputSource documentInput = (DocumentInputSource) input;
602             Document document = documentInput.getDocument();
603             write(document);
604         } else {
605             throw new SAXNotSupportedException (
606                     "This XMLReader can only accept "
607                             + "<dom4j> InputSource objects");
608         }
609     }
610
611     // Implementation methods
612 // -------------------------------------------------------------------------
613 protected void writeContent(Branch branch, NamespaceStack namespaceStack)
614             throws SAXException {
615         for (Iterator iter = branch.nodeIterator(); iter.hasNext();) {
616             Object object = iter.next();
617
618             if (object instanceof Element) {
619                 write((Element) object, namespaceStack);
620             } else if (object instanceof CharacterData) {
621                 if (object instanceof Text) {
622                     Text text = (Text) object;
623                     write(text.getText());
624                 } else if (object instanceof CDATA) {
625                     write((CDATA) object);
626                 } else if (object instanceof Comment) {
627                     write((Comment) object);
628                 } else {
629                     throw new SAXException ("Invalid Node in DOM4J content: "
630                             + object + " of type: " + object.getClass());
631                 }
632             } else if (object instanceof String ) {
633                 write((String ) object);
634             } else if (object instanceof Entity) {
635                 write((Entity) object);
636             } else if (object instanceof ProcessingInstruction) {
637                 write((ProcessingInstruction) object);
638             } else if (object instanceof Namespace) {
639                 write((Namespace) object);
640             } else {
641                 throw new SAXException ("Invalid Node in DOM4J content: "
642                         + object);
643             }
644         }
645     }
646
647     /**
648      * The {@link org.xml.sax.Locator}is only really useful when parsing a
649      * textual document as its main purpose is to identify the line and column
650      * number. Since we are processing an in memory tree which will probably
651      * have its line number information removed, we'll just use -1 for the line
652      * and column numbers.
653      *
654      * @param document
655      * DOCUMENT ME!
656      *
657      * @throws SAXException
658      * DOCUMENT ME!
659      */
660     protected void documentLocator(Document document) throws SAXException {
661         LocatorImpl locator = new LocatorImpl ();
662
663         String publicID = null;
664         String systemID = null;
665         DocumentType docType = document.getDocType();
666
667         if (docType != null) {
668             publicID = docType.getPublicID();
669             systemID = docType.getSystemID();
670         }
671
672         if (publicID != null) {
673             locator.setPublicId(publicID);
674         }
675
676         if (systemID != null) {
677             locator.setSystemId(systemID);
678         }
679
680         locator.setLineNumber(-1);
681         locator.setColumnNumber(-1);
682
683         contentHandler.setDocumentLocator(locator);
684     }
685
686     protected void entityResolver(Document document) throws SAXException {
687         if (entityResolver != null) {
688             DocumentType docType = document.getDocType();
689
690             if (docType != null) {
691                 String publicID = docType.getPublicID();
692                 String systemID = docType.getSystemID();
693
694                 if ((publicID != null) || (systemID != null)) {
695                     try {
696                         entityResolver.resolveEntity(publicID, systemID);
697                     } catch (IOException e) {
698                         throw new SAXException ("Could not resolve publicID: "
699                                 + publicID + " systemID: " + systemID, e);
700                     }
701                 }
702             }
703         }
704     }
705
706     /**
707      * We do not yet support DTD or XML Schemas so this method does nothing
708      * right now.
709      *
710      * @param document
711      * DOCUMENT ME!
712      *
713      * @throws SAXException
714      * DOCUMENT ME!
715      */
716     protected void dtdHandler(Document document) throws SAXException {
717     }
718
719     protected void startDocument() throws SAXException {
720         contentHandler.startDocument();
721     }
722
723     protected void endDocument() throws SAXException {
724         contentHandler.endDocument();
725     }
726
727     protected void write(Element element, NamespaceStack namespaceStack)
728             throws SAXException {
729         int stackSize = namespaceStack.size();
730         AttributesImpl namespaceAttributes = startPrefixMapping(element,
731                 namespaceStack);
732         startElement(element, namespaceAttributes);
733         writeContent(element, namespaceStack);
734         endElement(element);
735         endPrefixMapping(namespaceStack, stackSize);
736     }
737
738     /**
739      * Fires a SAX startPrefixMapping event for all the namespaceStack which
740      * have just come into scope
741      *
742      * @param element
743      * DOCUMENT ME!
744      * @param namespaceStack
745      * DOCUMENT ME!
746      *
747      * @return DOCUMENT ME!
748      *
749      * @throws SAXException
750      * DOCUMENT ME!
751      */
752     protected AttributesImpl startPrefixMapping(Element element,
753             NamespaceStack namespaceStack) throws SAXException {
754         AttributesImpl namespaceAttributes = null;
755
756         // start with the namespace of the element
757 Namespace elementNamespace = element.getNamespace();
758
759         if ((elementNamespace != null)
760                 && !isIgnoreableNamespace(elementNamespace, namespaceStack)) {
761             namespaceStack.push(elementNamespace);
762             contentHandler.startPrefixMapping(elementNamespace.getPrefix(),
763                     elementNamespace.getURI());
764             namespaceAttributes = addNamespaceAttribute(namespaceAttributes,
765                     elementNamespace);
766         }
767
768         List declaredNamespaces = element.declaredNamespaces();
769
770         for (int i = 0, size = declaredNamespaces.size(); i < size; i++) {
771             Namespace namespace = (Namespace) declaredNamespaces.get(i);
772
773             if (!isIgnoreableNamespace(namespace, namespaceStack)) {
774                 namespaceStack.push(namespace);
775                 contentHandler.startPrefixMapping(namespace.getPrefix(),
776                         namespace.getURI());
777                 namespaceAttributes = addNamespaceAttribute(
778                         namespaceAttributes, namespace);
779             }
780         }
781
782         return namespaceAttributes;
783     }
784
785     /**
786      * Fires a SAX endPrefixMapping event for all the namespaceStack which have
787      * gone out of scope
788      *
789      * @param stack
790      * DOCUMENT ME!
791      * @param stackSize
792      * DOCUMENT ME!
793      *
794      * @throws SAXException
795      * DOCUMENT ME!
796      */
797     protected void endPrefixMapping(NamespaceStack stack, int stackSize)
798             throws SAXException {
799         while (stack.size() > stackSize) {
800             Namespace namespace = stack.pop();
801
802             if (namespace != null) {
803                 contentHandler.endPrefixMapping(namespace.getPrefix());
804             }
805         }
806     }
807
808     protected void startElement(Element element,
809             AttributesImpl namespaceAttributes) throws SAXException {
810         contentHandler.startElement(element.getNamespaceURI(), element
811                 .getName(), element.getQualifiedName(), createAttributes(
812                 element, namespaceAttributes));
813     }
814
815     protected void endElement(Element element) throws SAXException {
816         contentHandler.endElement(element.getNamespaceURI(), element.getName(),
817                 element.getQualifiedName());
818     }
819
820     protected Attributes createAttributes(Element element,
821             Attributes namespaceAttributes) throws SAXException {
822         attributes.clear();
823
824         if (namespaceAttributes != null) {
825             attributes.setAttributes(namespaceAttributes);
826         }
827
828         for (Iterator iter = element.attributeIterator(); iter.hasNext();) {
829             Attribute attribute = (Attribute) iter.next();
830             attributes.addAttribute(attribute.getNamespaceURI(), attribute
831                     .getName(), attribute.getQualifiedName(), "CDATA",
832                     attribute.getValue());
833         }
834
835         return attributes;
836     }
837
838     /**
839      * If isDelcareNamespaceAttributes() is enabled then this method will add
840      * the given namespace declaration to the supplied attributes object,
841      * creating one if it does not exist.
842      *
843      * @param attrs
844      * DOCUMENT ME!
845      * @param namespace
846      * DOCUMENT ME!
847      *
848      * @return DOCUMENT ME!
849      */
850     protected AttributesImpl addNamespaceAttribute(AttributesImpl attrs,
851             Namespace namespace) {
852         if (declareNamespaceAttributes) {
853             if (attrs == null) {
854                 attrs = new AttributesImpl ();
855             }
856
857             String prefix = namespace.getPrefix();
858             String qualifiedName = "xmlns";
859
860             if ((prefix != null) && (prefix.length() > 0)) {
861                 qualifiedName = "xmlns:" + prefix;
862             }
863
864             String uri = "";
865             String localName = prefix;
866             String type = "CDATA";
867             String value = namespace.getURI();
868
869             attrs.addAttribute(uri, localName, qualifiedName, type, value);
870         }
871
872         return attrs;
873     }
874
875     /**
876      * DOCUMENT ME!
877      *
878      * @param namespace
879      * DOCUMENT ME!
880      * @param namespaceStack
881      * DOCUMENT ME!
882      *
883      * @return true if the given namespace is an ignorable namespace (such as
884      * Namespace.NO_NAMESPACE or Namespace.XML_NAMESPACE) or if the
885      * namespace has already been declared in the current scope
886      */
887     protected boolean isIgnoreableNamespace(Namespace namespace,
888             NamespaceStack namespaceStack) {
889         if (namespace.equals(Namespace.NO_NAMESPACE)
890                 || namespace.equals(Namespace.XML_NAMESPACE)) {
891             return true;
892         }
893
894         String uri = namespace.getURI();
895
896         if ((uri == null) || (uri.length() <= 0)) {
897             return true;
898         }
899
900         return namespaceStack.contains(namespace);
901     }
902
903     /**
904      * Ensures non-null content handlers?
905      */
906     protected void checkForNullHandlers() {
907     }
908 }
909
910 /*
911  * Redistribution and use of this software and associated documentation
912  * ("Software"), with or without modification, are permitted provided that the
913  * following conditions are met:
914  *
915  * 1. Redistributions of source code must retain copyright statements and
916  * notices. Redistributions must also contain a copy of this document.
917  *
918  * 2. Redistributions in binary form must reproduce the above copyright notice,
919  * this list of conditions and the following disclaimer in the documentation
920  * and/or other materials provided with the distribution.
921  *
922  * 3. The name "DOM4J" must not be used to endorse or promote products derived
923  * from this Software without prior written permission of MetaStuff, Ltd. For
924  * written permission, please contact dom4j-info@metastuff.com.
925  *
926  * 4. Products derived from this Software may not be called "DOM4J" nor may
927  * "DOM4J" appear in their names without prior written permission of MetaStuff,
928  * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
929  *
930  * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
931  *
932  * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
933  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
934  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
935  * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
936  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
937  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
938  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
939  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
940  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
941  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
942  * POSSIBILITY OF SUCH DAMAGE.
943  *
944  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
945  */
946

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags