Coverage report

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

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