Coverage report

  %line %branch
org.apache.jcs.config.OptionConverter
32% 
62% 

 1  
 package org.apache.jcs.config;
 2  
 
 3  
 /*
 4  
  * Licensed to the Apache Software Foundation (ASF) under one
 5  
  * or more contributor license agreements.  See the NOTICE file
 6  
  * distributed with this work for additional information
 7  
  * regarding copyright ownership.  The ASF licenses this file
 8  
  * to you under the Apache License, Version 2.0 (the
 9  
  * "License"); you may not use this file except in compliance
 10  
  * with the License.  You may obtain a copy of the License at
 11  
  *
 12  
  *   http://www.apache.org/licenses/LICENSE-2.0
 13  
  *
 14  
  * Unless required by applicable law or agreed to in writing,
 15  
  * software distributed under the License is distributed on an
 16  
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 17  
  * KIND, either express or implied.  See the License for the
 18  
  * specific language governing permissions and limitations
 19  
  * under the License.
 20  
  */
 21  
 
 22  
 import java.util.Properties;
 23  
 
 24  
 import org.apache.commons.logging.Log;
 25  
 import org.apache.commons.logging.LogFactory;
 26  
 
 27  
 /**
 28  
  * This class is based on the log4j class
 29  
  * org.apache.log4j.helpers.OptionConverter that was made by Ceki
 30  
  * Gülcü Simon Kitching; Avy Sharell (sharell@online.fr) Anders
 31  
  * Kristensen Matthieu Verbert (mve@zurich.ibm.com) A convenience class to
 32  
  * convert property values to specific types.
 33  
  *
 34  
  */
 35  6
 public class OptionConverter
 36  
 {
 37  396
     private final static Log log = LogFactory.getLog( OptionConverter.class );
 38  
 
 39  201
     static String DELIM_START = "${";
 40  
 
 41  201
     static char DELIM_STOP = '}';
 42  
 
 43  201
     static int DELIM_START_LEN = 2;
 44  
 
 45  201
     static int DELIM_STOP_LEN = 1;
 46  
 
 47  201
     static StringBuffer sbuf = new StringBuffer();
 48  
 
 49  
     /** No instances please. */
 50  
     private OptionConverter()
 51  
     {
 52  0
         super();
 53  0
     }
 54  
 
 55  
     /**
 56  
      * Combines two arrays.
 57  
      *
 58  
      * @param l
 59  
      * @param r
 60  
      * @return String[]
 61  
      */
 62  
     public static String[] concatanateArrays( String[] l, String[] r )
 63  
     {
 64  0
         int len = l.length + r.length;
 65  0
         String[] a = new String[len];
 66  
 
 67  0
         System.arraycopy( l, 0, a, 0, l.length );
 68  0
         System.arraycopy( r, 0, a, l.length, r.length );
 69  
 
 70  0
         return a;
 71  
     }
 72  
 
 73  
     /**
 74  
      * Escapes special cahracters/
 75  
      *
 76  
      * @param s
 77  
      * @return  String
 78  
      */
 79  
     public static String convertSpecialChars( String s )
 80  
     {
 81  
         char c;
 82  0
         int len = s.length();
 83  0
         StringBuffer sbuf = new StringBuffer( len );
 84  
 
 85  0
         int i = 0;
 86  0
         while ( i < len )
 87  
         {
 88  0
             c = s.charAt( i++ );
 89  0
             if ( c == '\\' )
 90  
             {
 91  0
                 c = s.charAt( i++ );
 92  0
                 if ( c == 'n' )
 93  
                 {
 94  0
                     c = '\n';
 95  0
                 }
 96  0
                 else if ( c == 'r' )
 97  
                 {
 98  0
                     c = '\r';
 99  0
                 }
 100  0
                 else if ( c == 't' )
 101  
                 {
 102  0
                     c = '\t';
 103  0
                 }
 104  0
                 else if ( c == 'f' )
 105  
                 {
 106  0
                     c = '\f';
 107  0
                 }
 108  0
                 else if ( c == '\b' )
 109  
                 {
 110  0
                     c = '\b';
 111  0
                 }
 112  0
                 else if ( c == '\"' )
 113  
                 {
 114  0
                     c = '\"';
 115  0
                 }
 116  0
                 else if ( c == '\'' )
 117  
                 {
 118  0
                     c = '\'';
 119  0
                 }
 120  0
                 else if ( c == '\\' )
 121  
                 {
 122  0
                     c = '\\';
 123  
                 }
 124  
             }
 125  0
             sbuf.append( c );
 126  0
         }
 127  0
         return sbuf.toString();
 128  
     }
 129  
 
 130  
     /**
 131  
      * Very similar to <code>System.getProperty</code> except that the {@link
 132  
      * SecurityException} is hidden.
 133  
      *
 134  
      * @param key
 135  
      *            The key to search for.
 136  
      * @param def
 137  
      *            The default value to return.
 138  
      * @return the string value of the system property, or the default value if
 139  
      *         there is no property with that key.
 140  
      * @since 1.1
 141  
      */
 142  
 
 143  
     public static String getSystemProperty( String key, String def )
 144  
     {
 145  
         try
 146  
         {
 147  47
             return System.getProperty( key, def );
 148  
         }
 149  0
         catch ( Throwable e )
 150  
         {
 151  
             // MS-Java throws com.ms.security.SecurityExceptionEx
 152  0
             log.debug( "Was not allowed to read system property \"" + key + "\"." );
 153  0
             return def;
 154  
         }
 155  
     }
 156  
 
 157  
     /**
 158  
      * Creates an object for the className value of the key.
 159  
      *
 160  
      * @param props
 161  
      * @param key
 162  
      * @param superClass
 163  
      * @param defaultValue
 164  
      * @return Object that was created
 165  
      */
 166  
     public static Object instantiateByKey( Properties props, String key, Class superClass, Object defaultValue )
 167  
     {
 168  
 
 169  
         // Get the value of the property in string form
 170  1831
         String className = findAndSubst( key, props );
 171  1831
         if ( className == null )
 172  
         {
 173  820
             if ( log.isTraceEnabled() )
 174  
             {
 175  0
                 log.info( "Could not find value for key " + key );
 176  
             }
 177  820
             return defaultValue;
 178  
         }
 179  
         // Trim className to avoid trailing spaces that cause problems.
 180  1011
         return OptionConverter.instantiateByClassName( className.trim(), superClass, defaultValue );
 181  
     }
 182  
 
 183  
     /**
 184  
      * If <code>value</code> is "true", then <code>true</code> is returned.
 185  
      * If <code>value</code> is "false", then <code>true</code> is returned.
 186  
      * Otherwise, <code>default</code> is returned.
 187  
      * <p>
 188  
      *
 189  
      * Case of value is unimportant.
 190  
      * @param value
 191  
      * @param dEfault
 192  
      * @return  Object
 193  
      */
 194  
 
 195  
     public static boolean toBoolean( String value, class="keyword">boolean dEfault )
 196  
     {
 197  0
         if ( value == null )
 198  
         {
 199  0
             return dEfault;
 200  
         }
 201  0
         String trimmedVal = value.trim();
 202  0
         if ( "true".equalsIgnoreCase( trimmedVal ) )
 203  
         {
 204  0
             return true;
 205  
         }
 206  0
         if ( "false".equalsIgnoreCase( trimmedVal ) )
 207  
         {
 208  0
             return false;
 209  
         }
 210  0
         return dEfault;
 211  
     }
 212  
 
 213  
     /** Description of the Method
 214  
      * @param value
 215  
      * @param dEfault
 216  
      * @return
 217  
      */
 218  
     public static int toInt( String value, class="keyword">int dEfault )
 219  
     {
 220  0
         if ( value != null )
 221  
         {
 222  0
             String s = value.trim();
 223  
             try
 224  
             {
 225  0
                 return Integer.valueOf( s ).intValue();
 226  
             }
 227  0
             catch ( NumberFormatException e )
 228  
             {
 229  0
                 log.error( "[" + s + "] is not in proper int form." );
 230  0
                 e.printStackTrace();
 231  
             }
 232  
         }
 233  0
         return dEfault;
 234  
     }
 235  
 
 236  
     /**
 237  
      * @param value
 238  
      * @param dEfault
 239  
      * @return
 240  
      */
 241  
     public static long toFileSize( String value, class="keyword">long dEfault )
 242  
     {
 243  0
         if ( value == null )
 244  
         {
 245  0
             return dEfault;
 246  
         }
 247  
 
 248  0
         String s = value.trim().toUpperCase();
 249  0
         long multiplier = 1;
 250  
         int index;
 251  
 
 252  0
         if ( ( index = s.indexOf( "KB" ) ) != -1 )
 253  
         {
 254  0
             multiplier = 1024;
 255  0
             s = s.substring( 0, index );
 256  0
         }
 257  0
         else if ( ( index = s.indexOf( "MB" ) ) != -1 )
 258  
         {
 259  0
             multiplier = 1024 * 1024;
 260  0
             s = s.substring( 0, index );
 261  0
         }
 262  0
         else if ( ( index = s.indexOf( "GB" ) ) != -1 )
 263  
         {
 264  0
             multiplier = 1024 * 1024 * 1024;
 265  0
             s = s.substring( 0, index );
 266  
         }
 267  0
         if ( s != null )
 268  
         {
 269  
             try
 270  
             {
 271  0
                 return Long.valueOf( s ).longValue() * multiplier;
 272  
             }
 273  0
             catch ( NumberFormatException e )
 274  
             {
 275  0
                 log.error( "[" + s + "] is not in proper int form" );
 276  0
                 log.error( "[" + value + "] not in expected format", e );
 277  
             }
 278  
         }
 279  0
         return dEfault;
 280  
     }
 281  
 
 282  
     /**
 283  
      * Find the value corresponding to <code>key</code> in <code>props</code>.
 284  
      * Then perform variable substitution on the found value.
 285  
      * @param key
 286  
      * @param props
 287  
      * @return
 288  
      */
 289  
 
 290  
     public static String findAndSubst( String key, Properties props )
 291  
     {
 292  5933
         String value = props.getProperty( key );
 293  5933
         if ( value == null )
 294  
         {
 295  820
             return null;
 296  
         }
 297  
 
 298  
         try
 299  
         {
 300  5113
             return substVars( value, props );
 301  
         }
 302  0
         catch ( IllegalArgumentException e )
 303  
         {
 304  0
             log.error( "Bad option value [" + value + "]", e );
 305  0
             return value;
 306  
         }
 307  
     }
 308  
 
 309  
     /**
 310  
      * Instantiate an object given a class name. Check that the
 311  
      * <code>className</code> is a subclass of <code>superClass</code>. If
 312  
      * that test fails or the object could not be instantiated, then
 313  
      * <code>defaultValue</code> is returned.
 314  
      *
 315  
      * @param className
 316  
      *            The fully qualified class name of the object to instantiate.
 317  
      * @param superClass
 318  
      *            The class to which the new object should belong.
 319  
      * @param defaultValue
 320  
      *            The object to return in case of non-fulfillment
 321  
      * @return
 322  
      */
 323  
 
 324  
     public static Object instantiateByClassName( String className, Class superClass, Object defaultValue )
 325  
     {
 326  1011
         if ( className != null )
 327  
         {
 328  
             try
 329  
             {
 330  1011
                 Class classObj = Class.forName( className );
 331  1011
                 if ( !superClass.isAssignableFrom( classObj ) )
 332  
                 {
 333  0
                     log.error( "A \"" + className + "\" object is not assignable to a \"" + superClass.getName()
 334  
                         + "\" variable." );
 335  0
                     return defaultValue;
 336  
                 }
 337  1011
                 return classObj.newInstance();
 338  
             }
 339  0
             catch ( Exception e )
 340  
             {
 341  0
                 log.error( "Could not instantiate class [" + className + "]", e );
 342  
             }
 343  
         }
 344  0
         return defaultValue;
 345  
     }
 346  
 
 347  
     /**
 348  
      * Perform variable substitution in string <code>val</code> from the
 349  
      * values of keys found in the system propeties.
 350  
      * <p>
 351  
      *
 352  
      * The variable substitution delimeters are <b>${ </b> and <b>} </b>.
 353  
      * <p>
 354  
      *
 355  
      * For example, if the System properties contains "key=value", then the call
 356  
      *
 357  
      * <pre>
 358  
      * String s = OptionConverter.substituteVars( &quot;Value of key is ${key}.&quot; );
 359  
      * </pre>
 360  
      *
 361  
      * will set the variable <code>s</code> to "Value of key is value.".
 362  
      * <p>
 363  
      *
 364  
      * If no value could be found for the specified key, then the
 365  
      * <code>props</code> parameter is searched, if the value could not be
 366  
      * found there, then substitution defaults to the empty string.
 367  
      * <p>
 368  
      *
 369  
      * For example, if system propeties contains no value for the key
 370  
      * "inexistentKey", then the call
 371  
      *
 372  
      * <pre>
 373  
      * String s = OptionConverter.subsVars( &quot;Value of inexistentKey is [${inexistentKey}]&quot; );
 374  
      * </pre>
 375  
      *
 376  
      * will set <code>s</code> to "Value of inexistentKey is []"
 377  
      * <p>
 378  
      *
 379  
      * An {@link java.lang.IllegalArgumentException}is thrown if
 380  
      * <code>val</code> contains a start delimeter "${" which is not balanced
 381  
      * by a stop delimeter "}".
 382  
      * </p>
 383  
      * <p>
 384  
      *
 385  
      * <b>Author </b> Avy Sharell </a>
 386  
      * </p>
 387  
      *
 388  
      * @param val
 389  
      *            The string on which variable substitution is performed.
 390  
      * @param props
 391  
      * @return String
 392  
      * @throws IllegalArgumentException
 393  
      *             if <code>val</code> is malformed.
 394  
      */
 395  
 
 396  
     public static String substVars( String val, Properties props )
 397  
         throws IllegalArgumentException
 398  
     {
 399  5113
         sbuf.setLength( 0 );
 400  
 
 401  5113
         int i = 0;
 402  
         int j;
 403  
         int k;
 404  
 
 405  
         while ( true )
 406  
         {
 407  5160
             j = val.indexOf( DELIM_START, i );
 408  5160
             if ( j == -1 )
 409  
             {
 410  5113
                 if ( i == 0 )
 411  
                 {
 412  5066
                     return val;
 413  
                 }
 414  47
                 sbuf.append( val.substring( i, val.length() ) );
 415  47
                 return sbuf.toString();
 416  
             }
 417  47
             sbuf.append( val.substring( i, j ) );
 418  47
             k = val.indexOf( DELIM_STOP, j );
 419  47
             if ( k == -1 )
 420  
             {
 421  0
                 throw new IllegalArgumentException( '"' + val + "\" has no closing brace. Opening brace at position "
 422  
                     + j + '.' );
 423  
             }
 424  47
             j += DELIM_START_LEN;
 425  47
             String key = val.substring( j, k );
 426  
             // first try in System properties
 427  47
             String replacement = getSystemProperty( key, null );
 428  
             // then try props parameter
 429  47
             if ( replacement == null && props != class="keyword">null )
 430  
             {
 431  16
                 replacement = props.getProperty( key );
 432  
             }
 433  
 
 434  47
             if ( replacement != null )
 435  
             {
 436  31
                 sbuf.append( replacement );
 437  
             }
 438  47
             i = k + DELIM_STOP_LEN;
 439  47
         }
 440  
     }
 441  
 
 442  
 }
 443  
 // end class

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.