JaxenXPath


1   /*--
2   
3    $Id: JaxenXPath.java,v 1.19 2004/09/03 07:27:39 jhunter Exp $
4   
5    Copyright (C) 2000-2004 Jason Hunter & Brett McLaughlin.
6    All rights reserved.
7   
8    Redistribution and use in source and binary forms, with or without
9    modification, are permitted provided that the following conditions
10   are met:
11  
12   1. Redistributions of source code must retain the above copyright
13      notice, this list of conditions, and the following disclaimer.
14  
15   2. Redistributions in binary form must reproduce the above copyright
16      notice, this list of conditions, and the disclaimer that follows
17      these conditions in the documentation and/or other materials
18      provided with the distribution.
19  
20   3. The name "JDOM" must not be used to endorse or promote products
21      derived from this software without prior written permission.  For
22      written permission, please contact <request_AT_jdom_DOT_org>.
23  
24   4. Products derived from this software may not be called "JDOM", nor
25      may "JDOM" appear in their name, without prior written permission
26      from the JDOM Project Management <request_AT_jdom_DOT_org>.
27  
28   In addition, we request (but do not require) that you include in the
29   end-user documentation provided with the redistribution and/or in the
30   software itself an acknowledgement equivalent to the following:
31       "This product includes software developed by the
32        JDOM Project (http://www.jdom.org/)."
33   Alternatively, the acknowledgment may be graphical using the logos
34   available at http://www.jdom.org/images/logos.
35  
36   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39   DISCLAIMED.  IN NO EVENT SHALL THE JDOM AUTHORS OR THE PROJECT
40   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46   OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47   SUCH DAMAGE.
48  
49   This software consists of voluntary contributions made by many
50   individuals on behalf of the JDOM Project and was originally
51   created by Jason Hunter <jhunter_AT_jdom_DOT_org> and
52   Brett McLaughlin <brett_AT_jdom_DOT_org>.  For more information
53   on the JDOM Project, please see <http://www.jdom.org/>.
54  
55   */
56  
57  package org.jdom.xpath;
58  
59  
60  import java.util.*;
61  
62  import org.jaxen.*;
63  import org.jaxen.jdom.*;
64  import org.jdom.*;
65  
66  
67  /**
68   * A non-public concrete XPath implementation for Jaxen.
69   *
70   * @version $Revision: 1.19 $, $Date: 2004/09/03 07:27:39 $
71   * @author  Laurent Bihanic
72   */
73  class JaxenXPath extends    XPath {             // package protected
74  
75      private static final String   CVS_ID =
76      "@(#) $RCSfile: JaxenXPath.java,v $ $Revision: 1.19 $ $Date: 2004/09/03 07:27:39 $ $Name:  $";
77  
78     /**
79      * The compiled XPath object to select nodes.  This attribute can
80      * not be made final as it needs to be set upon object
81      * deserialization.
82      */
83     private transient JDOMXPath xPath;
84  
85     /**
86      * The current context for XPath expression evaluation.
87      */
88     private           Object      currentContext;
89  
90     /**
91      * Creates a new XPath wrapper object, compiling the specified
92      * XPath expression.
93      *
94      * @param  expr   the XPath expression to wrap.
95      *
96      * @throws JDOMException   if the XPath expression is invalid.
97      */
98     public JaxenXPath(String   expr) throws JDOMException {
99        setXPath(expr);
100    }
101 
102    /**
103     * Evaluates the wrapped XPath expression and returns the list
104     * of selected items.
105     *
106     * @param  context   the node to use as context for evaluating
107     *                   the XPath expression.
108     *
109     * @return the list of selected items, which may be of types: {@link Element},
110     *         {@link Attribute}, {@link Text}, {@link CDATA},
111     *         {@link Comment}, {@link ProcessingInstruction}, Boolean,
112     *         Double, or String.
113     *
114     * @throws JDOMException   if the evaluation of the XPath
115     *                         expression on the specified context
116     *                         failed.
117     */
118    public List selectNodes(Object   context) throws JDOMException {
119       try {
120          currentContext = context;
121 
122          return xPath.selectNodes(context);
123       }
124       catch (JaxenException ex1) {
125          throw new JDOMException("XPath error while evaluating \"" +
126                         xPath.toString() + "\": " + ex1.getMessage(), ex1);
127       }
128       finally {
129          currentContext = null;
130       }
131    }
132 
133    /**
134     * Evaluates the wrapped XPath expression and returns the first
135     * entry in the list of selected nodes (or atomics).
136     *
137     * @param  context   the node to use as context for evaluating
138     *                   the XPath expression.
139     *
140     * @return the first selected item, which may be of types: {@link Element},
141     *         {@link Attribute}, {@link Text}, {@link CDATA},
142     *         {@link Comment}, {@link ProcessingInstruction}, Boolean,
143     *         Double, String, or <code>null</code> if no item was selected.
144     *
145     * @throws JDOMException   if the evaluation of the XPath
146     *                         expression on the specified context
147     *                         failed.
148     */
149    public Object   selectSingleNode(Object   context) throws JDOMException {
150       try {
151          currentContext = context;
152 
153          return xPath.selectSingleNode(context);
154       }
155       catch (JaxenException ex1) {
156          throw new JDOMException("XPath error while evaluating \"" +
157                         xPath.toString() + "\": " + ex1.getMessage(), ex1);
158       }
159       finally {
160          currentContext = null;
161       }
162    }
163 
164    /**
165     * Returns the string value of the first node selected by applying
166     * the wrapped XPath expression to the given context.
167     *
168     * @param  context   the element to use as context for evaluating
169     *                   the XPath expression.
170     *
171     * @return the string value of the first node selected by applying
172     *         the wrapped XPath expression to the given context.
173     *
174     * @throws JDOMException   if the XPath expression is invalid or
175     *                         its evaluation on the specified context
176     *                         failed.
177     */
178    public String   valueOf(Object   context) throws JDOMException {
179       try {
180          currentContext = context;
181 
182          return xPath.stringValueOf(context);
183       }
184       catch (JaxenException ex1) {
185          throw new JDOMException("XPath error while evaluating \"" +
186                         xPath.toString() + "\": " + ex1.getMessage(), ex1);
187       }
188       finally {
189          currentContext = null;
190       }
191    }
192 
193    /**
194     * Returns the number value of the first item selected by applying
195     * the wrapped XPath expression to the given context.
196     *
197     * @param  context   the element to use as context for evaluating
198     *                   the XPath expression.
199     *
200     * @return the number value of the first item selected by applying
201     *         the wrapped XPath expression to the given context,
202     *         <code>null</code> if no node was selected or the
203     *         special value {@link java.lang.Double#NaN}
204     *         (Not-a-Number) if the selected value can not be
205     *         converted into a number value.
206     *
207     * @throws JDOMException   if the XPath expression is invalid or
208     *                         its evaluation on the specified context
209     *                         failed.
210     */
211    public Number   numberValueOf(Object   context) throws JDOMException {
212       try {
213          currentContext = context;
214 
215          return xPath.numberValueOf(context);
216       }
217       catch (JaxenException ex1) {
218          throw new JDOMException("XPath error while evaluating \"" +
219                         xPath.toString() + "\": " + ex1.getMessage(), ex1);
220       }
221       finally {
222          currentContext = null;
223       }
224    }
225 
226    /**
227     * Defines an XPath variable and sets its value.
228     *
229     * @param  name    the variable name.
230     * @param  value   the variable value.
231     *
232     * @throws IllegalArgumentException   if <code>name</code> is not
233     *                                    a valid XPath variable name
234     *                                    or if the value type is not
235     *                                    supported by the underlying
236     *                                    implementation
237     */
238    public void setVariable(String   name, Object   value)
239                                         throws IllegalArgumentException   {
240       Object   o = xPath.getVariableContext();
241       if (o instanceof SimpleVariableContext) {
242            ((SimpleVariableContext)o).setVariableValue(null, name, value);
243       }
244    }
245 
246    /**
247     * Adds a namespace definition to the list of namespaces known of
248     * this XPath expression.
249     * <p>
250     * <strong>Note</strong>: In XPath, there is no such thing as a
251     * 'default namespace'.  The empty prefix <b>always</b> resolves
252     * to the empty namespace URI.</p>
253     *
254     * @param  namespace   the namespace.
255     */
256    public void addNamespace(Namespace namespace) {
257       try {
258          xPath.addNamespace(namespace.getPrefix(), namespace.getURI());
259       }
260       catch (JaxenException ex1) { /* Can't happen here. */ }
261    }
262 
263    /**
264     * Returns the wrapped XPath expression as a string.
265     *
266     * @return the wrapped XPath expression as a string.
267     */
268    public String   getXPath() {
269       return (xPath.toString());
270    }
271 
272    /**
273     * Compiles and sets the XPath expression wrapped by this object.
274     *
275     * @param  expr   the XPath expression to wrap.
276     *
277     * @throws JDOMException   if the XPath expression is invalid.
278     */
279    private void setXPath(String   expr) throws JDOMException {
280       try {
281          xPath = new JDOMXPath(expr);
282          xPath.setNamespaceContext(new NSContext());
283       }
284       catch (Exception   ex1) {
285          throw new JDOMException(
286                         "Invalid XPath expression: \"" + expr + "\"", ex1);
287       }
288    }
289 
290    public String   toString() {
291       return (xPath.toString());
292    }
293 
294    public boolean equals(Object   o) {
295       if (o instanceof JaxenXPath) {
296          JaxenXPath x = (JaxenXPath)o;
297 
298          return (super.equals(o) &&
299                  xPath.toString().equals(x.xPath.toString()));
300       }
301       return false;
302    }
303 
304    public int hashCode() {
305       return xPath.hashCode();
306    }
307 
308    private class NSContext extends SimpleNamespaceContext {
309       public NSContext() {
310          super();
311       }
312 
313       /**
314        * <i>[Jaxen NamespaceContext interface support]</i> Translates
315        * the provided namespace prefix into the matching bound
316        * namespace URI.
317        *
318        * @param  prefix   the namespace prefix to resolve.
319        *
320        * @return the namespace URI matching the prefix.
321        */
322       public String   translateNamespacePrefixToUri(String   prefix) {
323          if ((prefix == null) || (prefix.length() == 0)) {
324             return null;
325          }
326 
327          String   uri = super.translateNamespacePrefixToUri(prefix);
328          if (uri == null) {
329             Object   ctx = currentContext;
330             if (ctx != null) {
331                Element elt = null;
332 
333                // Get closer element node
334                if (ctx instanceof Element) {
335                   elt = (Element)ctx;
336                } else if (ctx instanceof Attribute) {
337                   elt = ((Attribute)ctx).getParent();
338                } else if (ctx instanceof Content) {
339                   elt = ((Content) ctx).getParentElement();
340                } else if (ctx instanceof Document) {
341                   elt = ((Document)ctx).getRootElement();
342                }
343 
344                if (elt != null) {
345                   Namespace ns = elt.getNamespace(prefix);
346                   if (ns != null) {
347                      uri = ns.getURI();
348                   }
349                }
350             }
351          }
352          return uri;
353       }
354    }
355 }
356 
357
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags