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


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.lang.reflect.Method ;
11 import java.util.ArrayList ;
12 import java.util.HashMap ;
13 import java.util.List ;
14 import java.util.Map ;
15
16 import org.dom4j.Branch;
17 import org.dom4j.Document;
18 import org.dom4j.DocumentFactory;
19 import org.dom4j.DocumentType;
20 import org.dom4j.Element;
21 import org.dom4j.ElementHandler;
22 import org.dom4j.Namespace;
23 import org.dom4j.QName;
24 import org.dom4j.dtd.AttributeDecl;
25 import org.dom4j.dtd.ElementDecl;
26 import org.dom4j.dtd.ExternalEntityDecl;
27 import org.dom4j.dtd.InternalEntityDecl;
28 import org.dom4j.tree.AbstractElement;
29 import org.dom4j.tree.NamespaceStack;
30
31 import org.xml.sax.Attributes ;
32 import org.xml.sax.DTDHandler ;
33 import org.xml.sax.EntityResolver ;
34 import org.xml.sax.InputSource ;
35 import org.xml.sax.Locator ;
36 import org.xml.sax.SAXException ;
37 import org.xml.sax.SAXParseException ;
38 import org.xml.sax.ext.DeclHandler ;
39 import org.xml.sax.ext.LexicalHandler ;
40 import org.xml.sax.helpers.DefaultHandler ;
41
42 /**
43  * <p>
44  * <code>SAXContentHandler</code> builds a dom4j tree via SAX events.
45  * </p>
46  *
47  * @author <a HREF="mailto:jstrachan@apache.org">James Strachan </a>
48  * @version $Revision: 1.61 $
49  */
50 public class SAXContentHandler extends DefaultHandler implements
51         LexicalHandler , DeclHandler , DTDHandler {
52     /** The factory used to create new <code>Document</code> instances */
53     private DocumentFactory documentFactory;
54
55     /** The document that is being built */
56     private Document document;
57
58     /** stack of <code>Element</code> objects */
59     private ElementStack elementStack;
60
61     /** stack of <code>Namespace</code> and <code>QName</code> objects */
62     private NamespaceStack namespaceStack;
63
64     /** the <code>ElementHandler</code> called as the elements are complete */
65     private ElementHandler elementHandler;
66
67     /** the Locator */
68     private Locator locator;
69
70     /** The name of the current entity */
71     private String entity;
72
73     /** Flag used to indicate that we are inside a DTD section */
74     private boolean insideDTDSection;
75
76     /** Flag used to indicate that we are inside a CDATA section */
77     private boolean insideCDATASection;
78
79     /**
80      * buffer to hold contents of cdata section across multiple characters
81      * events
82      */
83     private StringBuffer cdataText;
84
85     /** namespaces that are available for use */
86     private Map availableNamespaceMap = new HashMap ();
87
88     /** declared namespaces that are not yet available for use */
89     private List declaredNamespaceList = new ArrayList ();
90
91     /** internal DTD declarations */
92     private List internalDTDDeclarations;
93
94     /** external DTD declarations */
95     private List externalDTDDeclarations;
96
97     /** The number of namespaces that are declared in the current scope */
98     private int declaredNamespaceIndex;
99
100     /** The entity resolver */
101     private EntityResolver entityResolver;
102
103     private InputSource inputSource;
104
105     /** The current element we are on */
106     private Element currentElement;
107
108     /** Should internal DTD declarations be expanded into a List in the DTD */
109     private boolean includeInternalDTDDeclarations = false;
110
111     /** Should external DTD declarations be expanded into a List in the DTD */
112     private boolean includeExternalDTDDeclarations = false;
113
114     /** The number of levels deep we are inside a startEntity/endEntity call */
115     private int entityLevel;
116
117     /** Are we in an internal DTD subset? */
118     private boolean internalDTDsubset = false;
119
120     /** Whether adjacent text nodes should be merged */
121     private boolean mergeAdjacentText = false;
122
123     /** Have we added text to the buffer */
124     private boolean textInTextBuffer = false;
125
126     /** Should we ignore comments */
127     private boolean ignoreComments = false;
128
129     /** Buffer used to concatenate text together */
130     private StringBuffer textBuffer;
131
132     /** Holds value of property stripWhitespaceText. */
133     private boolean stripWhitespaceText = false;
134
135     public SAXContentHandler() {
136         this(DocumentFactory.getInstance());
137     }
138
139     public SAXContentHandler(DocumentFactory documentFactory) {
140         this(documentFactory, null);
141     }
142
143     public SAXContentHandler(DocumentFactory documentFactory,
144             ElementHandler elementHandler) {
145         this(documentFactory, elementHandler, null);
146         this.elementStack = createElementStack();
147     }
148
149     public SAXContentHandler(DocumentFactory documentFactory,
150             ElementHandler elementHandler, ElementStack elementStack) {
151         this.documentFactory = documentFactory;
152         this.elementHandler = elementHandler;
153         this.elementStack = elementStack;
154         this.namespaceStack = new NamespaceStack(documentFactory);
155     }
156
157     /**
158      * DOCUMENT ME!
159      *
160      * @return the document that has been or is being built
161      */
162     public Document getDocument() {
163         if (document == null) {
164             document = createDocument();
165         }
166
167         return document;
168     }
169
170     // ContentHandler interface
171 // -------------------------------------------------------------------------
172 public void setDocumentLocator(Locator documentLocator) {
173         this.locator = documentLocator;
174     }
175
176     public void processingInstruction(String target, String data)
177             throws SAXException {
178         if (mergeAdjacentText && textInTextBuffer) {
179             completeCurrentTextNode();
180         }
181
182         if (currentElement != null) {
183             currentElement.addProcessingInstruction(target, data);
184         } else {
185             getDocument().addProcessingInstruction(target, data);
186         }
187     }
188
189     public void startPrefixMapping(String prefix, String uri)
190             throws SAXException {
191         namespaceStack.push(prefix, uri);
192     }
193
194     public void endPrefixMapping(String prefix) throws SAXException {
195         namespaceStack.pop(prefix);
196         declaredNamespaceIndex = namespaceStack.size();
197     }
198
199     public void startDocument() throws SAXException {
200         // document = createDocument();
201 document = null;
202         currentElement = null;
203
204         elementStack.clear();
205
206         if ((elementHandler != null)
207                 && (elementHandler instanceof DispatchHandler)) {
208             elementStack.setDispatchHandler((DispatchHandler) elementHandler);
209         }
210
211         namespaceStack.clear();
212         declaredNamespaceIndex = 0;
213
214         if (mergeAdjacentText && (textBuffer == null)) {
215             textBuffer = new StringBuffer ();
216         }
217
218         textInTextBuffer = false;
219     }
220
221     public void endDocument() throws SAXException {
222         namespaceStack.clear();
223         elementStack.clear();
224         currentElement = null;
225         textBuffer = null;
226     }
227
228     public void startElement(String namespaceURI, String localName,
229             String qualifiedName, Attributes attributes) throws SAXException {
230         if (mergeAdjacentText && textInTextBuffer) {
231             completeCurrentTextNode();
232         }
233
234         QName qName = namespaceStack.getQName(namespaceURI, localName,
235                 qualifiedName);
236
237         Branch branch = currentElement;
238
239         if (branch == null) {
240             branch = getDocument();
241         }
242
243         Element element = branch.addElement(qName);
244
245         // add all declared namespaces
246 addDeclaredNamespaces(element);
247
248         // now lets add all attribute values
249 addAttributes(element, attributes);
250
251         elementStack.pushElement(element);
252         currentElement = element;
253
254         entity = null; // fixes bug527062
255
256         if (elementHandler != null) {
257             elementHandler.onStart(elementStack);
258         }
259     }
260
261     public void endElement(String namespaceURI, String localName, String qName)
262             throws SAXException {
263         if (mergeAdjacentText && textInTextBuffer) {
264             completeCurrentTextNode();
265         }
266
267         if ((elementHandler != null) && (currentElement != null)) {
268             elementHandler.onEnd(elementStack);
269         }
270
271         elementStack.popElement();
272         currentElement = elementStack.peekElement();
273     }
274
275     public void characters(char[] ch, int start, int end) throws SAXException {
276         if (end == 0) {
277             return;
278         }
279
280         if (currentElement != null) {
281             if (entity != null) {
282                 if (mergeAdjacentText && textInTextBuffer) {
283                     completeCurrentTextNode();
284                 }
285
286                 currentElement.addEntity(entity, new String (ch, start, end));
287                 entity = null;
288             } else if (insideCDATASection) {
289                 if (mergeAdjacentText && textInTextBuffer) {
290                     completeCurrentTextNode();
291                 }
292
293                 cdataText.append(new String (ch, start, end));
294             } else {
295                 if (mergeAdjacentText) {
296                     textBuffer.append(ch, start, end);
297                     textInTextBuffer = true;
298                 } else {
299                     currentElement.addText(new String (ch, start, end));
300                 }
301             }
302         }
303     }
304
305     // ErrorHandler interface
306 // -------------------------------------------------------------------------
307
308     /**
309      * This method is called when a warning occurs during the parsing of the
310      * document. This method does nothing.
311      *
312      * @param exception
313      * DOCUMENT ME!
314      *
315      * @throws SAXException
316      * DOCUMENT ME!
317      */
318     public void warning(SAXParseException exception) throws SAXException {
319         // ignore warnings by default
320 }
321
322     /**
323      * This method is called when an error is detected during parsing such as a
324      * validation error. This method rethrows the exception
325      *
326      * @param exception
327      * DOCUMENT ME!
328      *
329      * @throws SAXException
330      * DOCUMENT ME!
331      */
332     public void error(SAXParseException exception) throws SAXException {
333         throw exception;
334     }
335
336     /**
337      * This method is called when a fatal error occurs during parsing. This
338      * method rethrows the exception
339      *
340      * @param exception
341      * DOCUMENT ME!
342      *
343      * @throws SAXException
344      * DOCUMENT ME!
345      */
346     public void fatalError(SAXParseException exception) throws SAXException {
347         throw exception;
348     }
349
350     // LexicalHandler interface
351 // -------------------------------------------------------------------------
352 public void startDTD(String name, String publicId, String systemId)
353             throws SAXException {
354         getDocument().addDocType(name, publicId, systemId);
355         insideDTDSection = true;
356         internalDTDsubset = true;
357     }
358
359     public void endDTD() throws SAXException {
360         insideDTDSection = false;
361
362         DocumentType docType = getDocument().getDocType();
363
364         if (docType != null) {
365             if (internalDTDDeclarations != null) {
366                 docType.setInternalDeclarations(internalDTDDeclarations);
367             }
368
369             if (externalDTDDeclarations != null) {
370                 docType.setExternalDeclarations(externalDTDDeclarations);
371             }
372         }
373
374         internalDTDDeclarations = null;
375         externalDTDDeclarations = null;
376     }
377
378     public void startEntity(String name) throws SAXException {
379         ++entityLevel;
380
381         // Ignore DTD references
382 entity = null;
383
384         if (!insideDTDSection) {
385             if (!isIgnorableEntity(name)) {
386                 entity = name;
387             }
388         }
389
390         // internal DTD subsets can only appear outside of a
391 // startEntity/endEntity block
392 // see the startDTD method in
393 // http://dom4j.org/javadoc/org/xml/sax/ext/LexicalHandler.html
394 internalDTDsubset = false;
395     }
396
397     public void endEntity(String name) throws SAXException {
398         --entityLevel;
399         entity = null;
400
401         if (entityLevel == 0) {
402             internalDTDsubset = true;
403         }
404     }
405
406     public void startCDATA() throws SAXException {
407         insideCDATASection = true;
408         cdataText = new StringBuffer ();
409     }
410
411     public void endCDATA() throws SAXException {
412         insideCDATASection = false;
413         currentElement.addCDATA(cdataText.toString());
414     }
415
416     public void comment(char[] ch, int start, int end) throws SAXException {
417         if (!ignoreComments) {
418             if (mergeAdjacentText && textInTextBuffer) {
419                 completeCurrentTextNode();
420             }
421
422             String text = new String (ch, start, end);
423
424             if (!insideDTDSection && (text.length() > 0)) {
425                 if (currentElement != null) {
426                     currentElement.addComment(text);
427                 } else {
428                     getDocument().addComment(text);
429                 }
430             }
431         }
432     }
433
434     // DeclHandler interface
435 // -------------------------------------------------------------------------
436
437     /**
438      * Report an element type declaration.
439      *
440      * <p>
441      * The content model will consist of the string "EMPTY", the string "ANY",
442      * or a parenthesised group, optionally followed by an occurrence indicator.
443      * The model will be normalized so that all parameter entities are fully
444      * resolved and all whitespace is removed,and will include the enclosing
445      * parentheses. Other normalization (such as removing redundant parentheses
446      * or simplifying occurrence indicators) is at the discretion of the parser.
447      * </p>
448      *
449      * @param name
450      * The element type name.
451      * @param model
452      * The content model as a normalized string.
453      *
454      * @exception SAXException
455      * The application may raise an exception.
456      */
457     public void elementDecl(String name, String model) throws SAXException {
458         if (internalDTDsubset) {
459             if (includeInternalDTDDeclarations) {
460                 addDTDDeclaration(new ElementDecl(name, model));
461             }
462         } else {
463             if (includeExternalDTDDeclarations) {
464                 addExternalDTDDeclaration(new ElementDecl(name, model));
465             }
466         }
467     }
468
469     /**
470      * Report an attribute type declaration.
471      *
472      * <p>
473      * Only the effective (first) declaration for an attribute will be reported.
474      * The type will be one of the strings "CDATA", "ID", "IDREF", "IDREFS",
475      * "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES", a parenthesized token group
476      * with the separator "|" and all whitespace removed, or the word "NOTATION"
477      * followed by a space followed by a parenthesized token group with all
478      * whitespace removed.
479      * </p>
480      *
481      * <p>
482      * Any parameter entities in the attribute value will be expanded, but
483      * general entities will not.
484      * </p>
485      *
486      * @param eName
487      * The name of the associated element.
488      * @param aName
489      * The name of the attribute.
490      * @param type
491      * A string representing the attribute type.
492      * @param valueDefault
493      * A string representing the attribute default ("#IMPLIED",
494      * "#REQUIRED", or "#FIXED") or null if none of these applies.
495      * @param val
496      * A string representing the attribute's default value, or null
497      * if there is none.
498      *
499      * @exception SAXException
500      * The application may raise an exception.
501      */
502     public void attributeDecl(String eName, String aName, String type,
503             String valueDefault, String val) throws SAXException {
504         if (internalDTDsubset) {
505             if (includeInternalDTDDeclarations) {
506                 addDTDDeclaration(new AttributeDecl(eName, aName, type,
507                         valueDefault, val));
508             }
509         } else {
510             if (includeExternalDTDDeclarations) {
511                 addExternalDTDDeclaration(new AttributeDecl(eName, aName, type,
512                         valueDefault, val));
513             }
514         }
515     }
516
517     /**
518      * Report an internal entity declaration.
519      *
520      * <p>
521      * Only the effective (first) declaration for each entity will be reported.
522      * All parameter entities in the value will be expanded, but general
523      * entities will not.
524      * </p>
525      *
526      * @param name
527      * The name of the entity. If it is a parameter entity, the name
528      * will begin with '%'.
529      * @param value
530      * The replacement text of the entity.
531      *
532      * @exception SAXException
533      * The application may raise an exception.
534      *
535      * @see #externalEntityDecl
536      * @see org.xml.sax.DTDHandler#unparsedEntityDecl
537      */
538     public void internalEntityDecl(String name, String value)
539             throws SAXException {
540         if (internalDTDsubset) {
541             if (includeInternalDTDDeclarations) {
542                 addDTDDeclaration(new InternalEntityDecl(name, value));
543             }
544         } else {
545             if (includeExternalDTDDeclarations) {
546                 addExternalDTDDeclaration(new InternalEntityDecl(name, value));
547             }
548         }
549     }
550
551     /**
552      * Report a parsed external entity declaration.
553      *
554      * <p>
555      * Only the effective (first) declaration for each entity will be reported.
556      * </p>
557      *
558      * @param name
559      * The name of the entity. If it is a parameter entity, the name
560      * will begin with '%'.
561      * @param publicId
562      * The declared public identifier of the entity, or null if none
563      * was declared.
564      * @param sysId
565      * The declared system identifier of the entity.
566      *
567      * @exception SAXException
568      * The application may raise an exception.
569      *
570      * @see #internalEntityDecl
571      * @see org.xml.sax.DTDHandler#unparsedEntityDecl
572      */
573     public void externalEntityDecl(String name, String publicId, String sysId)
574             throws SAXException {
575         ExternalEntityDecl declaration = new ExternalEntityDecl(name, publicId,
576                 sysId);
577
578         if (internalDTDsubset) {
579             if (includeInternalDTDDeclarations) {
580                 addDTDDeclaration(declaration);
581             }
582         } else {
583             if (includeExternalDTDDeclarations) {
584                 addExternalDTDDeclaration(declaration);
585             }
586         }
587     }
588
589     // DTDHandler interface
590 // -------------------------------------------------------------------------
591
592     /**
593      * Receive notification of a notation declaration event.
594      *
595      * <p>
596      * It is up to the application to record the notation for later reference,
597      * if necessary.
598      * </p>
599      *
600      * <p>
601      * At least one of publicId and systemId must be non-null. If a system
602      * identifier is present, and it is a URL, the SAX parser must resolve it
603      * fully before passing it to the application through this event.
604      * </p>
605      *
606      * <p>
607      * There is no guarantee that the notation declaration will be reported
608      * before any unparsed entities that use it.
609      * </p>
610      *
611      * @param name
612      * The notation name.
613      * @param publicId
614      * The notation's public identifier, or null if none was given.
615      * @param systemId
616      * The notation's system identifier, or null if none was given.
617      *
618      * @exception SAXException
619      * Any SAX exception, possibly wrapping another exception.
620      *
621      * @see #unparsedEntityDecl
622      * @see org.xml.sax.AttributeList
623      */
624     public void notationDecl(String name, String publicId, String systemId)
625             throws SAXException {
626         // #### not supported yet!
627 }
628
629     /**
630      * Receive notification of an unparsed entity declaration event.
631      *
632      * <p>
633      * Note that the notation name corresponds to a notation reported by the
634      * {@link #notationDecl notationDecl}event. It is up to the application to
635      * record the entity for later reference, if necessary.
636      * </p>
637      *
638      * <p>
639      * If the system identifier is a URL, the parser must resolve it fully
640      * before passing it to the application.
641      * </p>
642      *
643      * @param name
644      * The unparsed entity's name.
645      * @param publicId
646      * The entity's public identifier, or null if none was given.
647      * @param systemId
648      * The entity's system identifier.
649      * @param notationName
650      * The name of the associated notation.
651      *
652      * @exception SAXException
653      * Any SAX exception, possibly wrapping another exception.
654      *
655      * @see #notationDecl
656      * @see org.xml.sax.AttributeList
657      */
658     public void unparsedEntityDecl(String name, String publicId,
659             String systemId, String notationName) throws SAXException {
660         // #### not supported yet!
661 }
662
663     // Properties
664 // -------------------------------------------------------------------------
665 public ElementStack getElementStack() {
666         return elementStack;
667     }
668
669     public void setElementStack(ElementStack elementStack) {
670         this.elementStack = elementStack;
671     }
672
673     public EntityResolver getEntityResolver() {
674         return entityResolver;
675     }
676
677     public void setEntityResolver(EntityResolver entityResolver) {
678         this.entityResolver = entityResolver;
679     }
680
681     public InputSource getInputSource() {
682         return inputSource;
683     }
684
685     public void setInputSource(InputSource inputSource) {
686         this.inputSource = inputSource;
687     }
688
689     /**
690      * DOCUMENT ME!
691      *
692      * @return whether internal DTD declarations should be expanded into the
693      * DocumentType object or not.
694      */
695     public boolean isIncludeInternalDTDDeclarations() {
696         return includeInternalDTDDeclarations;
697     }
698
699     /**
700      * Sets whether internal DTD declarations should be expanded into the
701      * DocumentType object or not.
702      *
703      * @param include
704      * whether or not DTD declarations should be expanded and
705      * included into the DocumentType object.
706      */
707     public void setIncludeInternalDTDDeclarations(boolean include) {
708         this.includeInternalDTDDeclarations = include;
709     }
710
711     /**
712      * DOCUMENT ME!
713      *
714      * @return whether external DTD declarations should be expanded into the
715      * DocumentType object or not.
716      */
717     public boolean isIncludeExternalDTDDeclarations() {
718         return includeExternalDTDDeclarations;
719     }
720
721     /**
722      * Sets whether DTD external declarations should be expanded into the
723      * DocumentType object or not.
724      *
725      * @param include
726      * whether or not DTD declarations should be expanded and
727      * included into the DocumentType object.
728      */
729     public void setIncludeExternalDTDDeclarations(boolean include) {
730         this.includeExternalDTDDeclarations = include;
731     }
732
733     /**
734      * Returns whether adjacent text nodes should be merged together.
735      *
736      * @return Value of property mergeAdjacentText.
737      */
738     public boolean isMergeAdjacentText() {
739         return mergeAdjacentText;
740     }
741
742     /**
743      * Sets whether or not adjacent text nodes should be merged together when
744      * parsing.
745      *
746      * @param mergeAdjacentText
747      * New value of property mergeAdjacentText.
748      */
749     public void setMergeAdjacentText(boolean mergeAdjacentText) {
750         this.mergeAdjacentText = mergeAdjacentText;
751     }
752
753     /**
754      * Sets whether whitespace between element start and end tags should be
755      * ignored
756      *
757      * @return Value of property stripWhitespaceText.
758      */
759     public boolean isStripWhitespaceText() {
760         return stripWhitespaceText;
761     }
762
763     /**
764      * Sets whether whitespace between element start and end tags should be
765      * ignored.
766      *
767      * @param stripWhitespaceText
768      * New value of property stripWhitespaceText.
769      */
770     public void setStripWhitespaceText(boolean stripWhitespaceText) {
771         this.stripWhitespaceText = stripWhitespaceText;
772     }
773
774     /**
775      * Returns whether we should ignore comments or not.
776      *
777      * @return boolean
778      */
779     public boolean isIgnoreComments() {
780         return ignoreComments;
781     }
782
783     /**
784      * Sets whether we should ignore comments or not.
785      *
786      * @param ignoreComments
787      * whether we should ignore comments or not.
788      */
789     public void setIgnoreComments(boolean ignoreComments) {
790         this.ignoreComments = ignoreComments;
791     }
792
793     // Implementation methods
794 // -------------------------------------------------------------------------
795
796     /**
797      * If the current text buffer contains any text then create a new text node
798      * with it and add it to the current element
799      */
800     protected void completeCurrentTextNode() {
801         if (stripWhitespaceText) {
802             boolean whitespace = true;
803
804             for (int i = 0, size = textBuffer.length(); i < size; i++) {
805                 if (!Character.isWhitespace(textBuffer.charAt(i))) {
806                     whitespace = false;
807
808                     break;
809                 }
810             }
811
812             if (!whitespace) {
813                 currentElement.addText(textBuffer.toString());
814             }
815         } else {
816             currentElement.addText(textBuffer.toString());
817         }
818
819         textBuffer.setLength(0);
820         textInTextBuffer = false;
821     }
822
823     /**
824      * DOCUMENT ME!
825      *
826      * @return the current document
827      */
828     protected Document createDocument() {
829         String encoding = getEncoding();
830         Document doc = documentFactory.createDocument(encoding);
831
832         // set the EntityResolver
833 doc.setEntityResolver(entityResolver);
834
835         if (inputSource != null) {
836             doc.setName(inputSource.getSystemId());
837         }
838
839         return doc;
840     }
841
842     private String getEncoding() {
843         if (locator == null) {
844             return null;
845         }
846
847         // use reflection to avoid dependency on Locator2
848 // or other locator implemenations.
849 try {
850             Method m = locator.getClass().getMethod("getEncoding",
851                     new Class [] {});
852
853             if (m != null) {
854                 return (String ) m.invoke(locator, null);
855             }
856         } catch (Exception e) {
857             // do nothing
858 }
859
860         // couldn't determine encoding, returning null...
861 return null;
862     }
863
864     /**
865      * a Strategy Method to determine if a given entity name is ignorable
866      *
867      * @param name
868      * DOCUMENT ME!
869      *
870      * @return DOCUMENT ME!
871      */
872     protected boolean isIgnorableEntity(String name) {
873         return "amp".equals(name) || "apos".equals(name) || "gt".equals(name)
874                 || "lt".equals(name) || "quot".equals(name);
875     }
876
877     /**
878      * Add all namespaces declared before the startElement() SAX event to the
879      * current element so that they are available to child elements and
880      * attributes
881      *
882      * @param element
883      * DOCUMENT ME!
884      */
885     protected void addDeclaredNamespaces(Element element) {
886         Namespace elementNamespace = element.getNamespace();
887
888         for (int size = namespaceStack.size(); declaredNamespaceIndex < size;
889                 declaredNamespaceIndex++) {
890             Namespace namespace = namespaceStack
891                     .getNamespace(declaredNamespaceIndex);
892
893             // if ( namespace != elementNamespace ) {
894 element.add(namespace);
895
896             // }
897 }
898     }
899
900     /**
901      * Add all the attributes to the given elements
902      *
903      * @param element
904      * DOCUMENT ME!
905      * @param attributes
906      * DOCUMENT ME!
907      */
908     protected void addAttributes(Element element, Attributes attributes) {
909         // XXXX: as an optimisation, we could deduce this value from the current
910 // SAX parser settings, the SAX namespaces-prefixes feature
911 boolean noNamespaceAttributes = false;
912
913         if (element instanceof AbstractElement) {
914             // optimised method
915 AbstractElement baseElement = (AbstractElement) element;
916             baseElement.setAttributes(attributes, namespaceStack,
917                     noNamespaceAttributes);
918         } else {
919             int size = attributes.getLength();
920
921             for (int i = 0; i < size; i++) {
922                 String attributeQName = attributes.getQName(i);
923
924                 if (noNamespaceAttributes
925                         || !attributeQName.startsWith("xmlns")) {
926                     String attributeURI = attributes.getURI(i);
927                     String attributeLocalName = attributes.getLocalName(i);
928                     String attributeValue = attributes.getValue(i);
929
930                     QName qName = namespaceStack.getAttributeQName(
931                             attributeURI, attributeLocalName, attributeQName);
932                     element.addAttribute(qName, attributeValue);
933                 }
934             }
935         }
936     }
937
938     /**
939      * Adds an internal DTD declaration to the list of declarations
940      *
941      * @param declaration
942      * DOCUMENT ME!
943      */
944     protected void addDTDDeclaration(Object declaration) {
945         if (internalDTDDeclarations == null) {
946             internalDTDDeclarations = new ArrayList ();
947         }
948
949         internalDTDDeclarations.add(declaration);
950     }
951
952     /**
953      * Adds an external DTD declaration to the list of declarations
954      *
955      * @param declaration
956      * DOCUMENT ME!
957      */
958     protected void addExternalDTDDeclaration(Object declaration) {
959         if (externalDTDDeclarations == null) {
960             externalDTDDeclarations = new ArrayList ();
961         }
962
963         externalDTDDeclarations.add(declaration);
964     }
965
966     protected ElementStack createElementStack() {
967         return new ElementStack();
968     }
969 }
970
971 /*
972  * Redistribution and use of this software and associated documentation
973  * ("Software"), with or without modification, are permitted provided that the
974  * following conditions are met:
975  *
976  * 1. Redistributions of source code must retain copyright statements and
977  * notices. Redistributions must also contain a copy of this document.
978  *
979  * 2. Redistributions in binary form must reproduce the above copyright notice,
980  * this list of conditions and the following disclaimer in the documentation
981  * and/or other materials provided with the distribution.
982  *
983  * 3. The name "DOM4J" must not be used to endorse or promote products derived
984  * from this Software without prior written permission of MetaStuff, Ltd. For
985  * written permission, please contact dom4j-info@metastuff.com.
986  *
987  * 4. Products derived from this Software may not be called "DOM4J" nor may
988  * "DOM4J" appear in their names without prior written permission of MetaStuff,
989  * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
990  *
991  * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
992  *
993  * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
994  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
995  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
996  * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
997  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
998  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
999  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1000 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
1001 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1002 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1003 * POSSIBILITY OF SUCH DAMAGE.
1004 *
1005 * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
1006 */
1007

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags