Coverage report

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

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

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