dom4j - 1.6.1

Clover coverage report - dom4j - 1.6.1

Coverage timestamp: ma mei 16 2005 14:23:01 GMT+01:00

FRAMES NO FRAMES

file stats:	LOC:	331		Methods:	25
	NCLOC:	115		Classes:	1

Source file

Conditionals

Statements

Methods

TOTAL

Rule.java

50%

52,1%

60%

54,1%

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.rule;
9
10		import org.dom4j.Node;
11
12		/**
13		* <p>
14		* <code>Rule</code> matches against DOM4J Node so that some action can be
15		* performed such as in the XSLT processing model.
16		* </p>
17		*
18		* @author <a href="mailto:james.strachan@metastuff.com">James Strachan </a>
19		* @version $Revision: 1.7 $
20		*/
21		public class Rule implements Comparable {
22		/** Holds value of property mode. */
23		private String mode;
24
25		/** Holds value of property importPrecedence. */
26		private int importPrecedence;
27
28		/** Holds value of property priority. */
29		private double priority;
30
31		/** Holds value of property appearenceCount. */
32		private int appearenceCount;
33
34		/** Holds value of property pattern. */
35		private Pattern pattern;
36
37		/** Holds value of property action. */
38		private Action action;
39
40	0	public Rule() {
41	0	this.priority = Pattern.DEFAULT_PRIORITY;
42		}
43
44	32	public Rule(Pattern pattern) {
45	32	this.pattern = pattern;
46	32	this.priority = pattern.getPriority();
47		}
48
49	28	public Rule(Pattern pattern, Action action) {
50	28	this(pattern);
51	28	this.action = action;
52		}
53
54		/**
55		* Constructs a new Rule with the same instance data as the given rule but a
56		* different pattern.
57		*
58		* @param that
59		* DOCUMENT ME!
60		* @param pattern
61		* DOCUMENT ME!
62		*/
63	0	public Rule(Rule that, Pattern pattern) {
64	0	this.mode = that.mode;
65	0	this.importPrecedence = that.importPrecedence;
66	0	this.priority = that.priority;
67	0	this.appearenceCount = that.appearenceCount;
68	0	this.action = that.action;
69	0	this.pattern = pattern;
70		}
71
72	0	public boolean equals(Object that) {
73	0	if (that instanceof Rule) {
74	0	return compareTo((Rule) that) == 0;
75		}
76
77	0	return false;
78		}
79
80	2	public int hashCode() {
81	2	return importPrecedence + appearenceCount;
82		}
83
84	11	public int compareTo(Object that) {
85	11	if (that instanceof Rule) {
86	11	return compareTo((Rule) that);
87		}
88
89	0	return getClass().getName().compareTo(that.getClass().getName());
90		}
91
92		/**
93		* Compares two rules in XSLT processing model order assuming that the modes
94		* are equal.
95		*
96		* @param that
97		* DOCUMENT ME!
98		*
99		* @return DOCUMENT ME!
100		*/
101	12	public int compareTo(Rule that) {
102	12	int answer = this.importPrecedence - that.importPrecedence;
103
104	12	if (answer == 0) {
105	9	answer = (int) Math.round(this.priority - that.priority);
106
107	9	if (answer == 0) {
108	7	answer = this.appearenceCount - that.appearenceCount;
109		}
110		}
111
112	12	return answer;
113		}
114
115	2	public String toString() {
116	2	return super.toString() + "[ pattern: " + getPattern() + " action: "
117		+ getAction() + " ]";
118		}
119
120		/**
121		* DOCUMENT ME!
122		*
123		* @param node
124		* DOCUMENT ME!
125		*
126		* @return true if the pattern matches the given DOM4J node.
127		*/
128	52	public final boolean matches(Node node) {
129	52	return pattern.matches(node);
130		}
131
132		/**
133		* If this rule contains a union pattern then this method should return an
134		* array of Rules which describe the union rule, which should contain more
135		* than one rule. Otherwise this method should return null.
136		*
137		* @return an array of the rules which make up this union rule or null if
138		* this rule is not a union rule
139		*/
140	14	public Rule[] getUnionRules() {
141	14	Pattern[] patterns = pattern.getUnionPatterns();
142
143	14	if (patterns == null) {
144	14	return null;
145		}
146
147	0	int size = patterns.length;
148	0	Rule[] answer = new Rule[size];
149
150	0	for (int i = 0; i < size; i++) {
151	0	answer[i] = new Rule(this, patterns[i]);
152		}
153
154	0	return answer;
155		}
156
157		/**
158		* DOCUMENT ME!
159		*
160		* @return the type of node the pattern matches which by default should
161		* return ANY_NODE if it can match any kind of node.
162		*/
163	28	public final short getMatchType() {
164	28	return pattern.getMatchType();
165		}
166
167		/**
168		* For patterns which only match an ATTRIBUTE_NODE or an ELEMENT_NODE then
169		* this pattern may return the name of the element or attribute it matches.
170		* This allows a more efficient rule matching algorithm to be performed,
171		* rather than a brute force approach of evaluating every pattern for a
172		* given Node.
173		*
174		* @return the name of the element or attribute this pattern matches or null
175		* if this pattern matches any or more than one name.
176		*/
177	28	public final String getMatchesNodeName() {
178	28	return pattern.getMatchesNodeName();
179		}
180
181		/**
182		* Getter for property mode.
183		*
184		* @return Value of property mode.
185		*/
186	14	public String getMode() {
187	14	return mode;
188		}
189
190		/**
191		* Setter for property mode.
192		*
193		* @param mode
194		* New value of property mode.
195		*/
196	0	public void setMode(String mode) {
197	0	this.mode = mode;
198		}
199
200		/**
201		* Getter for property importPrecedence.
202		*
203		* @return Value of property importPrecedence.
204		*/
205	0	public int getImportPrecedence() {
206	0	return importPrecedence;
207		}
208
209		/**
210		* Setter for property importPrecedence.
211		*
212		* @param importPrecedence
213		* New value of property importPrecedence.
214		*/
215	14	public void setImportPrecedence(int importPrecedence) {
216	14	this.importPrecedence = importPrecedence;
217		}
218
219		/**
220		* Getter for property priority.
221		*
222		* @return Value of property priority.
223		*/
224	0	public double getPriority() {
225	0	return priority;
226		}
227
228		/**
229		* Setter for property priority.
230		*
231		* @param priority
232		* New value of property priority.
233		*/
234	0	public void setPriority(double priority) {
235	0	this.priority = priority;
236		}
237
238		/**
239		* Getter for property appearenceCount.
240		*
241		* @return Value of property appearenceCount.
242		*/
243	0	public int getAppearenceCount() {
244	0	return appearenceCount;
245		}
246
247		/**
248		* Setter for property appearenceCount.
249		*
250		* @param appearenceCount
251		* New value of property appearenceCount.
252		*/
253	14	public void setAppearenceCount(int appearenceCount) {
254	14	this.appearenceCount = appearenceCount;
255		}
256
257		/**
258		* Getter for property pattern.
259		*
260		* @return Value of property pattern.
261		*/
262	2	public Pattern getPattern() {
263	2	return pattern;
264		}
265
266		/**
267		* Setter for property pattern.
268		*
269		* @param pattern
270		* New value of property pattern.
271		*/
272	0	public void setPattern(Pattern pattern) {
273	0	this.pattern = pattern;
274		}
275
276		/**
277		* Getter for property action.
278		*
279		* @return Value of property action.
280		*/
281	30	public Action getAction() {
282	30	return action;
283		}
284
285		/**
286		* Setter for property action.
287		*
288		* @param action
289		* New value of property action.
290		*/
291	0	public void setAction(Action action) {
292	0	this.action = action;
293		}
294		}
295
296		/*
297		* Redistribution and use of this software and associated documentation
298		* ("Software"), with or without modification, are permitted provided that the
299		* following conditions are met:
300		*
301		* 1. Redistributions of source code must retain copyright statements and
302		* notices. Redistributions must also contain a copy of this document.
303		*
304		* 2. Redistributions in binary form must reproduce the above copyright notice,
305		* this list of conditions and the following disclaimer in the documentation
306		* and/or other materials provided with the distribution.
307		*
308		* 3. The name "DOM4J" must not be used to endorse or promote products derived
309		* from this Software without prior written permission of MetaStuff, Ltd. For
310		* written permission, please contact dom4j-info@metastuff.com.
311		*
312		* 4. Products derived from this Software may not be called "DOM4J" nor may
313		* "DOM4J" appear in their names without prior written permission of MetaStuff,
314		* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
315		*
316		* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
317		*
318		* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
319		* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
320		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
321		* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
322		* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
323		* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
324		* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
325		* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
326		* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
327		* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
328		* POSSIBILITY OF SUCH DAMAGE.
329		*
330		* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
331		*/