Coverage report

  %line %branch
org.apache.commons.validator.FormSet
57% 
80% 

 1  
 /*
 2  
  * $Id: FormSet.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  
 package org.apache.commons.validator;
 22  
 
 23  
 import java.io.Serializable;
 24  
 import java.util.Collections;
 25  
 import java.util.HashMap;
 26  
 import java.util.Iterator;
 27  
 import java.util.Map;
 28  
 import org.apache.commons.logging.Log;
 29  
 import org.apache.commons.logging.LogFactory;
 30  
 
 31  
 /**
 32  
  * Holds a set of <code>Form</code>s stored associated with a <code>Locale</code>
 33  
  * based on the country, language, and variant specified. Instances of this
 34  
  * class are configured with a &lt;formset&gt; xml element.
 35  
  */
 36  296
 public class FormSet implements Serializable {
 37  
 
 38  
     /** Logging */
 39  138
     private transient Log log = LogFactory.getLog(FormSet.class);
 40  
 
 41  
     /**
 42  
      * Whether or not the this <code>FormSet</code> was processed for replacing
 43  
      * variables in strings with their values.
 44  
      */
 45  138
     private boolean processed = false;
 46  
 
 47  
     /** Language component of <code>Locale</code> (required). */
 48  138
     private String language = null;
 49  
 
 50  
     /** Country component of <code>Locale</code> (optional). */
 51  138
     private String country = null;
 52  
 
 53  
     /** Variant component of <code>Locale</code> (optional). */
 54  138
     private String variant = null;
 55  
 
 56  
     /**
 57  
      * A <code>Map</code> of <code>Form</code>s using the name field of the
 58  
      * <code>Form</code> as the key.
 59  
      */
 60  138
     private Map forms = new HashMap();
 61  
 
 62  
     /**
 63  
      * A <code>Map</code> of <code>Constant</code>s using the name field of the
 64  
      * <code>Constant</code> as the key.
 65  
      */
 66  138
     private Map constants = new HashMap();
 67  
 
 68  
     /**
 69  
      * This is the type of <code>FormSet</code>s where no locale is specified.
 70  
      */
 71  
     protected final static int GLOBAL_FORMSET = 1;
 72  
 
 73  
     /**
 74  
      * This is the type of <code>FormSet</code>s where only language locale is
 75  
      * specified.
 76  
      */
 77  
     protected final static int LANGUAGE_FORMSET = 2;
 78  
 
 79  
     /**
 80  
      * This is the type of <code>FormSet</code>s where only language and country
 81  
      * locale are specified.
 82  
      */
 83  
     protected final static int COUNTRY_FORMSET = 3;
 84  
 
 85  
     /**
 86  
      * This is the type of <code>FormSet</code>s where full locale has been set.
 87  
      */
 88  
     protected final static int VARIANT_FORMSET = 4;
 89  
 
 90  
     /**
 91  
      * Flag indicating if this formSet has been merged with its parent (higher
 92  
      * rank in Locale hierarchy).
 93  
      */
 94  
     private boolean merged;
 95  
 
 96  
     /**
 97  
      * Has this formSet been merged?
 98  
      *
 99  
      * @return   true if it has been merged
 100  
      * @since    Validator 1.2.0
 101  
      */
 102  
     protected boolean isMerged() {
 103  0
         return merged;
 104  
     }
 105  
 
 106  
     /**
 107  
      * Returns the type of <code>FormSet</code>:<code>GLOBAL_FORMSET</code>,
 108  
      * <code>LANGUAGE_FORMSET</code>,<code>COUNTRY_FORMSET</code> or <code>VARIANT_FORMSET</code>
 109  
      * .
 110  
      *
 111  
      * @return                       The type value
 112  
      * @since                        Validator 1.2.0
 113  
      * @throws NullPointerException  if there is inconsistency in the locale
 114  
      *      definition (not sure about this)
 115  
      */
 116  
     protected int getType() {
 117  85
         if (getVariant() != null) {
 118  45
             if (getLanguage() == null || getCountry() == class="keyword">null) {
 119  0
                 throw new NullPointerException(
 120  
                     "When variant is specified, country and language must be specified.");
 121  
             }
 122  45
             return VARIANT_FORMSET;
 123  
         }
 124  40
         else if (getCountry() != null) {
 125  30
             if (getLanguage() == null) {
 126  0
                 throw new NullPointerException(
 127  
                     "When country is specified, language must be specified.");
 128  
             }
 129  30
             return COUNTRY_FORMSET;
 130  
         }
 131  10
         else if (getLanguage() != null) {
 132  10
             return LANGUAGE_FORMSET;
 133  
         }
 134  
         else {
 135  0
             return GLOBAL_FORMSET;
 136  
         }
 137  
     }
 138  
 
 139  
     /**
 140  
      * Merges the given <code>FormSet</code> into this one. If any of <code>depends</code>
 141  
      * s <code>Forms</code> are not in this <code>FormSet</code> then, include
 142  
      * them, else merge both <code>Forms</code>. Theoretically we should only
 143  
      * merge a "parent" formSet.
 144  
      *
 145  
      * @param depends  FormSet to be merged
 146  
      * @since          Validator 1.2.0
 147  
      */
 148  
     protected void merge(FormSet depends) {
 149  40
         if (depends != null) {
 150  40
             Map pForms = getForms();
 151  40
             Map dForms = depends.getForms();
 152  190
             for (Iterator it = dForms.keySet().iterator(); it.hasNext(); ) {
 153  110
                 Object key = it.next();
 154  110
                 Form pForm = (Form) pForms.get(key);
 155  110
                 if (pForm != null) {//merge, but principal 'rules', don't overwrite
 156  
                     // anything
 157  55
                     pForm.merge((Form) dForms.get(key));
 158  
                 }
 159  
                 else {//just add
 160  55
                     addForm((Form) dForms.get(key));
 161  
                 }
 162  
             }
 163  
         }
 164  40
         merged = true;
 165  40
     }
 166  
 
 167  
     /**
 168  
      * Whether or not the this <code>FormSet</code> was processed for replacing
 169  
      * variables in strings with their values.
 170  
      *
 171  
      * @return   The processed value
 172  
      */
 173  
     public boolean isProcessed() {
 174  40
         return processed;
 175  
     }
 176  
 
 177  
     /**
 178  
      * Gets the equivalent of the language component of <code>Locale</code>.
 179  
      *
 180  
      * @return   The language value
 181  
      */
 182  
     public String getLanguage() {
 183  263
         return language;
 184  
     }
 185  
 
 186  
     /**
 187  
      * Sets the equivalent of the language component of <code>Locale</code>.
 188  
      *
 189  
      * @param language  The new language value
 190  
      */
 191  
     public void setLanguage(String language) {
 192  134
         this.language = language;
 193  134
     }
 194  
 
 195  
     /**
 196  
      * Gets the equivalent of the country component of <code>Locale</code>.
 197  
      *
 198  
      * @return   The country value
 199  
      */
 200  
     public String getCountry() {
 201  238
         return country;
 202  
     }
 203  
 
 204  
     /**
 205  
      * Sets the equivalent of the country component of <code>Locale</code>.
 206  
      *
 207  
      * @param country  The new country value
 208  
      */
 209  
     public void setCountry(String country) {
 210  134
         this.country = country;
 211  134
     }
 212  
 
 213  
     /**
 214  
      * Gets the equivalent of the variant component of <code>Locale</code>.
 215  
      *
 216  
      * @return   The variant value
 217  
      */
 218  
     public String getVariant() {
 219  223
         return variant;
 220  
     }
 221  
 
 222  
     /**
 223  
      * Sets the equivalent of the variant component of <code>Locale</code>.
 224  
      *
 225  
      * @param variant  The new variant value
 226  
      */
 227  
     public void setVariant(String variant) {
 228  134
         this.variant = variant;
 229  134
     }
 230  
 
 231  
     /**
 232  
      * Add a <code>Constant</code> to the locale level.
 233  
      *
 234  
      * @param name   The constant name
 235  
      * @param value  The constant value
 236  
      */
 237  
     public void addConstant(String name, String value) {
 238  
 
 239  20
         if (constants.containsKey(name)) {
 240  0
             getLog().error("Constant '" + name +  "' already exists in FormSet["
 241  
                       + this.displayKey() + "] - ignoring.");
 242  
                        
 243  
         } else {
 244  20
             constants.put(name, value);
 245  
         }
 246  
 
 247  20
     }
 248  
 
 249  
     /**
 250  
      * Add a <code>Form</code> to the <code>FormSet</code>.
 251  
      *
 252  
      * @param f  The form
 253  
      */
 254  
     public void addForm(Form f) {
 255  
 
 256  472
         String formName = f.getName();
 257  472
         if (forms.containsKey(formName)) {
 258  0
             getLog().error("Form '" + formName + "' already exists in FormSet[" 
 259  
                       + this.displayKey() + "] - ignoring.");
 260  
                        
 261  
         } else {
 262  472
             forms.put(f.getName(), f);
 263  
         }
 264  
 
 265  472
     }
 266  
 
 267  
     /**
 268  
      * Retrieve a <code>Form</code> based on the form name.
 269  
      *
 270  
      * @param formName  The form name
 271  
      * @return          The form
 272  
      */
 273  
     public Form getForm(String formName) {
 274  163
         return (Form) this.forms.get(formName);
 275  
     }
 276  
 
 277  
     /**
 278  
      * A <code>Map</code> of <code>Form</code>s is returned as an unmodifiable
 279  
      * <code>Map</code> with the key based on the form name.
 280  
      *
 281  
      * @return   The forms map
 282  
      */
 283  
     public Map getForms() {
 284  80
         return Collections.unmodifiableMap(forms);
 285  
     }
 286  
 
 287  
     /**
 288  
      * Processes all of the <code>Form</code>s.
 289  
      *
 290  
      * @param globalConstants  Global constants
 291  
      */
 292  
     synchronized void process(Map globalConstants) {
 293  748
         for (Iterator i = class="keyword">forms.values().iterator(); i.hasNext(); ) {
 294  472
             Form f = (Form) i.next();
 295  472
             f.process(globalConstants, constants, forms);
 296  
         }
 297  
 
 298  138
         processed = true;
 299  138
     }
 300  
 
 301  
     /**
 302  
      * Returns a string representation of the object's key.
 303  
      *
 304  
      * @return   A string representation of the key
 305  
      */
 306  
     public String displayKey() {
 307  0
         StringBuffer results = new StringBuffer();
 308  0
         if (language != null && language.length() > 0) {
 309  0
             results.append("language=");
 310  0
             results.append(language);
 311  
         }
 312  0
         if (country != null && country.length() > 0) {
 313  0
             if (results.length() > 0) {
 314  0
                results.append(", ");
 315  
             }
 316  0
             results.append("country=");
 317  0
             results.append(country);
 318  
         }
 319  0
         if (variant != null && variant.length() > 0) {
 320  0
             if (results.length() > 0) {
 321  0
                results.append(", ");
 322  
             }
 323  0
             results.append("variant=");
 324  0
             results.append(variant );
 325  
         }
 326  0
         if (results.length() == 0) {
 327  0
            results.append("default");
 328  
         }
 329  
 
 330  0
         return results.toString();
 331  
     }
 332  
 
 333  
     /**
 334  
      * Returns a string representation of the object.
 335  
      *
 336  
      * @return   A string representation
 337  
      */
 338  
     public String toString() {
 339  0
         StringBuffer results = new StringBuffer();
 340  
 
 341  0
         results.append("FormSet: language=");
 342  0
         results.append(language);
 343  0
         results.append("  country=");
 344  0
         results.append(country);
 345  0
         results.append("  variant=");
 346  0
         results.append(variant);
 347  0
         results.append("\n");
 348  
 
 349  0
         for (Iterator i = getForms().values().iterator(); i.hasNext(); ) {
 350  0
             results.append("   ");
 351  0
             results.append(i.next());
 352  0
             results.append("\n");
 353  
         }
 354  
 
 355  0
         return results.toString();
 356  
     }
 357  
 
 358  
     /**
 359  
      * Accessor method for Log instance.
 360  
      *
 361  
      * The Log instance variable is transient and
 362  
      * accessing it through this method ensures it
 363  
      * is re-initialized when this instance is
 364  
      * de-serialized.
 365  
      *
 366  
      * @return The Log instance.
 367  
      */
 368  
     private Log getLog() {
 369  0
         if (log == null) {
 370  0
             log =  LogFactory.getLog(FormSet.class);
 371  
         }
 372  0
         return log;
 373  
     }
 374  
 }

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