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.