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.