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

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

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