View Javadoc

1   package br.com.ibnetwork.guara.parameters;
2   
3   import java.math.BigDecimal;
4   import java.text.DateFormat;
5   import java.text.ParseException;
6   import java.text.SimpleDateFormat;
7   import java.util.ArrayList;
8   import java.util.Date;
9   import java.util.HashMap;
10  import java.util.List;
11  import java.util.Map;
12  import java.util.Set;
13  
14  import org.apache.commons.lang.StringUtils;
15  import org.apache.commons.logging.Log;
16  
17  import br.com.ibnetwork.xingu.utils.ArrayUtils;
18  
19  public class ValueParserSupport 
20  	implements ValueParser
21  {
22      protected String encoding;
23  
24      protected Log logger;
25      
26      protected Map map = new HashMap();
27  
28      public ValueParserSupport(String encoding)
29      {
30          this.encoding = encoding;
31      }
32      
33      private void logParseError(String key, Object value, Throwable t)
34      {
35          logger.error("Error trying to format ["+key+"] value["+value+"]",t);
36      }
37  
38      public String getEncoding()
39      {
40          return encoding;
41      }
42  
43      public Set keySet()
44      {
45          return map.keySet();
46      }
47  
48      public void clear()
49      {
50          map.clear();
51      }
52  
53      /*
54       * String
55       */
56      
57      public String getString(String key)
58      {
59          String[] value = (String[]) map.get(key);
60          return value != null ? value[0] : null;
61      }
62  
63      public String get(String key)
64      {
65          return getString(key);
66      }
67  
68      public String getTrimmed(String key)
69      {
70          String value = get(key);
71          return StringUtils.trimToNull(value);
72      }
73      
74      public String getString(String key, String defaultValue)
75      {
76          String value = getString(key);
77          return value != null ? value : defaultValue;
78      }
79      
80      public String[] getStrings(String key)
81      {
82          return (String[]) map.get(key);
83      }
84  
85      public String[] getStringsTrimmed(String key)
86      {
87          String[] array = (String[]) map.get(key);
88          if(array == null)
89          {
90              return null;
91          }
92          List tmp = new ArrayList(array.length);
93          for (int i = 0; i < array.length; i++)
94          {
95              String value = array[i];
96              value = StringUtils.trimToNull(value);
97              if(value != null)
98              {
99                  tmp.add(value);
100             }
101         }
102         String[] result = ArrayUtils.toStringArray(tmp.toArray());
103         return result;
104     }
105 
106     public String[] getStrings(String key, String[] defaultValue)
107     {
108         String[] value = getStrings(key);
109         return value != null ? value : defaultValue;
110     }
111 
112     public void setString(String key, String value)
113     {
114         map.put(key, new String[]{value});
115     }
116 
117     public void setStrings(String key, String[] values)
118     {
119         map.put(key, values);
120     }
121     public void add(String key, String value)
122     {
123         add(key, new String[]{value});
124     }
125 
126     public void add(String key, String[] value)
127     {
128         String[] values = (String[]) map.get(key);
129         if(values != null)
130         {
131             int size = values.length + value.length;
132             String[] newValues = new String[size];
133             System.arraycopy(values,0,newValues,0,values.length);
134             System.arraycopy(value,0,newValues,values.length,value.length);
135             value = newValues;
136         }
137         map.put(key,value);
138     }
139     
140     /*
141      * Boolean
142      */
143     
144     public Boolean getBooleanObject(String key)
145     {
146         String value = getTrimmed(key);
147         if(value == null)
148         {
149             return null;
150         }
151         if (value.equals("1") || value.equalsIgnoreCase("true")
152                 || value.equalsIgnoreCase("yes")
153                 || value.equalsIgnoreCase("on"))
154         {
155             return Boolean.TRUE;
156         }
157         return null;
158     }
159 
160     public Boolean getBooleanObject(String key, Boolean defaultValue)
161     {
162         Boolean value = getBooleanObject(key);
163         return value != null ? value : defaultValue;
164     }
165     
166     public boolean getBoolean(String key)
167     {
168         return getBoolean(key, false);
169     }
170     
171     public boolean getBoolean(String key, boolean defaultValue)
172     {
173         Boolean value = getBooleanObject(key);
174         return value != null ? value.booleanValue() : defaultValue;
175     }
176 
177     public Boolean[] getBooleanObjects(String key)
178     {
179         String[] value = getStringsTrimmed(key);
180         if(value == null)
181         {
182             return null;
183         }
184         Boolean[] result = new Boolean[value.length];
185         for (int i = 0; i < value.length; i++)
186         {
187             String v = value[i];
188             if (v.equals("1") || v.equalsIgnoreCase("true")
189                     || v.equalsIgnoreCase("yes")
190                     || v.equalsIgnoreCase("on"))
191             {
192                 result[i] = Boolean.TRUE;
193             }
194             else
195             {
196                 result[i] = Boolean.FALSE;
197             }
198         }
199         return result;
200     }
201     
202     /*
203      * Integer
204      */
205     
206     public int getInt(String key)
207     {
208         return getInt(key, 0);
209     }
210 
211     public int getInt(String key, int defaultValue)
212     {
213         Integer value = getIntObject(key);
214         return value != null ? value.intValue() : defaultValue;
215     }
216 
217     public int[] getInts(String key)
218     {
219         String[] value = getStringsTrimmed(key);
220         if(value == null)
221         {
222             return null;
223         }
224         int[] result = new int[value.length];
225         for (int i = 0; i < value.length; i++)
226         {
227             try
228             {
229                 result[i] = Integer.parseInt(value[i]);
230             }
231             catch (NumberFormatException e)
232             {
233                 logParseError(key,value,e);
234             }
235         }
236         return result;        
237     }
238 
239     public Integer getIntObject(String key, Integer defaultValue)
240     {
241         Integer value = getIntObject(key);
242         return value != null ? value : defaultValue;        
243     }
244 
245     public Integer getIntObject(String key)
246     {
247         String value = getTrimmed(key);
248         if(value == null)
249         {
250             return null;
251         }
252         try
253         {
254             return new Integer(value);
255         }
256         catch(NumberFormatException e)
257         {
258             logParseError(key, value, e);
259         }
260         return null;
261     }
262 
263     public Integer[] getIntObjects(String key)
264     {
265         String[] value = getStringsTrimmed(key);
266         if(value == null)
267         {
268             return null;
269         }
270         Integer[] result = new Integer[value.length];
271         for (int i = 0; i < value.length; i++)
272         {
273             try
274             {
275                 result[i] = new Integer(value[i]);
276             }
277             catch (NumberFormatException e)
278             {
279                 logParseError(key,value,e);
280             }
281         }
282         return result;
283     }
284 
285     /*
286      * Long
287      */
288     
289     public long getLong(String key)
290     {
291         return getLong(key, 0);
292     }
293 
294     public long getLong(String key, long defaultValue)
295     {
296         Long value = getLongObject(key);
297         return value != null ? value.longValue() : defaultValue;
298     }
299 
300     public long[] getLongs(String key)
301     {
302         String[] value = getStringsTrimmed(key);
303         if(value == null)
304         {
305             return null;
306         }
307         long[] result = new long[value.length];
308         for (int i = 0; i < value.length; i++)
309         {
310             try
311             {
312                 result[i] = Long.parseLong(value[i]);
313             }
314             catch (NumberFormatException e)
315             {
316                 logParseError(key,value,e);
317             }
318         }
319         return result;        
320     }
321 
322     public Long getLongObject(String key, Long defaultValue)
323     {
324         Long value = getLongObject(key);
325         return value != null ? value : defaultValue;        
326     }
327 
328     public Long getLongObject(String key)
329     {
330         String value = getTrimmed(key);
331         if(value == null)
332         {
333             return null;
334         }
335         try
336         {
337             return new Long(value);
338         }
339         catch(NumberFormatException e)
340         {
341             logParseError(key, value, e);
342         }
343         return null;
344     }
345 
346     public Long[] getLongObjects(String key)
347     {
348         String[] value = getStringsTrimmed(key);
349         if(value == null)
350         {
351             return null;
352         }
353         Long[] result = new Long[value.length];
354         for (int i = 0; i < value.length; i++)
355         {
356             try
357             {
358                 result[i] = new Long(value[i]);
359             }
360             catch (NumberFormatException e)
361             {
362                 logParseError(key,value,e);
363             }
364         }
365         return result;
366     }
367 
368     /*
369      * Float
370      */
371 
372     public Float getFloatObject(String key)
373     {
374         String value = getTrimmed(key);
375         if(value == null)
376         {
377             return null;
378         }
379         try
380         {
381             return new Float(value);
382         }
383         catch(NumberFormatException e)
384         {
385             logParseError(key,value,e);
386         }
387         return null;
388     }
389     
390     public Float getFloatObject(String key, Float defaultValue)
391     {
392         Float value = getFloatObject(key);
393         return value != null ? value : defaultValue;
394     }
395 
396     public float getFloat(String key)
397     {
398         return getFloat(key, 0.0f);
399     }
400 
401     public float getFloat(String key, float defaultValue)
402     {
403         Float value = getFloatObject(key);
404         return value != null ? value.floatValue() : defaultValue;
405     }
406 
407     public float[] getFloats(String key)
408     {
409         String[] value = getStrings(key);
410         if(value == null)
411         {
412             return null;
413         }
414         float[] result = new float[value.length];
415         for (int i = 0; i < value.length; i++)
416         {
417             try
418             {
419                 result[i] = Float.parseFloat(value[i]);
420             }
421             catch (NumberFormatException e)
422             {
423                 logParseError(key,value,e);
424             }
425         }
426         return result;
427     }
428 
429     public Float[] getFloatObjects(String key)
430     {
431         String[] value = getStringsTrimmed(key);
432         if(value == null)
433         {
434             return null;
435         }
436         Float[] result = new Float[value.length];
437         for (int i = 0; i < value.length; i++)
438         {
439             try
440             {
441                 result[i] = new Float(value[i]);
442             }
443             catch (NumberFormatException e)
444             {
445                 logParseError(key,value,e);
446             }
447         }
448         return result;
449     }
450 
451     /*
452      * Double
453      */
454 
455     public Double getDoubleObject(String key)
456     {
457         String value = getTrimmed(key);
458         if(value == null)
459         {
460             return null;
461         }
462         try
463         {
464             return new Double(value);
465         }
466         catch(NumberFormatException e)
467         {
468             logParseError(key,value,e);
469         }
470         return null;
471     }
472     
473     public Double getDoubleObject(String key, Double defaultValue)
474     {
475         Double value = getDoubleObject(key);
476         return value != null ? value : defaultValue;
477     }
478 
479     public double getDouble(String key)
480     {
481         return getDouble(key, 0.0);
482     }
483 
484     public double getDouble(String key, double defaultValue)
485     {
486         Double value = getDoubleObject(key);
487         return value != null ? value.doubleValue() : defaultValue;
488     }
489 
490     public double[] getDoubles(String key)
491     {
492         String[] value = getStrings(key);
493         if(value == null)
494         {
495             return null;
496         }
497         double[] result = new double[value.length];
498         for (int i = 0; i < value.length; i++)
499         {
500             try
501             {
502                 result[i] = Double.parseDouble(value[i]);
503             }
504             catch (NumberFormatException e)
505             {
506                 logParseError(key,value,e);
507             }
508         }
509         return result;
510     }
511 
512     public Double[] getDoubleObjects(String key)
513     {
514         String[] value = getStrings(key);
515         if(value == null)
516         {
517             return null;
518         }
519         Double[] result = new Double[value.length];
520         for (int i = 0; i < value.length; i++)
521         {
522             try
523             {
524                 result[i] = new Double(value[i]);
525             }
526             catch (NumberFormatException e)
527             {
528                 logParseError(key,value,e);
529             }
530         }
531         return result;
532     }
533 
534     /*
535      * BigDecimal
536      */
537 
538     public BigDecimal getBigDecimal(String key)
539     {
540         String value = getTrimmed(key);
541         if(value == null)
542         {
543             return null;
544         }
545         try
546         {
547             return new BigDecimal(value);
548         }
549         catch(NumberFormatException e)
550         {
551             logParseError(key,value,e);
552         }
553         return null;
554     }
555     
556     public BigDecimal getBigDecimal(String key, BigDecimal defaultValue)
557     {
558         BigDecimal value = getBigDecimal(key);
559         return value != null ? value : defaultValue;
560     }
561 
562     public BigDecimal[] getBigDecimals(String key)
563     {
564         String[] value = getStrings(key);
565         if(value == null)
566         {
567             return null;
568         }
569         BigDecimal[] result = new BigDecimal[value.length];
570         for (int i = 0; i < value.length; i++)
571         {
572             try
573             {
574                 result[i] = new BigDecimal(value[i]);
575             }
576             catch (NumberFormatException e)
577             {
578                 logParseError(key,value,e);
579             }
580         }
581         return result;
582     }
583 
584     /*
585      * Date
586      */
587 
588     public Date getDate(String key)
589     {
590         DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
591         return getDate(key, df);
592     }
593     
594     public Date getDate(String key, DateFormat format)
595     {
596         return getDate(key, format, null);
597     }
598 
599     public Date getDate(String key, DateFormat df, Date defaultValue)
600     {
601         Date result = defaultValue;
602         String value = getString(key);
603         if (value == null)
604         {
605             return null;
606         }
607         try
608         {
609             df.setLenient(false);
610             result = df.parse(value);
611         }
612         catch (ParseException e)
613         {
614             logger.error("Error parsing Date ["+key+"]", e);
615         }
616         return result;
617     }
618     
619     /*
620      * Object
621      */
622     
623     public Object getObject(String key)
624     {
625         return getString(key);
626     }
627 
628     public Object[] getObjects(String key)
629     {
630         return getStrings(key);
631     }
632 }