%line | %branch | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
org.apache.commons.validator.FormSet |
|
|
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 <formset> 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. |