%line	%branch
org.apache.commons.validator.Validator	57%	93%

1		/*
2		* $Id: Validator.java 366933 2006-01-07 22:51:01Z niallp $
3		* $Rev: 366933 $
4		* $Date: 2006-01-07 22:51:01 +0000 (Sat, 07 Jan 2006) $
5		*
6		* ====================================================================
7		* Copyright 2001-2006 The Apache Software Foundation
8		*
9		* Licensed under the Apache License, Version 2.0 (the "License");
10		* you may not use this file except in compliance with the License.
11		* You may obtain a copy of the License at
12		*
13		* http://www.apache.org/licenses/LICENSE-2.0
14		*
15		* Unless required by applicable law or agreed to in writing, software
16		* distributed under the License is distributed on an "AS IS" BASIS,
17		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18		* See the License for the specific language governing permissions and
19		* limitations under the License.
20		*/
21
22		package org.apache.commons.validator;
23
24		import java.io.Serializable;
25		import java.util.HashMap;
26		import java.util.Locale;
27		import java.util.Map;
28
29		/**
30		* Validations are processed by the validate method. An instance of
31		* <code>ValidatorResources</code> is used to define the validators
32		* (validation methods) and the validation rules for a JavaBean.
33		*/
34		public class Validator implements Serializable {
35
36		/**
37		* Resources key the JavaBean is stored to perform validation on.
38		*/
39		public static final String BEAN_PARAM = "java.lang.Object";
40
41		/**
42		* Resources key the <code>ValidatorAction</code> is stored under.
43		* This will be automatically passed into a validation method
44		* with the current <code>ValidatorAction</code> if it is
45		* specified in the method signature.
46		*/
47		public static final String VALIDATOR_ACTION_PARAM =
48		"org.apache.commons.validator.ValidatorAction";
49
50		/**
51		* Resources key the <code>ValidatorResults</code> is stored under.
52		* This will be automatically passed into a validation method
53		* with the current <code>ValidatorResults</code> if it is
54		* specified in the method signature.
55		*/
56		public static final String VALIDATOR_RESULTS_PARAM =
57		"org.apache.commons.validator.ValidatorResults";
58
59		/**
60		* Resources key the <code>Form</code> is stored under.
61		* This will be automatically passed into a validation method
62		* with the current <code>Form</code> if it is
63		* specified in the method signature.
64		*/
65		public static final String FORM_PARAM = "org.apache.commons.validator.Form";
66
67		/**
68		* Resources key the <code>Field</code> is stored under.
69		* This will be automatically passed into a validation method
70		* with the current <code>Field</code> if it is
71		* specified in the method signature.
72		*/
73		public static final String FIELD_PARAM = "org.apache.commons.validator.Field";
74
75		/**
76		* Resources key the <code>Validator</code> is stored under.
77		* This will be automatically passed into a validation method
78		* with the current <code>Validator</code> if it is
79		* specified in the method signature.
80		*/
81		public static final String VALIDATOR_PARAM =
82		"org.apache.commons.validator.Validator";
83
84		/**
85		* Resources key the <code>Locale</code> is stored.
86		* This will be used to retrieve the appropriate
87		* <code>FormSet</code> and <code>Form</code> to be
88		* processed.
89		*/
90		public static final String LOCALE_PARAM = "java.util.Locale";
91
92		/**
93		* The Validator Resources.
94		*/
95	110	protected ValidatorResources resources = null;
96
97		/**
98		* The name of the form to validate
99		*/
100	110	protected String formName = null;
101
102		/**
103		* The name of the field on the form to validate
104		* @since 1.2.0
105		*/
106	110	protected String fieldName = null;
107
108		/**
109		* Maps validation method parameter class names to the objects to be passed
110		* into the method.
111		*/
112	110	protected Map parameters = new HashMap();
113
114		/**
115		* The current page number to validate.
116		*/
117	110	protected int page = 0;
118
119		/**
120		* The class loader to use for instantiating application objects.
121		* If not specified, the context class loader, or the class loader
122		* used to load Digester itself, is used, based on the value of the
123		* <code>useContextClassLoader</code> variable.
124		*/
125	110	protected ClassLoader classLoader = null;
126
127		/**
128		* Whether or not to use the Context ClassLoader when loading classes
129		* for instantiating new objects. Default is <code>false</code>.
130		*/
131	110	protected boolean useContextClassLoader = false;
132
133		/**
134		* Set this to true to not return Fields that pass validation. Only return failures.
135		*/
136	110	protected boolean onlyReturnErrors = false;
137
138		/**
139		* Construct a <code>Validator</code> that will
140		* use the <code>ValidatorResources</code>
141		* passed in to retrieve pluggable validators
142		* the different sets of validation rules.
143		*
144		* @param resources <code>ValidatorResources</code> to use during validation.
145		*/
146		public Validator(ValidatorResources resources) {
147	0	this(resources, null);
148	0	}
149
150		/**
151		* Construct a <code>Validator</code> that will
152		* use the <code>ValidatorResources</code>
153		* passed in to retrieve pluggable validators
154		* the different sets of validation rules.
155		*
156		* @param resources <code>ValidatorResources</code> to use during validation.
157		* @param formName Key used for retrieving the set of validation rules.
158		*/
159	109	public Validator(ValidatorResources resources, String formName) {
160	109	if (resources == null) {
161	0	throw new IllegalArgumentException("Resources cannot be null.");
162		}
163
164	109	this.resources = resources;
165	109	this.formName = formName;
166	109	}
167
168		/**
169		* Construct a <code>Validator</code> that will
170		* use the <code>ValidatorResources</code>
171		* passed in to retrieve pluggable validators
172		* the different sets of validation rules.
173		*
174		* @param resources <code>ValidatorResources</code> to use during validation.
175		* @param formName Key used for retrieving the set of validation rules.
176		* @param fieldName Key used for retrieving the set of validation rules for a field
177		* @since 1.2.0
178		*/
179	1	public Validator(ValidatorResources resources, String formName, String fieldName) {
180	1	if (resources == null) {
181	0	throw new IllegalArgumentException("Resources cannot be null.");
182		}
183
184	1	this.resources = resources;
185	1	this.formName = formName;
186	1	this.fieldName = fieldName;
187	1	}
188
189		/**
190		* Set a parameter of a pluggable validation method.
191		*
192		* @param parameterClassName The full class name of the parameter of the
193		* validation method that corresponds to the value/instance passed in with it.
194		*
195		* @param parameterValue The instance that will be passed into the
196		* validation method.
197		*/
198		public void setParameter(String parameterClassName, Object parameterValue) {
199	346	this.parameters.put(parameterClassName, parameterValue);
200	346	}
201
202		/**
203		* Returns the value of the specified parameter that will be used during the
204		* processing of validations.
205		*
206		* @param parameterClassName The full class name of the parameter of the
207		* validation method that corresponds to the value/instance passed in with it.
208		* @return value of the specified parameter.
209		*/
210		public Object getParameterValue(String parameterClassName) {
211	123	return this.parameters.get(parameterClassName);
212		}
213
214		/**
215		* Gets the form name which is the key to a set of validation rules.
216		* @return the name of the form.
217		*/
218		public String getFormName() {
219	0	return formName;
220		}
221
222		/**
223		* Sets the form name which is the key to a set of validation rules.
224		* @param formName the name of the form.
225		*/
226		public void setFormName(String formName) {
227	0	this.formName = formName;
228	0	}
229
230		/**
231		* Sets the name of the field to validate in a form (optional)
232		*
233		* @param fieldName The name of the field in a form set
234		* @since 1.2.0
235		*/
236		public void setFieldName(String fieldName) {
237	0	this.fieldName = fieldName;
238	0	}
239
240		/**
241		* Gets the page. This in conjunction with the page property of
242		* a <code>Field<code> can control the processing of fields. If the field's
243		* page is less than or equal to this page value, it will be processed.
244		* @return the page number.
245		*/
246		public int getPage() {
247	0	return page;
248		}
249
250		/**
251		* Sets the page. This in conjunction with the page property of
252		* a <code>Field<code> can control the processing of fields. If the field's page
253		* is less than or equal to this page value, it will be processed.
254		* @param page the page number.
255		*/
256		public void setPage(int page) {
257	0	this.page = page;
258	0	}
259
260		/**
261		* Clears the form name, resources that were added, and the page that was
262		* set (if any). This can be called to reinitialize the Validator instance
263		* so it can be reused. The form name (key to set of validation rules) and any
264		* resources needed, like the JavaBean being validated, will need to
265		* set and/or added to this instance again. The
266		* <code>ValidatorResources</code> will not be removed since it can be used
267		* again and is thread safe.
268		*/
269		public void clear() {
270	0	this.formName = null;
271	0	this.fieldName = null;
272	0	this.parameters = new HashMap();
273	0	this.page = 0;
274	0	}
275
276		/**
277		* Return the boolean as to whether the context classloader should be used.
278		* @return whether the context classloader should be used.
279		*/
280		public boolean getUseContextClassLoader() {
281	0	return this.useContextClassLoader;
282		}
283
284		/**
285		* Determine whether to use the Context ClassLoader (the one found by
286		* calling <code>Thread.currentThread().getContextClassLoader()</code>)
287		* to resolve/load classes that are defined in various rules. If not
288		* using Context ClassLoader, then the class-loading defaults to
289		* using the calling-class' ClassLoader.
290		*
291		* @param use determines whether to use Context ClassLoader.
292		*/
293		public void setUseContextClassLoader(boolean use) {
294	0	this.useContextClassLoader = use;
295	0	}
296
297		/**
298		* Return the class loader to be used for instantiating application objects
299		* when required. This is determined based upon the following rules:
300		* <ul>
301		* <li>The class loader set by <code>setClassLoader()</code>, if any</li>
302		* <li>The thread context class loader, if it exists and the
303		* <code>useContextClassLoader</code> property is set to true</li>
304		* <li>The class loader used to load the Digester class itself.
305		* </ul>
306		* @return the class loader.
307		*/
308		public ClassLoader getClassLoader() {
309	165	if (this.classLoader != null) {
310	0	return this.classLoader;
311		}
312
313	165	if (this.useContextClassLoader) {
314	0	ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
315	0	if (contextLoader != null) {
316	0	return contextLoader;
317		}
318		}
319
320	165	return this.getClass().getClassLoader();
321		}
322
323		/**
324		* Set the class loader to be used for instantiating application objects
325		* when required.
326		*
327		* @param classLoader The new class loader to use, or <code>null</code>
328		* to revert to the standard rules
329		*/
330		public void setClassLoader(ClassLoader classLoader) {
331	0	this.classLoader = classLoader;
332	0	}
333
334		/**
335		* Performs validations based on the configured resources.
336		*
337		* @return The <code>Map</code> returned uses the property of the
338		* <code>Field</code> for the key and the value is the number of error the
339		* field had.
340		* @throws ValidatorException If an error occurs during validation
341		*/
342		public ValidatorResults validate() throws ValidatorException {
343	113	Locale locale = (Locale) this.getParameterValue(LOCALE_PARAM);
344
345	113	if (locale == null) {
346	104	locale = Locale.getDefault();
347		}
348
349	113	this.setParameter(VALIDATOR_PARAM, class="keyword">this);
350
351	113	Form form = this.resources.getForm(locale, class="keyword">this.formName);
352	113	if (form != null) {
353	113	this.setParameter(FORM_PARAM, class="keyword">this);
354	113	return form.validate(
355		this.parameters,
356		this.resources.getValidatorActions(),
357		this.page,
358		this.fieldName);
359		}
360
361	0	return new ValidatorResults();
362		}
363
364		/**
365		* Returns true if the Validator is only returning Fields that fail validation.
366		* @return whether only failed fields are returned.
367		*/
368		public boolean getOnlyReturnErrors() {
369	90	return onlyReturnErrors;
370		}
371
372		/**
373		* Configures which Fields the Validator returns from the validate() method. Set this
374		* to true to only return Fields that failed validation. By default, validate() returns
375		* all fields.
376		* @param onlyReturnErrors whether only failed fields are returned.
377		*/
378		public void setOnlyReturnErrors(boolean onlyReturnErrors) {
379	1	this.onlyReturnErrors = onlyReturnErrors;
380	1	}
381
382		}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.