KickJava   Java API By Example, From Geeks To Geeks.

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


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.util.ArrayList JavaDoc;
11 import java.util.HashMap JavaDoc;
12
13 import org.dom4j.Element;
14 import org.dom4j.ElementHandler;
15 import org.dom4j.ElementPath;
16
17 /**
18  * <p>
19  * <code>DispatchHandler</code> implements the <code>ElementHandler</code>
20  * interface and provides a means to register multiple
21  * <code>ElementHandler</code> instances to be used by an event based
22  * processor. This is a special <code>ElementHandler</code> in that it's
23  * <b>onStart </b> and <b>onEnd </b> implementation methods are called for every
24  * element encountered during the parse. It then delegates to other
25  * <code>ElementHandler</code> instances registered with it to process the
26  * elements encountered.
27  * </p>
28  *
29  * @author <a HREF="mailto:dwhite@equipecom.com">Dave White </a>
30  * @version $Revision: 1.11 $
31  */
32 class DispatchHandler implements ElementHandler {
33     /** Whether the parser is at the root element or not */
34     private boolean atRoot;
35
36     /** The current path in the XML tree (i.e. /a/b/c) */
37     private String JavaDoc path;
38
39     /** maintains a stack of previously encountered paths */
40     private ArrayList JavaDoc pathStack;
41
42     /** maintains a stack of previously encountered handlers */
43     private ArrayList JavaDoc handlerStack;
44
45     /**
46      * <code>HashMap</code> maintains the mapping between element paths and
47      * handlers
48      */
49     private HashMap JavaDoc handlers;
50
51     /**
52      * <code>ElementHandler</code> to use by default for element paths with no
53      * handlers registered
54      */
55     private ElementHandler defaultHandler;
56
57     public DispatchHandler() {
58         atRoot = true;
59         path = "/";
60         pathStack = new ArrayList JavaDoc();
61         handlerStack = new ArrayList JavaDoc();
62         handlers = new HashMap JavaDoc();
63     }
64
65     /**
66      * Adds the <code>ElementHandler</code> to be called when the specified
67      * path is encounted.
68      *
69      * @param handlerPath
70      * is the path to be handled
71      * @param handler
72      * is the <code>ElementHandler</code> to be called by the event
73      * based processor.
74      */
75     public void addHandler(String JavaDoc handlerPath, ElementHandler handler) {
76         handlers.put(handlerPath, handler);
77     }
78
79     /**
80      * Removes the <code>ElementHandler</code> from the event based processor,
81      * for the specified path.
82      *
83      * @param handlerPath
84      * is the path to remove the <code>ElementHandler</code> for.
85      *
86      * @return DOCUMENT ME!
87      */
88     public ElementHandler removeHandler(String JavaDoc handlerPath) {
89         return (ElementHandler) handlers.remove(handlerPath);
90     }
91
92     /**
93      * DOCUMENT ME!
94      *
95      * @param handlerPath
96      * DOCUMENT ME!
97      *
98      * @return true when an <code>ElementHandler</code> is registered for the
99      * specified path.
100      */
101     public boolean containsHandler(String JavaDoc handlerPath) {
102         return handlers.containsKey(handlerPath);
103     }
104
105     /**
106      * Get the registered {@link ElementHandler}for the specified path.
107      *
108      * @param handlerPath
109      * XML path to get the handler for
110      *
111      * @return the registered handler
112      */
113     public ElementHandler getHandler(String JavaDoc handlerPath) {
114         return (ElementHandler) handlers.get(handlerPath);
115     }
116
117     /**
118      * Returns the number of {@link ElementHandler}objects that are waiting for
119      * their elements closing tag.
120      *
121      * @return number of active handlers
122      */
123     public int getActiveHandlerCount() {
124         return handlerStack.size();
125     }
126
127     /**
128      * When multiple <code>ElementHandler</code> instances have been
129      * registered, this will set a default <code>ElementHandler</code> to be
130      * called for any path which does <b>NOT </b> have a handler registered.
131      *
132      * @param handler
133      * is the <code>ElementHandler</code> to be called by the event
134      * based processor.
135      */
136     public void setDefaultHandler(ElementHandler handler) {
137         defaultHandler = handler;
138     }
139
140     /**
141      * Used to remove all the Element Handlers and return things back to the way
142      * they were when object was created.
143      */
144     public void resetHandlers() {
145         atRoot = true;
146         path = "/";
147         pathStack.clear();
148         handlerStack.clear();
149         handlers.clear();
150         defaultHandler = null;
151     }
152
153     /**
154      * DOCUMENT ME!
155      *
156      * @return the current path for the parse
157      */
158     public String JavaDoc getPath() {
159         return path;
160     }
161
162     // The following methods implement the ElementHandler interface
163 public void onStart(ElementPath elementPath) {
164         Element element = elementPath.getCurrent();
165
166         // Save the location of the last (i.e. parent) path
167 pathStack.add(path);
168
169         // Calculate the new path
170 if (atRoot) {
171             path = path + element.getName();
172             atRoot = false;
173         } else {
174             path = path + "/" + element.getName();
175         }
176
177         if ((handlers != null) && (handlers.containsKey(path))) {
178             // The current node has a handler associated with it.
179 // Find the handler and save it on the handler stack.
180 ElementHandler handler = (ElementHandler) handlers.get(path);
181             handlerStack.add(handler);
182
183             // Call the handlers onStart method.
184 handler.onStart(elementPath);
185         } else {
186             // No handler is associated with this node, so use the
187 // defaultHandler it it exists.
188 if (handlerStack.isEmpty() && (defaultHandler != null)) {
189                 defaultHandler.onStart(elementPath);
190             }
191         }
192     }
193
194     public void onEnd(ElementPath elementPath) {
195         if ((handlers != null) && (handlers.containsKey(path))) {
196             // This node has a handler associated with it.
197 // Find the handler and pop it from the handler stack.
198 ElementHandler handler = (ElementHandler) handlers.get(path);
199             handlerStack.remove(handlerStack.size() - 1);
200
201             // Call the handlers onEnd method
202 handler.onEnd(elementPath);
203         } else {
204             // No handler is associated with this node, so use the
205 // defaultHandler it it exists.
206 if (handlerStack.isEmpty() && (defaultHandler != null)) {
207                 defaultHandler.onEnd(elementPath);
208             }
209         }
210
211         // Set path back to its parent
212 path = (String JavaDoc) pathStack.remove(pathStack.size() - 1);
213
214         if (pathStack.size() == 0) {
215             atRoot = true;
216         }
217     }
218 }
219
220 /*
221  * Redistribution and use of this software and associated documentation
222  * ("Software"), with or without modification, are permitted provided that the
223  * following conditions are met:
224  *
225  * 1. Redistributions of source code must retain copyright statements and
226  * notices. Redistributions must also contain a copy of this document.
227  *
228  * 2. Redistributions in binary form must reproduce the above copyright notice,
229  * this list of conditions and the following disclaimer in the documentation
230  * and/or other materials provided with the distribution.
231  *
232  * 3. The name "DOM4J" must not be used to endorse or promote products derived
233  * from this Software without prior written permission of MetaStuff, Ltd. For
234  * written permission, please contact dom4j-info@metastuff.com.
235  *
236  * 4. Products derived from this Software may not be called "DOM4J" nor may
237  * "DOM4J" appear in their names without prior written permission of MetaStuff,
238  * Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
239  *
240  * 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
241  *
242  * THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
243  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
244  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
245  * ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
246  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
247  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
248  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
249  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
250  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
251  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
252  * POSSIBILITY OF SUCH DAMAGE.
253  *
254  * Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
255  */
256
Popular Tags