Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.validator.Form |
82% |
93% |

1 |  |
     /*
2 |  |
      * $Id: Form.java 280974 2005-09-15 00:06:59Z niallp $
3 |  |
      * $Rev: 280974 $
4 |  |
      * $Date: 2005-09-15 01:06:59 +0100 (Thu, 15 Sep 2005) $
5 |  |
      *
6 |  |
      * ====================================================================
7 |  |
      * Copyright 2001-2005 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 |  |
     package org.apache.commons.validator;
22 |  |
23 |  |
     import java.io.Serializable;
24 |  |
     import java.util.ArrayList;
25 |  |
     import java.util.Collections;
26 |  |
     import java.util.Iterator;
27 |  |
     import java.util.List;
28 |  |
     import java.util.Map;
29 |  |
30 |  |
     import org.apache.commons.collections.FastHashMap;// DEPRECATED
31 |  |
32 |  |
     /**
33 |  |
      * <p>
34 |  |
      *
35 |  |
      * This contains a set of validation rules for a form/JavaBean. The information
36 |  |
      * is contained in a list of <code>Field</code> objects. Instances of this class
37 |  |
      * are configured with a &lt;form&gt; xml element. </p> <p>
38 |  |
      *
39 |  |
      * The use of FastHashMap is deprecated and will be replaced in a future
40 |  |
      * release. </p>
41 |  |
      */
42 | 834 |
     public class Form implements Serializable {
43 |  |
44 |  |
         /** The name/key the set of validation rules is stored under. */
45 | 417 |
         protected String name = null;
46 |  |
47 |  |
         /**
48 |  |
          * List of <code>Field</code>s. Used to maintain the order they were added
49 |  |
          * in although individual <code>Field</code>s can be retrieved using <code>Map</code>
50 |  |
          * of <code>Field</code>s.
51 |  |
          */
52 | 417 |
         protected List lFields = new ArrayList();
53 |  |
54 |  |
         /**
55 |  |
          * Map of <code>Field</code>s keyed on their property value.
56 |  |
          *
57 |  |
          * @deprecated   Subclasses should use getFieldMap() instead.
58 |  |
          */
59 | 417 |
         protected FastHashMap hFields = new FastHashMap();
60 |  |
61 |  |
         /**
62 |  |
          * The name/key of the form which this form extends from.
63 |  |
          *
64 |  |
          * @since   Validator 1.2.0
65 |  |
          */
66 | 417 |
         protected String inherit = null;
67 |  |
68 |  |
         /**
69 |  |
          * Whether or not the this <code>Form</code> was processed for replacing
70 |  |
          * variables in strings with their values.
71 |  |
          */
72 | 417 |
         private boolean processed = false;
73 |  |
74 |  |
         /**
75 |  |
          * Gets the name/key of the set of validation rules.
76 |  |
          *
77 |  |
          * @return   The name value
78 |  |
          */
79 |  |
         public String getName() {
80 | 944 |
             return name;
81 |  |
         }
82 |  |
83 |  |
         /**
84 |  |
          * Sets the name/key of the set of validation rules.
85 |  |
          *
86 |  |
          * @param name  The new name value
87 |  |
          */
88 |  |
         public void setName(String name) {
89 | 417 |
             this.name = name;
90 | 417 |
         }
91 |  |
92 |  |
         /**
93 |  |
          * Add a <code>Field</code> to the <code>Form</code>.
94 |  |
          *
95 |  |
          * @param f  The field
96 |  |
          */
97 |  |
         public void addField(Field f) {
98 | 504 |
             this.lFields.add(f);
99 | 504 |
             this.hFields.put(f.getKey(), f);
100 | 504 |
         }
101 |  |
102 |  |
         /**
103 |  |
          * A <code>List</code> of <code>Field</code>s is returned as an unmodifiable
104 |  |
          * <code>List</code>.
105 |  |
          *
106 |  |
          * @return   The fields value
107 |  |
          */
108 |  |
         public List getFields() {
109 | 77 |
             return Collections.unmodifiableList(lFields);
110 |  |
         }
111 |  |
112 |  |
         /**
113 |  |
          * Returns the Field with the given name or null if this Form has no such
114 |  |
          * field.
115 |  |
          *
116 |  |
          * @param fieldName  The field name
117 |  |
          * @return           The field value
118 |  |
          * @since            Validator 1.1
119 |  |
          */
120 |  |
         public Field getField(String fieldName) {
121 | 100 |
             return (Field) this.hFields.get(fieldName);
122 |  |
         }
123 |  |
124 |  |
         /**
125 |  |
          * Returns true if this Form contains a Field with the given name.
126 |  |
          *
127 |  |
          * @param fieldName  The field name
128 |  |
          * @return           True if this form contains the field by the given name
129 |  |
          * @since            Validator 1.1
130 |  |
          */
131 |  |
         public boolean containsField(String fieldName) {
132 | 70 |
             return this.hFields.containsKey(fieldName);
133 |  |
         }
134 |  |
135 |  |
         /**
136 |  |
          * Merges the given form into this one. For any field in <code>depends</code>
137 |  |
          * not present in this form, include it. <code>depends</code> has precedence
138 |  |
          * in the way the fields are ordered.
139 |  |
          *
140 |  |
          * @param depends  the form we want to merge
141 |  |
          * @since          Validator 1.2.0
142 |  |
          */
143 |  |
         protected void merge(Form depends) {
144 |  |
145 | 55 |
             List templFields = new ArrayList();
146 | 55 |
             Map temphFields = new FastHashMap();
147 | 55 |
             Iterator dependsIt = depends.getFields().iterator();
148 | 180 |
             while (dependsIt.hasNext()) {
149 | 70 |
                 Field defaultField = (Field) dependsIt.next();
150 | 70 |
                 if (defaultField != null) {
151 | 70 |
                     String fieldKey = defaultField.getKey();
152 | 70 |
                     if (!this.containsField(fieldKey)) {
153 | 0 |
                         templFields.add(defaultField);
154 | 0 |
                         temphFields.put(fieldKey, defaultField);
155 |  |
                     }
156 |  |
                     else {
157 | 70 |
                         Field old = getField(fieldKey);
158 | 70 |
                         hFields.remove(fieldKey);
159 | 70 |
                         lFields.remove(old);
160 | 70 |
                         templFields.add(old);
161 | 70 |
                         temphFields.put(fieldKey, old);
162 |  |
                     }
163 |  |
                 }
164 |  |
             }
165 | 55 |
             lFields.addAll(0, templFields);
166 | 55 |
             hFields.putAll(temphFields);
167 | 55 |
         }
168 |  |
169 |  |
         /**
170 |  |
          * Processes all of the <code>Form</code>'s <code>Field</code>s.
171 |  |
          *
172 |  |
          * @param globalConstants  A map of global constants
173 |  |
          * @param constants        Local constants
174 |  |
          * @param forms            Map of forms
175 |  |
          * @since                  Validator 1.2.0
176 |  |
          */
177 |  |
         protected void process(Map globalConstants, Map constants, Map forms) {
178 | 488 |
             if (isProcessed()) {
179 | 71 |
                 return;
180 |  |
             }
181 |  |
182 | 417 |
             int n = 0;//we want the fields from its parent first
183 | 417 |
             if (isExtending()) {
184 | 16 |
                 Form parent = (Form) forms.get(inherit);
185 | 16 |
                 if (parent != null) {
186 | 16 |
                     if (!parent.isProcessed()) {
187 |  |
                         //we want to go all the way up the tree
188 | 16 |
                         parent.process(constants, globalConstants, forms);
189 |  |
                     }
190 | 56 |
                     for (Iterator i = parent.getFields().iterator(); i.hasNext(); ) {
191 | 24 |
                         Field f = (Field) i.next();
192 |  |
                         //we want to be able to override any fields we like
193 | 24 |
                         if (hFields.get(f.getKey()) == null) {
194 | 8 |
                             lFields.add(n, f);
195 | 8 |
                             hFields.put(f.getKey(), f);
196 | 8 |
                             n++;
197 |  |
                         }
198 |  |
                     }
199 |  |
                 }
200 |  |
             }
201 | 417 |
             hFields.setFast(true);
202 |  |
             //no need to reprocess parent's fields, we iterate from 'n'
203 | 1338 |
             for (Iterator i = lFields.listIterator(n); i.hasNext(); ) {
204 | 504 |
                 Field f = (Field) i.next();
205 | 504 |
                 f.process(globalConstants, constants);
206 |  |
             }
207 |  |
208 | 417 |
             processed = true;
209 | 417 |
         }
210 |  |
211 |  |
         /**
212 |  |
          * Returns a string representation of the object.
213 |  |
          *
214 |  |
          * @return string representation
215 |  |
          */
216 |  |
         public String toString() {
217 | 0 |
             StringBuffer results = new StringBuffer();
218 |  |
219 | 0 |
             results.append("Form: ");
220 | 0 |
             results.append(name);
221 | 0 |
             results.append("\n");
222 |  |
223 | 0 |
             for (Iterator i = lFields.iterator(); i.hasNext(); ) {
224 | 0 |
                 results.append("\tField: \n");
225 | 0 |
                 results.append(i.next());
226 | 0 |
                 results.append("\n");
227 |  |
             }
228 |  |
229 | 0 |
             return results.toString();
230 |  |
         }
231 |  |
232 |  |
         /**
233 |  |
          * Validate all Fields in this Form on the given page and below.
234 |  |
          *
235 |  |
          * @param params               A Map of parameter class names to parameter
236 |  |
          *      values to pass into validation methods.
237 |  |
          * @param actions              A Map of validator names to ValidatorAction
238 |  |
          *      objects.
239 |  |
          * @param page                 Fields on pages higher than this will not be
240 |  |
          *      validated.
241 |  |
          * @return                     A ValidatorResults object containing all
242 |  |
          *      validation messages.
243 |  |
          * @throws ValidatorException
244 |  |
          */
245 |  |
         ValidatorResults validate(Map params, Map actions, int page)
246 |  |
             throws ValidatorException {
247 | 0 |
             return validate(params, actions, page, null);
248 |  |
         }
249 |  |
250 |  |
         /**
251 |  |
          * Validate all Fields in this Form on the given page and below.
252 |  |
          *
253 |  |
          * @param params               A Map of parameter class names to parameter
254 |  |
          *      values to pass into validation methods.
255 |  |
          * @param actions              A Map of validator names to ValidatorAction
256 |  |
          *      objects.
257 |  |
          * @param page                 Fields on pages higher than this will not be
258 |  |
          *      validated.
259 |  |
          * @return                     A ValidatorResults object containing all
260 |  |
          *      validation messages.
261 |  |
          * @throws ValidatorException
262 |  |
          * @since 1.2.0
263 |  |
          */
264 |  |
         ValidatorResults validate(Map params, Map actions, int page, String fieldName)
265 |  |
             throws ValidatorException {
266 |  |
267 | 113 |
             ValidatorResults results = new ValidatorResults();
268 | 113 |
             params.put(Validator.VALIDATOR_RESULTS_PARAM, results);
269 |  |
270 |  |
             // Only validate a single field if specified
271 | 113 |
             if (fieldName != null) {
272 | 1 |
                 Field field = (Field) this.hFields.get(fieldName);
273 |  |
274 | 1 |
                 if (field == null) {
275 | 0 |
                    throw new ValidatorException("Unknown field "+fieldName+" in form "+getName());
276 |  |
                 }
277 | 1 |
                 params.put(Validator.FIELD_PARAM, field);
278 |  |
279 | 1 |
                 if (field.getPage() <= page) {
280 | 1 |
                    results.merge(field.validate(params, actions));
281 |  |
                 }
282 |  |
             } else {
283 | 112 |
                 Iterator fields = this.lFields.iterator();
284 | 384 |
                 while (fields.hasNext()) {
285 | 161 |
                     Field field = (Field) fields.next();
286 |  |
287 | 161 |
                     params.put(Validator.FIELD_PARAM, field);
288 |  |
289 | 161 |
                     if (field.getPage() <= page) {
290 | 161 |
                         results.merge(field.validate(params, actions));
291 |  |
                     }
292 |  |
                 }
293 |  |
             }
294 |  |
295 | 112 |
             return results;
296 |  |
         }
297 |  |
298 |  |
         /**
299 |  |
          * Whether or not the this <code>Form</code> was processed for replacing
300 |  |
          * variables in strings with their values.
301 |  |
          *
302 |  |
          * @return   The processed value
303 |  |
          * @since    Validator 1.2.0
304 |  |
          */
305 |  |
         public boolean isProcessed() {
306 | 504 |
             return processed;
307 |  |
         }
308 |  |
309 |  |
         /**
310 |  |
          * Gets the name/key of the parent set of validation rules.
311 |  |
          *
312 |  |
          * @return   The extends value
313 |  |
          * @since    Validator 1.2.0
314 |  |
          */
315 |  |
         public String getExtends() {
316 | 0 |
             return inherit;
317 |  |
         }
318 |  |
319 |  |
         /**
320 |  |
          * Sets the name/key of the parent set of validation rules.
321 |  |
          *
322 |  |
          * @param inherit  The new extends value
323 |  |
          * @since          Validator 1.2.0
324 |  |
          */
325 |  |
         public void setExtends(String inherit) {
326 | 16 |
             this.inherit = inherit;
327 | 16 |
         }
328 |  |
329 |  |
         /**
330 |  |
          * Get extends flag.
331 |  |
          *
332 |  |
          * @return   The extending value
333 |  |
          * @since    Validator 1.2.0
334 |  |
          */
335 |  |
         public boolean isExtending() {
336 | 417 |
             return inherit != null;
337 |  |
         }
338 |  |
339 |  |
         /**
340 |  |
          * Returns a Map of String field keys to Field objects.
341 |  |
          *
342 |  |
          * @return   The fieldMap value
343 |  |
          * @since    Validator 1.2.0
344 |  |
          */
345 |  |
         protected Map getFieldMap() {
346 | 0 |
             return hFields;
347 |  |
         }
348 |  |
     }

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