Coverage report

  %line %branch
org.apache.commons.configuration.ConfigurationConverter
93% 
100% 

 1  
 /*
 2  
  * Copyright 2001-2004 The Apache Software Foundation.
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License")
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *     http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 
 17  
 package org.apache.commons.configuration;
 18  
 
 19  
 import java.util.Iterator;
 20  
 import java.util.List;
 21  
 import java.util.Map;
 22  
 import java.util.Properties;
 23  
 import java.util.Vector;
 24  
 
 25  
 import org.apache.commons.collections.ExtendedProperties;
 26  
 
 27  
 /**
 28  
  * Configuration converter. Helper class to convert between Configuration,
 29  
  * ExtendedProperties and standard Properties.
 30  
  *
 31  
  * @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a>
 32  
  * @version $Revision: 155408 $, $Date: 2005-02-26 13:56:39 +0100 (Sa, 26 Feb 2005) $
 33  
  */
 34  
 public final class ConfigurationConverter
 35  
 {
 36  
     private ConfigurationConverter()
 37  0
     {
 38  
         // to prevent instanciation...
 39  0
     }
 40  
 
 41  
     /**
 42  
      * Convert a ExtendedProperties class into a Configuration class.
 43  
      *
 44  
      * @param eprops ExtendedProperties object to convert
 45  
      * @return Configuration created from the ExtendedProperties
 46  
      */
 47  
     public static Configuration getConfiguration(ExtendedProperties eprops)
 48  
     {
 49  23
         return new MapConfiguration(eprops);
 50  
     }
 51  
 
 52  
     /**
 53  
      * Convert a standard Properties class into a configuration class.
 54  
      *
 55  
      * @param props properties object to convert
 56  
      * @return Configuration configuration created from the Properties
 57  
      */
 58  
     public static Configuration getConfiguration(Properties props)
 59  
     {
 60  69
         return new MapConfiguration(props);
 61  
     }
 62  
 
 63  
     /**
 64  
      * Convert a Configuration class into a ExtendedProperties class.
 65  
      *
 66  
      * @param config Configuration object to convert
 67  
      * @return ExtendedProperties created from the Configuration
 68  
      */
 69  
     public static ExtendedProperties getExtendedProperties(Configuration config)
 70  
     {
 71  23
         ExtendedProperties props = new ExtendedProperties();
 72  
 
 73  23
         Iterator keys = config.getKeys();
 74  
 
 75  92
         while (keys.hasNext())
 76  
         {
 77  69
             String key = (String) keys.next();
 78  69
             Object property = config.getProperty(key);
 79  
 
 80  
             // turn lists into vectors
 81  69
             if (property instanceof List)
 82  
             {
 83  23
                 property = new Vector((List) property);
 84  
             }
 85  
 
 86  69
             props.setProperty(key, property);
 87  
         }
 88  
 
 89  23
         return props;
 90  
     }
 91  
 
 92  
     /**
 93  
      * Convert a Configuration class into a Properties class. Multivalue keys
 94  
      * will be collapsed into comma separated values.
 95  
      *
 96  
      * @param config Configuration object to convert
 97  
      * @return Properties created from the Configuration
 98  
      */
 99  
     public static Properties getProperties(Configuration config)
 100  
     {
 101  23
         Properties props = new Properties();
 102  
 
 103  23
         Iterator keys = config.getKeys();
 104  
 
 105  69
         while (keys.hasNext())
 106  
         {
 107  46
             String key = (String) keys.next();
 108  46
             List list = config.getList(key);
 109  
 
 110  
             // turn lists into a string
 111  46
             StringBuffer property = new StringBuffer();
 112  46
             Iterator it = list.iterator();
 113  115
             while (it.hasNext())
 114  
             {
 115  69
                 property.append(String.valueOf(it.next()));
 116  69
                 if (it.hasNext())
 117  
                 {
 118  23
                     property.append(", ");
 119  
                 }
 120  
             }
 121  
 
 122  46
             props.setProperty(key, property.toString());
 123  
         }
 124  
 
 125  23
         return props;
 126  
     }
 127  
 
 128  
     /**
 129  
      * Convert a Configuration class into a Map class.
 130  
      *
 131  
      * @param config Configuration object to convert
 132  
      * @return Map created from the Configuration
 133  
      */
 134  
     public static Map getMap(Configuration config)
 135  
     {
 136  23
         return new ConfigurationMap(config);
 137  
     }
 138  
 
 139  
 }

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