SetupReader


1   /*
2    * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
3    * 
4    * Project: OpenSubsystems
5    * 
6    * $Id: SetupReader.java,v 1.6 2007/01/07 06:14:00 bastafidli Exp $
7    * 
8    * This program is free software; you can redistribute it and/or modify
9    * it under the terms of the GNU General Public License as published by
10   * the Free Software Foundation; version 2 of the License. 
11   * 
12   * This program is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   * GNU General Public License for more details.
16   * 
17   * You should have received a copy of the GNU General Public License
18   * along with this program; if not, write to the Free Software
19   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
20   */
21  
22  package org.opensubsystems.core.util;
23  
24  import java.io.File  ;
25  import java.util.HashMap  ;
26  import java.util.Map  ;
27  import java.util.Properties  ;
28  import java.util.logging.Level  ;
29  import java.util.logging.Logger  ;
30  
31  /**
32   * Reads properties from property file for named objects. It allows to specify 
33   * set of default properties and then override the properties for an instance 
34   * with specified name. If an overriden property for an object with specified 
35   * name doesn't exist, the default peroperty will be used.
36   * 
37   * Each property name consist from three parts. base path, reader name and 
38   * parameter name. Property name looks like <xxx>.<yyy>.<zzz> where
39   * xxx is base path (for example oss.receiver) yyy is reader name (for example 
40   * defaultfax) and zzz is parameter name (for example priority). Result will be
41   * oss.receiver.defaultfax.priority
42   * 
43   * @version $Id: SetupReader.java,v 1.6 2007/01/07 06:14:00 bastafidli Exp $
44   * @author Martin Cerba
45   * @code.reviewer Miro Halas
46   * @code.reviewed 1.4 2006/01/12 05:53:08 bastafidli
47   */
48  public abstract class SetupReader
49  {
50     // Constants ////////////////////////////////////////////////////////////////
51     
52     /**
53      * Constant for parameter data type
54      */
55     public static final int PARAMETER_TYPE_UNKNOWN = 0;
56     
57     /**
58      * Constant for parameter data type object
59      */
60     public static final Integer   PARAMETER_TYPE_UNKNOWN_OBJ = new Integer  (PARAMETER_TYPE_UNKNOWN);
61  
62     /**
63      * Constant for parameter data type
64      */
65     public static final int PARAMETER_TYPE_STRING = 1;
66     
67     /**
68      * Constant for parameter data type object
69      */
70     public static final Integer   PARAMETER_TYPE_STRING_OBJ = new Integer  (PARAMETER_TYPE_STRING);
71     
72     /**
73      * Constant for parameter data type
74      */
75     public static final int PARAMETER_TYPE_INTEGER = 2;
76     
77     /**
78      * Constant for parameter data type object
79      */
80     public static final Integer   PARAMETER_TYPE_INTEGER_OBJ = new Integer  (PARAMETER_TYPE_INTEGER);
81     
82     /**
83      * Constant for parameter data type object
84      */
85     public static final int PARAMETER_TYPE_DOUBLE = 3;
86     
87     /**
88      * Constant for parameter data type object
89      */
90     public static final Integer   PARAMETER_TYPE_DOUBLE_OBJ = new Integer  (PARAMETER_TYPE_DOUBLE);
91     
92     /**
93      * Constant for parameter data type object
94      */
95     public static final int PARAMETER_TYPE_FLOAT = 4;
96     
97     /**
98      * Constant for parameter data type object
99      */
100    public static final Integer   PARAMETER_TYPE_FLOAT_OBJ = new Integer  (PARAMETER_TYPE_FLOAT);
101 
102    /**
103     * Constant for parameter data type object
104     */
105    public static final int PARAMETER_TYPE_BOOLEAN = 5;
106    
107    /**
108     * Constant for parameter data type object
109     */
110    public static final Integer   PARAMETER_TYPE_BOOLEAN_OBJ = new Integer  (PARAMETER_TYPE_BOOLEAN);
111 
112    /**
113     * Constant for parameter data type object
114     */
115    public static final int PARAMETER_TYPE_LONG = 6;
116    
117    /**
118     * Constant for parameter data type object
119     */
120    public static final Integer   PARAMETER_TYPE_LONG_OBJ = new Integer  (PARAMETER_TYPE_LONG);
121 
122    /**
123     * Constant for parameter data type object
124     */
125    public static final int PARAMETER_TYPE_PATH = 7;
126    
127    /**
128     * Constant for parameter data type object
129     */
130    public static final Integer   PARAMETER_TYPE_PATH_OBJ = new Integer  (PARAMETER_TYPE_PATH);
131 
132    // Attributes ///////////////////////////////////////////////////////////////
133    
134    /**
135     * Name of this reader. This name is added to base path to get full parameter 
136     * name.
137     */
138    protected String   m_readerName;
139    
140    /**
141     * Base path of this reader. Each property name consist from three parts. 
142     * base path, reader name and parameter name. Property name looks like 
143     * <xxx>.<yyy>.<zzz> where xxx is base path (for example oss.receiver) yyy 
144     * is reader name (for example defaultfax) and zzz is parameter name (for 
145     * example priority). Result will be oss.receiver.defaultfax.priority
146     */
147    protected String   m_basePath;
148 
149    // Cached values ////////////////////////////////////////////////////////////
150 
151    /**
152     * Logger for this class
153     */
154    private static Logger   s_logger = Log.getInstance(SetupReader.class);
155 
156    /**
157     * Cached properties to access configuration settins. 
158     */
159    protected Properties   m_settings;
160 
161    /**
162     * Map with parameters values. Parameters values are readed only once and then 
163     * is used value from this map. Key is parameter name
164     */
165    protected Map   m_registeredParametersValues;
166 
167    // Constructors /////////////////////////////////////////////////////////////
168    
169    /**
170     * @param basePath   - Base path of reader
171     * @param readerName - name of reader
172     */
173    public SetupReader(
174       String   basePath,
175       String   readerName
176    )
177    {
178       super();
179       
180       m_basePath = basePath;
181       m_readerName = readerName;
182       // Here will be cached configuration values for current reader
183       m_registeredParametersValues = new HashMap  ();
184 
185       m_settings = Config.getInstance().getPropertiesSafely();
186 
187       if (getRegisteredParameterTypes().isEmpty())
188       {
189          // No parameters were registered yet so register the
190          registerParameters();
191       }
192    }
193    
194    // Accessors ////////////////////////////////////////////////////////////////
195    
196    /**
197     * Read parameter with specified name. The parameter name has to be registered
198     * using registerParameter. If such parameter is not registered it returns null.
199     * 
200     * @param parameterName - name of parameter
201     * @return - object with parameter value or null of parameter name is not 
202     *           registered. If you pass in correct parameter name, this method
203     *           guarantees to return not null value (in case of failure it will
204     *           return the hardcoded value you passed in).
205     */ 
206    public Object   getParameterValue(
207       String   parameterName
208    )
209    {
210       Object         retval = null;
211       Integer        parameterType = null;
212       Object         defaultValue = null;
213       StringBuffer   fullPropertyName = new StringBuffer  (m_basePath);
214       String         propertyValue;
215       
216       parameterType = (Integer  )getRegisteredParameterTypes().get(parameterName);
217       defaultValue = getRegisteredParametersDefaults().get(parameterName);
218       
219       if ((defaultValue != null) && (parameterType != null))
220       {
221          fullPropertyName.append(".");
222          fullPropertyName.append(m_readerName);
223          fullPropertyName.append(".");
224          fullPropertyName.append(parameterName);
225          
226          // try to get parameter value from cached values
227          retval = m_registeredParametersValues.get(parameterName);
228          if (retval == null)
229          {
230             // read value from file
231             propertyValue = m_settings.getProperty(fullPropertyName.toString(), 
232                                                    "");
233             s_logger.config(fullPropertyName.toString() + " = " 
234                                      + propertyValue);
235             if (propertyValue.length() == 0)
236             {
237                retval = defaultValue;
238             }
239             else
240             {
241                retval = parseValue(parameterType.intValue(), propertyValue);
242                if (retval != null)
243                {
244                   // remember value
245                   m_registeredParametersValues.put(parameterName, retval);
246                }
247                else
248                {
249                   retval = defaultValue;
250                }
251             }
252          }
253       }
254       
255       return retval;
256    }
257    
258    /**
259     * Get parameter value as string
260     * 
261     * @param parameterName - name of parameter
262     * @return String - value of parameter. It will be default value if 
263     *                  parameter was not found or null if parameter name is 
264     *                  not registered
265     */
266    public String   getStringParameterValue(
267       String   parameterName
268    )
269    {
270       return (String  )getParameterValue(parameterName);
271    }
272 
273    /**
274     * Get parameter value as Integer
275     * 
276     * @param parameterName - name of parameter
277     * @return Integer - value of parameter. It will be default value if 
278     *                  parameter was not found or null if parameter name is 
279     *                  not registered
280     */
281    public Integer   getIntegerParameterValue(
282       String   parameterName
283    )
284    {
285       return (Integer  )getParameterValue(parameterName);
286    }
287 
288    /**
289     * Get parameter value as Double
290     * 
291     * @param parameterName - name of parameter
292     * @return Double - value of parameter. It will be default value if 
293     *                  parameter was not found or null if parameter name is 
294     *                  not registered
295     */
296    public Double   getDoubleParameterValue(
297       String   parameterName
298    )
299    {
300       return (Double  )getParameterValue(parameterName);
301    }
302 
303    /**
304     * Get parameter value as Float
305     * 
306     * @param parameterName - name of parameter
307     * @return Float - value of parameter. It will be default value if 
308     *                  parameter was not found or null if parameter name is 
309     *                  not registered
310     */
311    public Float   getFloatParameterValue(
312       String   parameterName
313    )
314    {
315       return (Float  )getParameterValue(parameterName);
316    }   
317    
318    /**
319     * Get parameter value as Boolean
320     * 
321     * @param parameterName - name of parameter
322     * @return Boolean - value of parameter. It will be default value if 
323     *                  parameter was not found or null if parameter name is 
324     *                  not registered
325     */
326    public Boolean   getBooleanParameterValue(
327       String   parameterName
328    )
329    {
330       return (Boolean  )getParameterValue(parameterName);
331    }
332    
333    /**
334     * Get parameter value as Long
335     * 
336     * @param parameterName - name of parameter
337     * @return Long - value of parameter. It will be default value if 
338     *                  parameter was not found or null if parameter name is 
339     *                  not registered
340     */
341    public Long   getLongParameterValue(
342       String   parameterName
343    )
344    {
345       return (Long  )getParameterValue(parameterName);
346    }
347 
348 
349    // Helper methods ///////////////////////////////////////////////////////////
350 
351    /**
352     * Parse specified value according to its type.
353     * 
354     * @param iParameterType - parameter type, one of PARAMETER_TYPE_XXX constants
355     * @param propertyValue - value to parse
356     * @return Object - parsed object or null if it cannot be parsed
357     */
358    protected Object   parseValue(
359       int    iParameterType,
360       String   propertyValue
361    )
362    {
363       Object   retval = null;   
364    
365       switch (iParameterType)
366       {
367          case PARAMETER_TYPE_STRING :
368          {
369             retval = propertyValue;
370             break;
371          }
372          case PARAMETER_TYPE_INTEGER :
373          {
374             try
375             {
376                retval = new Integer  (propertyValue);
377             }
378             catch (NumberFormatException   exec)
379             {
380                s_logger.log(Level.WARNING, "property value is not integer");
381                retval = null;
382             }
383             break;
384          }
385          case PARAMETER_TYPE_DOUBLE :
386          {
387             try
388             {
389                retval = new Double  (propertyValue);
390             }
391             catch (NumberFormatException   exec)
392             {
393                s_logger.log(Level.WARNING, "property value is not double");
394                retval = null;
395             }
396             break;
397          }
398          case PARAMETER_TYPE_FLOAT :
399          {
400             try
401             {
402                retval = new Float  (propertyValue);
403             }
404             catch (NumberFormatException   exec)
405             {
406                s_logger.log(Level.WARNING, "property value is not float");
407                retval = null;
408             }
409             break;
410          }
411          case PARAMETER_TYPE_BOOLEAN :
412          {
413                if (propertyValue != null 
414                      && (propertyValue.equalsIgnoreCase("true")
415                          || propertyValue.equalsIgnoreCase("t")
416                          || propertyValue.equalsIgnoreCase("yes")
417                          || propertyValue.equalsIgnoreCase("y")
418                          || propertyValue.equalsIgnoreCase("1")))
419                {
420                   retval = Boolean.TRUE;
421                }
422                else if (propertyValue != null 
423                      && (propertyValue.equalsIgnoreCase("false")
424                            || propertyValue.equalsIgnoreCase("f")
425                            || propertyValue.equalsIgnoreCase("no")
426                            || propertyValue.equalsIgnoreCase("n")
427                            || propertyValue.equalsIgnoreCase("0"))
428                      )
429                {
430                   retval = Boolean.FALSE;
431                }
432                else
433                {
434                   s_logger.log(Level.WARNING, "property value is not boolean");
435                   retval = null;
436                }
437             break;
438          }
439          case PARAMETER_TYPE_LONG :
440          {
441             try
442             {
443                retval = new Long  (propertyValue);
444             }
445             catch (NumberFormatException   exec)
446             {
447                s_logger.log(Level.WARNING, "property value is not long");
448                retval = null;
449             }
450             break;
451          }
452          case PARAMETER_TYPE_PATH :
453          {
454             char cTemp;
455             
456             cTemp = propertyValue.trim().charAt(propertyValue.trim().length() - 1);
457             if ((cTemp != File.separatorChar)
458                 // On Windows it is allowed to end with / since java will shield it
459                 && (GlobalConstants.isWindows() && (cTemp != '/')))
460             {
461                s_logger.log(Level.WARNING,
462                      "Property value for path do not end with separator char");
463                retval = null;
464             }
465             else
466             {
467                retval = propertyValue;
468             }
469             break;
470          }
471          default:
472          {
473             assert false : "Unknown property value type";
474          }
475       }
476       
477       return retval;
478    }
479 
480    /**
481     * Register parameters which will be read from the property file with this
482     * reader. This method will try to read from the property file value common
483     * to all readers and if it doesn't find one it will use specified default value
484     * .
485     * 
486     * @param parameterName - parameter string name. This is just the part of the name
487     *                        which follows the base path and optionally reader name
488     * @param parameterType - parameter type - one of PARAMETER_TYPE_XXX constants
489     * @param defaultvalue  - parameter default value - as string, this should be
490     *                        always valid hardcoded string
491     */
492    protected void registerParameter(
493       String    parameterName,
494       Integer   parameterType,
495       String    defaultvalue
496    )
497    {
498       StringBuffer   fullPropertyName = new StringBuffer  (m_basePath);
499       Object         objHardcodedDefault;
500       Object         objDefault;
501 
502       objHardcodedDefault = parseValue(parameterType.intValue(), defaultvalue);
503       if (GlobalConstants.ERROR_CHECKING)
504       {
505          assert objHardcodedDefault != null 
506                 : "Hardcoded default value should be always parsable.";
507       }
508       
509       // Try to read what is the default value for this property (common value 
510       // for all readers without the reader name) and only if it is not there
511       // only the use passed default value
512       fullPropertyName.append(".");
513       fullPropertyName.append(parameterName);            
514       defaultvalue = m_settings.getProperty(fullPropertyName.toString(), 
515                                             defaultvalue);
516       objDefault = parseValue(parameterType.intValue(), defaultvalue);
517       if (objDefault == null)
518       {
519          objDefault = objHardcodedDefault;
520       }
521 
522       s_logger.config(fullPropertyName.toString() + " = " + defaultvalue);
523 
524       getRegisteredParameterTypes().put(parameterName, parameterType);
525       // Store there parsed value
526       getRegisteredParametersDefaults().put(parameterName, objDefault);
527    }
528 
529    /**
530     * Implementation can register all parameters in this function.
531     */
532    protected abstract void registerParameters();
533    
534    /**
535     * this function returns Map for parameter types. This map have to be static.
536     * key in map is parameter name and value is Integer type constant
537     * @return Map of parameter types
538     */
539    protected abstract Map   getRegisteredParameterTypes();
540 
541    /**
542     * this function returns Map for parameter defaults. This map have to be static.
543     * key in map is parameter name and value is String default value
544     * @return Map of default values
545     */
546    protected abstract Map   getRegisteredParametersDefaults();
547 }
548
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags