%line | %branch | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
org.apache.commons.validator.Validator |
|
|
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. |