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.