Coverage Report

Coverage Report - org.jaxen.expr.DefaultXPathFactory

Classes in this File

Line Coverage

Branch Coverage

Complexity

DefaultXPathFactory

90%

57/63

100%

3/3

3.115

 /*
  * $Header$
  * $Revision: 1251 $
  * $Date: 2006-11-09 08:11:38 -0800 (Thu, 09 Nov 2006) $
  *
  * ====================================================================
  *
  * Copyright 2000-2002 bob mcwhirter & James Strachan.
  * All rights reserved.
  *
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *   * Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 
  *   * Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
  *     documentation and/or other materials provided with the distribution.
  * 
  *   * Neither the name of the Jaxen Project nor the names of its
  *     contributors may be used to endorse or promote products derived 
  *     from this software without specific prior written permission.
  * 
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * ====================================================================
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Jaxen Project and was originally
  * created by bob mcwhirter <bob@werken.com> and
  * James Strachan <jstrachan@apache.org>.  For more information on the
  * Jaxen Project, please see <http://www.jaxen.org/>.
  *
  * $Id: DefaultXPathFactory.java 1251 2006-11-09 16:11:38Z elharo $
  */
 package org.jaxen.expr;
 
 import org.jaxen.JaxenException;
 import org.jaxen.expr.iter.IterableAncestorAxis;
 import org.jaxen.expr.iter.IterableAncestorOrSelfAxis;
 import org.jaxen.expr.iter.IterableAttributeAxis;
 import org.jaxen.expr.iter.IterableAxis;
 import org.jaxen.expr.iter.IterableChildAxis;
 import org.jaxen.expr.iter.IterableDescendantAxis;
 import org.jaxen.expr.iter.IterableDescendantOrSelfAxis;
 import org.jaxen.expr.iter.IterableFollowingAxis;
 import org.jaxen.expr.iter.IterableFollowingSiblingAxis;
 import org.jaxen.expr.iter.IterableNamespaceAxis;
 import org.jaxen.expr.iter.IterableParentAxis;
 import org.jaxen.expr.iter.IterablePrecedingAxis;
 import org.jaxen.expr.iter.IterablePrecedingSiblingAxis;
 import org.jaxen.expr.iter.IterableSelfAxis;
 import org.jaxen.saxpath.Axis;
 import org.jaxen.saxpath.Operator;
 
 /**
  * The concrete implementation of the XPathFactory anstract factory.
  *
  *
  * @see XPathFactory
  */
 public class DefaultXPathFactory implements XPathFactory
 {
     public XPathExpr createXPath( Expr rootExpr ) throws JaxenException
     {
         return new DefaultXPathExpr( rootExpr );
     }
 
     public PathExpr createPathExpr( FilterExpr filterExpr,
                                     LocationPath locationPath ) throws JaxenException
     {
         return new DefaultPathExpr( filterExpr,
                                     locationPath );
     }
 
     public LocationPath createRelativeLocationPath() throws JaxenException
     {
         return new DefaultRelativeLocationPath();
     }
 
     public LocationPath createAbsoluteLocationPath() throws JaxenException
     {
         return new DefaultAbsoluteLocationPath();
     }
 
     public BinaryExpr createOrExpr( Expr lhs,
                                     Expr rhs ) throws JaxenException
     {
         return new DefaultOrExpr( lhs,
                                   rhs );
     }
 
     public BinaryExpr createAndExpr( Expr lhs,
                                      Expr rhs ) throws JaxenException
     {
         return new DefaultAndExpr( lhs,
                                    rhs );
     }
 
     public BinaryExpr createEqualityExpr( Expr lhs,
                                           Expr rhs,
                                           int equalityOperator ) throws JaxenException
     {
         switch( equalityOperator )
         {
             case Operator.EQUALS:
                 {
                     return new DefaultEqualsExpr( lhs,
                                                   rhs );
                 }
             case Operator.NOT_EQUALS:
                 {
                     return new DefaultNotEqualsExpr( lhs,
                                                      rhs );
                 }
         }
         throw new JaxenException( "Unhandled operator in createEqualityExpr(): " + equalityOperator );
     }
 
     public BinaryExpr createRelationalExpr( Expr lhs,
                                             Expr rhs,
                                             int relationalOperator ) throws JaxenException
     {
         switch( relationalOperator )
         {
             case Operator.LESS_THAN:
                 {
                     return new DefaultLessThanExpr( lhs,
                                                     rhs );
                 }
             case Operator.GREATER_THAN:
                 {
                     return new DefaultGreaterThanExpr( lhs,
                                                        rhs );
                 }
             case Operator.LESS_THAN_EQUALS:
                 {
                     return new DefaultLessThanEqualExpr( lhs,
                                                          rhs );
                 }
             case Operator.GREATER_THAN_EQUALS:
                 {
                     return new DefaultGreaterThanEqualExpr( lhs,
                                                             rhs );
                 }
         }
         throw new JaxenException( "Unhandled operator in createRelationalExpr(): " + relationalOperator );
     }
 
     public BinaryExpr createAdditiveExpr( Expr lhs,
                                           Expr rhs,
                                           int additiveOperator ) throws JaxenException
     {
         switch( additiveOperator )
         {
             case Operator.ADD:
                 {
                     return new DefaultPlusExpr( lhs,
                                                 rhs );
                 }
             case Operator.SUBTRACT:
                 {
                     return new DefaultMinusExpr( lhs,
                                                  rhs );
                 }
         }
         throw new JaxenException( "Unhandled operator in createAdditiveExpr(): " + additiveOperator );
     }
 
     public BinaryExpr createMultiplicativeExpr( Expr lhs,
                                                 Expr rhs,
                                                 int multiplicativeOperator ) throws JaxenException
     {
         switch( multiplicativeOperator )
         {
             case Operator.MULTIPLY:
                 {
                     return new DefaultMultiplyExpr( lhs,
                                                     rhs );
                 }
             case Operator.DIV:
                 {
                     return new DefaultDivExpr( lhs,
                                                rhs );
                 }
             case Operator.MOD:
                 {
                     return new DefaultModExpr( lhs,
                                                rhs );
                 }
         }
         throw new JaxenException( "Unhandled operator in createMultiplicativeExpr(): " + multiplicativeOperator );
     }
 
     public Expr createUnaryExpr( Expr expr,
                                  int unaryOperator ) throws JaxenException
     {
         switch( unaryOperator )
         {
             case Operator.NEGATIVE:
                 {
                     return new DefaultUnaryExpr( expr );
                 }
         }
         return expr;
     }
 
     public UnionExpr createUnionExpr( Expr lhs,
                                       Expr rhs ) throws JaxenException
     {
         return new DefaultUnionExpr( lhs,
                                      rhs );
     }
 
     public FilterExpr createFilterExpr( Expr expr ) throws JaxenException
     {
         return new DefaultFilterExpr( expr, createPredicateSet() );
     }
 
     public FunctionCallExpr createFunctionCallExpr( String prefix,
                                                     String functionName ) throws JaxenException
     {
         return new DefaultFunctionCallExpr( prefix,
                                             functionName );
     }
 
     public NumberExpr createNumberExpr( int number ) throws JaxenException
     {
         return new DefaultNumberExpr( new Double( number ) );
     }
 
     public NumberExpr createNumberExpr( double number ) throws JaxenException
     {
         return new DefaultNumberExpr( new Double( number ) );
     }
 
     public LiteralExpr createLiteralExpr( String literal ) throws JaxenException
     {
         return new DefaultLiteralExpr( literal );
     }
 
     public VariableReferenceExpr createVariableReferenceExpr( String prefix,
                                                               String variable ) throws JaxenException
     {
         return new DefaultVariableReferenceExpr( prefix,
                                                  variable );
     }
 
     public Step createNameStep( int axis,
                                 String prefix,
                                 String localName ) throws JaxenException
     {
         IterableAxis iter = getIterableAxis( axis );
         return new DefaultNameStep( iter,
                                     prefix,
                                     localName,
                                     createPredicateSet() );
     }
 
     public Step createTextNodeStep( int axis ) throws JaxenException
     {
         IterableAxis iter = getIterableAxis( axis );
         return new DefaultTextNodeStep( iter, createPredicateSet() );
     }
 
     public Step createCommentNodeStep( int axis ) throws JaxenException
     {
         IterableAxis iter = getIterableAxis( axis );
         return new DefaultCommentNodeStep( iter, createPredicateSet() );
     }
 
     public Step createAllNodeStep( int axis ) throws JaxenException
     {
         IterableAxis iter = getIterableAxis( axis );
         return new DefaultAllNodeStep( iter, createPredicateSet() );
     }
 
     public Step createProcessingInstructionNodeStep( int axis,
                                                      String piName ) throws JaxenException
     {
         IterableAxis iter = getIterableAxis( axis );
         return new DefaultProcessingInstructionNodeStep( iter,
                                                          piName,
                                                          createPredicateSet() );
     }
 
     public Predicate createPredicate( Expr predicateExpr ) throws JaxenException
     {
         return new DefaultPredicate( predicateExpr );
     }
 
     protected IterableAxis getIterableAxis( int axis ) throws JaxenException
     {
 
         switch( axis )
         {
             case Axis.CHILD:
                  return new IterableChildAxis( axis );
             case Axis.DESCENDANT:
                  return  new IterableDescendantAxis( axis );
             case Axis.PARENT:
                 return new IterableParentAxis( axis );
             case Axis.FOLLOWING_SIBLING:
                 return  new IterableFollowingSiblingAxis( axis );
             case Axis.PRECEDING_SIBLING:
                 return new IterablePrecedingSiblingAxis( axis );
             case Axis.FOLLOWING:
                 return new IterableFollowingAxis( axis );
             case Axis.PRECEDING:
                 return new IterablePrecedingAxis( axis );
             case Axis.ATTRIBUTE:
                 return new IterableAttributeAxis( axis );
             case Axis.NAMESPACE:
                 return new IterableNamespaceAxis( axis );
             case Axis.SELF:
                 return new IterableSelfAxis( axis );
             case Axis.DESCENDANT_OR_SELF:
                 return new IterableDescendantOrSelfAxis( axis );
             case Axis.ANCESTOR_OR_SELF:
                 return new IterableAncestorOrSelfAxis( axis );
             case Axis.ANCESTOR:
                 return new IterableAncestorAxis( axis );
             default:
                 throw new JaxenException("Unrecognized axis code: " + axis);
         }
 
     }
 
     public PredicateSet createPredicateSet() throws JaxenException
     {
         return new PredicateSet();
     }
     
 }

1		/*
2		* $Header$
3		* $Revision: 1251 $
4		* $Date: 2006-11-09 08:11:38 -0800 (Thu, 09 Nov 2006) $
5		*
6		* ====================================================================
7		*
8		* Copyright 2000-2002 bob mcwhirter & James Strachan.
9		* All rights reserved.
10		*
11		*
12		* Redistribution and use in source and binary forms, with or without
13		* modification, are permitted provided that the following conditions are
14		* met:
15		*
16		* * Redistributions of source code must retain the above copyright
17		* notice, this list of conditions and the following disclaimer.
18		*
19		* * Redistributions in binary form must reproduce the above copyright
20		* notice, this list of conditions and the following disclaimer in the
21		* documentation and/or other materials provided with the distribution.
22		*
23		* * Neither the name of the Jaxen Project nor the names of its
24		* contributors may be used to endorse or promote products derived
25		* from this software without specific prior written permission.
26		*
27		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
28		* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29		* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
30		* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
31		* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32		* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33		* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34		* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35		* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36		* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37		* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38		*
39		* ====================================================================
40		* This software consists of voluntary contributions made by many
41		* individuals on behalf of the Jaxen Project and was originally
42		* created by bob mcwhirter <bob@werken.com> and
43		* James Strachan <jstrachan@apache.org>. For more information on the
44		* Jaxen Project, please see <http://www.jaxen.org/>.
45		*
46		* $Id: DefaultXPathFactory.java 1251 2006-11-09 16:11:38Z elharo $
47		*/
48		package org.jaxen.expr;
49
50		import org.jaxen.JaxenException;
51		import org.jaxen.expr.iter.IterableAncestorAxis;
52		import org.jaxen.expr.iter.IterableAncestorOrSelfAxis;
53		import org.jaxen.expr.iter.IterableAttributeAxis;
54		import org.jaxen.expr.iter.IterableAxis;
55		import org.jaxen.expr.iter.IterableChildAxis;
56		import org.jaxen.expr.iter.IterableDescendantAxis;
57		import org.jaxen.expr.iter.IterableDescendantOrSelfAxis;
58		import org.jaxen.expr.iter.IterableFollowingAxis;
59		import org.jaxen.expr.iter.IterableFollowingSiblingAxis;
60		import org.jaxen.expr.iter.IterableNamespaceAxis;
61		import org.jaxen.expr.iter.IterableParentAxis;
62		import org.jaxen.expr.iter.IterablePrecedingAxis;
63		import org.jaxen.expr.iter.IterablePrecedingSiblingAxis;
64		import org.jaxen.expr.iter.IterableSelfAxis;
65		import org.jaxen.saxpath.Axis;
66		import org.jaxen.saxpath.Operator;
67
68		/**
69		* The concrete implementation of the XPathFactory anstract factory.
70		*
71		*
72		* @see XPathFactory
73		*/
74	15481	public class DefaultXPathFactory implements XPathFactory
75		{
76		public XPathExpr createXPath( Expr rootExpr ) throws JaxenException
77		{
78	15366	return new DefaultXPathExpr( rootExpr );
79		}
80
81		public PathExpr createPathExpr( FilterExpr filterExpr,
82		LocationPath locationPath ) throws JaxenException
83		{
84	37168	return new DefaultPathExpr( filterExpr,
85		locationPath );
86		}
87
88		public LocationPath createRelativeLocationPath() throws JaxenException
89		{
90	5921	return new DefaultRelativeLocationPath();
91		}
92
93		public LocationPath createAbsoluteLocationPath() throws JaxenException
94		{
95	7936	return new DefaultAbsoluteLocationPath();
96		}
97
98		public BinaryExpr createOrExpr( Expr lhs,
99		Expr rhs ) throws JaxenException
100		{
101	48	return new DefaultOrExpr( lhs,
102		rhs );
103		}
104
105		public BinaryExpr createAndExpr( Expr lhs,
106		Expr rhs ) throws JaxenException
107		{
108	620	return new DefaultAndExpr( lhs,
109		rhs );
110		}
111
112		public BinaryExpr createEqualityExpr( Expr lhs,
113		Expr rhs,
114		int equalityOperator ) throws JaxenException
115		{
116	3175	switch( equalityOperator )
117		{
118		case Operator.EQUALS:
119		{
120	2825	return new DefaultEqualsExpr( lhs,
121		rhs );
122		}
123		case Operator.NOT_EQUALS:
124		{
125	350	return new DefaultNotEqualsExpr( lhs,
126		rhs );
127		}
128		}
129	0	throw new JaxenException( "Unhandled operator in createEqualityExpr(): " + equalityOperator );
130		}
131
132		public BinaryExpr createRelationalExpr( Expr lhs,
133		Expr rhs,
134		int relationalOperator ) throws JaxenException
135		{
136	1145	switch( relationalOperator )
137		{
138		case Operator.LESS_THAN:
139		{
140	305	return new DefaultLessThanExpr( lhs,
141		rhs );
142		}
143		case Operator.GREATER_THAN:
144		{
145	310	return new DefaultGreaterThanExpr( lhs,
146		rhs );
147		}
148		case Operator.LESS_THAN_EQUALS:
149		{
150	240	return new DefaultLessThanEqualExpr( lhs,
151		rhs );
152		}
153		case Operator.GREATER_THAN_EQUALS:
154		{
155	290	return new DefaultGreaterThanEqualExpr( lhs,
156		rhs );
157		}
158		}
159	0	throw new JaxenException( "Unhandled operator in createRelationalExpr(): " + relationalOperator );
160		}
161
162		public BinaryExpr createAdditiveExpr( Expr lhs,
163		Expr rhs,
164		int additiveOperator ) throws JaxenException
165		{
166	1260	switch( additiveOperator )
167		{
168		case Operator.ADD:
169		{
170	740	return new DefaultPlusExpr( lhs,
171		rhs );
172		}
173		case Operator.SUBTRACT:
174		{
175	520	return new DefaultMinusExpr( lhs,
176		rhs );
177		}
178		}
179	0	throw new JaxenException( "Unhandled operator in createAdditiveExpr(): " + additiveOperator );
180		}
181
182		public BinaryExpr createMultiplicativeExpr( Expr lhs,
183		Expr rhs,
184		int multiplicativeOperator ) throws JaxenException
185		{
186	945	switch( multiplicativeOperator )
187		{
188		case Operator.MULTIPLY:
189		{
190	305	return new DefaultMultiplyExpr( lhs,
191		rhs );
192		}
193		case Operator.DIV:
194		{
195	465	return new DefaultDivExpr( lhs,
196		rhs );
197		}
198		case Operator.MOD:
199		{
200	175	return new DefaultModExpr( lhs,
201		rhs );
202		}
203		}
204	0	throw new JaxenException( "Unhandled operator in createMultiplicativeExpr(): " + multiplicativeOperator );
205		}
206
207		public Expr createUnaryExpr( Expr expr,
208		int unaryOperator ) throws JaxenException
209		{
210	340	switch( unaryOperator )
211		{
212		case Operator.NEGATIVE:
213		{
214	340	return new DefaultUnaryExpr( expr );
215		}
216		}
217	0	return expr;
218		}
219
220		public UnionExpr createUnionExpr( Expr lhs,
221		Expr rhs ) throws JaxenException
222		{
223	100	return new DefaultUnionExpr( lhs,
224		rhs );
225		}
226
227		public FilterExpr createFilterExpr( Expr expr ) throws JaxenException
228		{
229	23706	return new DefaultFilterExpr( expr, createPredicateSet() );
230		}
231
232		public FunctionCallExpr createFunctionCallExpr( String prefix,
233		String functionName ) throws JaxenException
234		{
235	6634	return new DefaultFunctionCallExpr( prefix,
236		functionName );
237		}
238
239		public NumberExpr createNumberExpr( int number ) throws JaxenException
240		{
241	0	return new DefaultNumberExpr( new Double( number ) );
242		}
243
244		public NumberExpr createNumberExpr( double number ) throws JaxenException
245		{
246	7883	return new DefaultNumberExpr( new Double( number ) );
247		}
248
249		public LiteralExpr createLiteralExpr( String literal ) throws JaxenException
250		{
251	5514	return new DefaultLiteralExpr( literal );
252		}
253
254		public VariableReferenceExpr createVariableReferenceExpr( String prefix,
255		String variable ) throws JaxenException
256		{
257	195	return new DefaultVariableReferenceExpr( prefix,
258		variable );
259		}
260
261		public Step createNameStep( int axis,
262		String prefix,
263		String localName ) throws JaxenException
264		{
265	18934	IterableAxis iter = getIterableAxis( axis );
266	18934	return new DefaultNameStep( iter,
267		prefix,
268		localName,
269		createPredicateSet() );
270		}
271
272		public Step createTextNodeStep( int axis ) throws JaxenException
273		{
274	390	IterableAxis iter = getIterableAxis( axis );
275	390	return new DefaultTextNodeStep( iter, createPredicateSet() );
276		}
277
278		public Step createCommentNodeStep( int axis ) throws JaxenException
279		{
280	225	IterableAxis iter = getIterableAxis( axis );
281	225	return new DefaultCommentNodeStep( iter, createPredicateSet() );
282		}
283
284		public Step createAllNodeStep( int axis ) throws JaxenException
285		{
286	3243	IterableAxis iter = getIterableAxis( axis );
287	3238	return new DefaultAllNodeStep( iter, createPredicateSet() );
288		}
289
290		public Step createProcessingInstructionNodeStep( int axis,
291		String piName ) throws JaxenException
292		{
293	358	IterableAxis iter = getIterableAxis( axis );
294	358	return new DefaultProcessingInstructionNodeStep( iter,
295		piName,
296		createPredicateSet() );
297		}
298
299		public Predicate createPredicate( Expr predicateExpr ) throws JaxenException
300		{
301	3373	return new DefaultPredicate( predicateExpr );
302		}
303
304		protected IterableAxis getIterableAxis( int axis ) throws JaxenException
305		{
306
307	23150	switch( axis )
308		{
309		case Axis.CHILD:
310	15517	return new IterableChildAxis( axis );
311		case Axis.DESCENDANT:
312	805	return new IterableDescendantAxis( axis );
313		case Axis.PARENT:
314	595	return new IterableParentAxis( axis );
315		case Axis.FOLLOWING_SIBLING:
316	85	return new IterableFollowingSiblingAxis( axis );
317		case Axis.PRECEDING_SIBLING:
318	450	return new IterablePrecedingSiblingAxis( axis );
319		case Axis.FOLLOWING:
320	160	return new IterableFollowingAxis( axis );
321		case Axis.PRECEDING:
322	345	return new IterablePrecedingAxis( axis );
323		case Axis.ATTRIBUTE:
324	1830	return new IterableAttributeAxis( axis );
325		case Axis.NAMESPACE:
326	685	return new IterableNamespaceAxis( axis );
327		case Axis.SELF:
328	760	return new IterableSelfAxis( axis );
329		case Axis.DESCENDANT_OR_SELF:
330	1678	return new IterableDescendantOrSelfAxis( axis );
331		case Axis.ANCESTOR_OR_SELF:
332	85	return new IterableAncestorOrSelfAxis( axis );
333		case Axis.ANCESTOR:
334	150	return new IterableAncestorAxis( axis );
335		default:
336	5	throw new JaxenException("Unrecognized axis code: " + axis);
337		}
338
339		}
340
341		public PredicateSet createPredicateSet() throws JaxenException
342		{
343	46851	return new PredicateSet();
344		}
345
346		}