001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018 package org.apache.commons.cli; 019 020 import java.io.File; 021 022 import java.net.MalformedURLException; 023 import java.net.URL; 024 025 import java.util.Date; 026 027 /** 028 * This is a temporary implementation. TypeHandler will handle the 029 * pluggableness of OptionTypes and it will direct all of these types 030 * of conversion functionalities to ConvertUtils component in Commons 031 * already. BeanUtils I think. 032 * 033 * @version $Revision: 741425 $, $Date: 2009-02-05 22:10:54 -0800 (Thu, 05 Feb 2009) $ 034 */ 035 public class TypeHandler 036 { 037 /** 038 * Returns the <code>Object</code> of type <code>obj</code> 039 * with the value of <code>str</code>. 040 * 041 * @param str the command line value 042 * @param obj the type of argument 043 * @return The instance of <code>obj</code> initialised with 044 * the value of <code>str</code>. 045 */ 046 public static Object createValue(String str, Object obj) 047 throws ParseException 048 { 049 return createValue(str, (Class) obj); 050 } 051 052 /** 053 * Returns the <code>Object</code> of type <code>clazz</code> 054 * with the value of <code>str</code>. 055 * 056 * @param str the command line value 057 * @param clazz the type of argument 058 * @return The instance of <code>clazz</code> initialised with 059 * the value of <code>str</code>. 060 */ 061 public static Object createValue(String str, Class clazz) 062 throws ParseException 063 { 064 if (PatternOptionBuilder.STRING_VALUE == clazz) 065 { 066 return str; 067 } 068 else if (PatternOptionBuilder.OBJECT_VALUE == clazz) 069 { 070 return createObject(str); 071 } 072 else if (PatternOptionBuilder.NUMBER_VALUE == clazz) 073 { 074 return createNumber(str); 075 } 076 else if (PatternOptionBuilder.DATE_VALUE == clazz) 077 { 078 return createDate(str); 079 } 080 else if (PatternOptionBuilder.CLASS_VALUE == clazz) 081 { 082 return createClass(str); 083 } 084 else if (PatternOptionBuilder.FILE_VALUE == clazz) 085 { 086 return createFile(str); 087 } 088 else if (PatternOptionBuilder.EXISTING_FILE_VALUE == clazz) 089 { 090 return createFile(str); 091 } 092 else if (PatternOptionBuilder.FILES_VALUE == clazz) 093 { 094 return createFiles(str); 095 } 096 else if (PatternOptionBuilder.URL_VALUE == clazz) 097 { 098 return createURL(str); 099 } 100 else 101 { 102 return null; 103 } 104 } 105 106 /** 107 * Create an Object from the classname and empty constructor. 108 * 109 * @param classname the argument value 110 * @return the initialised object, or null if it couldn't create 111 * the Object. 112 */ 113 public static Object createObject(String classname) 114 throws ParseException 115 { 116 Class cl = null; 117 118 try 119 { 120 cl = Class.forName(classname); 121 } 122 catch (ClassNotFoundException cnfe) 123 { 124 throw new ParseException("Unable to find the class: " + classname); 125 } 126 127 Object instance = null; 128 129 try 130 { 131 instance = cl.newInstance(); 132 } 133 catch (Exception e) 134 { 135 throw new ParseException(e.getClass().getName() + "; Unable to create an instance of: " + classname); 136 } 137 138 return instance; 139 } 140 141 /** 142 * Create a number from a String. If a . is present, it creates a 143 * Double, otherwise a Long. 144 * 145 * @param str the value 146 * @return the number represented by <code>str</code>, if <code>str</code> 147 * is not a number, null is returned. 148 */ 149 public static Number createNumber(String str) 150 throws ParseException 151 { 152 try 153 { 154 if (str.indexOf('.') != -1) 155 { 156 return Double.valueOf(str); 157 } 158 else 159 { 160 return Long.valueOf(str); 161 } 162 } 163 catch (NumberFormatException e) 164 { 165 throw new ParseException(e.getMessage()); 166 } 167 } 168 169 /** 170 * Returns the class whose name is <code>classname</code>. 171 * 172 * @param classname the class name 173 * @return The class if it is found, otherwise return null 174 */ 175 public static Class createClass(String classname) 176 throws ParseException 177 { 178 try 179 { 180 return Class.forName(classname); 181 } 182 catch (ClassNotFoundException e) 183 { 184 throw new ParseException("Unable to find the class: " + classname); 185 } 186 } 187 188 /** 189 * Returns the date represented by <code>str</code>. 190 * 191 * @param str the date string 192 * @return The date if <code>str</code> is a valid date string, 193 * otherwise return null. 194 */ 195 public static Date createDate(String str) 196 throws ParseException 197 { 198 throw new UnsupportedOperationException("Not yet implemented"); 199 } 200 201 /** 202 * Returns the URL represented by <code>str</code>. 203 * 204 * @param str the URL string 205 * @return The URL is <code>str</code> is well-formed, otherwise 206 * return null. 207 */ 208 public static URL createURL(String str) 209 throws ParseException 210 { 211 try 212 { 213 return new URL(str); 214 } 215 catch (MalformedURLException e) 216 { 217 throw new ParseException("Unable to parse the URL: " + str); 218 } 219 } 220 221 /** 222 * Returns the File represented by <code>str</code>. 223 * 224 * @param str the File location 225 * @return The file represented by <code>str</code>. 226 */ 227 public static File createFile(String str) 228 throws ParseException 229 { 230 return new File(str); 231 } 232 233 /** 234 * Returns the File[] represented by <code>str</code>. 235 * 236 * @param str the paths to the files 237 * @return The File[] represented by <code>str</code>. 238 */ 239 public static File[] createFiles(String str) 240 throws ParseException 241 { 242 // to implement/port: 243 // return FileW.findFiles(str); 244 throw new UnsupportedOperationException("Not yet implemented"); 245 } 246 }