| /* |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to You under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| */ |
| |
| package org.apache.commons.cli; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.Date; |
| |
| /** |
| * This is a temporary implementation. TypeHandler will handle the pluggableness of OptionTypes and it will direct all |
| * of these types of conversion functionalities to ConvertUtils component in Commons already. BeanUtils I think. |
| */ |
| public class TypeHandler { |
| /** |
| * Returns the class whose name is {@code classname}. |
| * |
| * @param classname the class name |
| * @return The class if it is found |
| * @throws ParseException if the class could not be found |
| */ |
| public static Class<?> createClass(final String classname) throws ParseException { |
| try { |
| return Class.forName(classname); |
| } catch (final ClassNotFoundException e) { |
| throw new ParseException("Unable to find the class: " + classname); |
| } |
| } |
| |
| /** |
| * Returns the date represented by {@code str}. |
| * <p> |
| * This method is not yet implemented and always throws an {@link UnsupportedOperationException}. |
| * |
| * @param str the date string |
| * @return The date if {@code str} is a valid date string, otherwise return null. |
| * @throws UnsupportedOperationException always |
| */ |
| public static Date createDate(final String str) { |
| throw new UnsupportedOperationException("Not yet implemented"); |
| } |
| |
| /** |
| * Returns the File represented by {@code str}. |
| * |
| * @param str the File location |
| * @return The file represented by {@code str}. |
| */ |
| public static File createFile(final String str) { |
| return new File(str); |
| } |
| |
| /** |
| * Returns the File[] represented by {@code str}. |
| * <p> |
| * This method is not yet implemented and always throws an {@link UnsupportedOperationException}. |
| * |
| * @param str the paths to the files |
| * @return The File[] represented by {@code str}. |
| * @throws UnsupportedOperationException always |
| */ |
| public static File[] createFiles(final String str) { |
| // to implement/port: |
| // return FileW.findFiles(str); |
| throw new UnsupportedOperationException("Not yet implemented"); |
| } |
| |
| /** |
| * Create a number from a String. If a . is present, it creates a Double, otherwise a Long. |
| * |
| * @param str the value |
| * @return the number represented by {@code str} |
| * @throws ParseException if {@code str} is not a number |
| */ |
| public static Number createNumber(final String str) throws ParseException { |
| try { |
| if (str.indexOf('.') != -1) { |
| return Double.valueOf(str); |
| } |
| return Long.valueOf(str); |
| } catch (final NumberFormatException e) { |
| throw new ParseException(e.getMessage()); |
| } |
| } |
| |
| /** |
| * Create an Object from the classname and empty constructor. |
| * |
| * @param classname the argument value |
| * @return the initialized object |
| * @throws ParseException if the class could not be found or the object could not be created |
| */ |
| public static Object createObject(final String classname) throws ParseException { |
| final Class<?> cl; |
| |
| try { |
| cl = Class.forName(classname); |
| } catch (final ClassNotFoundException cnfe) { |
| throw new ParseException("Unable to find the class: " + classname); |
| } |
| |
| try { |
| return cl.newInstance(); |
| } catch (final Exception e) { |
| throw new ParseException(e.getClass().getName() + "; Unable to create an instance of: " + classname); |
| } |
| } |
| |
| /** |
| * Returns the URL represented by {@code str}. |
| * |
| * @param str the URL string |
| * @return The URL in {@code str} is well-formed |
| * @throws ParseException if the URL in {@code str} is not well-formed |
| */ |
| public static URL createURL(final String str) throws ParseException { |
| try { |
| return new URL(str); |
| } catch (final MalformedURLException e) { |
| throw new ParseException("Unable to parse the URL: " + str); |
| } |
| } |
| |
| /** |
| * Returns the {@code Object} of type {@code clazz} with the value of {@code str}. |
| * |
| * @param str the command line value |
| * @param clazz the class representing the type of argument |
| * @param <T> type of argument |
| * @return The instance of {@code clazz} initialized with the value of {@code str}. |
| * @throws ParseException if the value creation for the given class failed |
| */ |
| @SuppressWarnings("unchecked") // returned value will have type T because it is fixed by clazz |
| public static <T> T createValue(final String str, final Class<T> clazz) throws ParseException { |
| if (PatternOptionBuilder.STRING_VALUE == clazz) { |
| return (T) str; |
| } |
| if (PatternOptionBuilder.OBJECT_VALUE == clazz) { |
| return (T) createObject(str); |
| } |
| if (PatternOptionBuilder.NUMBER_VALUE == clazz) { |
| return (T) createNumber(str); |
| } |
| if (PatternOptionBuilder.DATE_VALUE == clazz) { |
| return (T) createDate(str); |
| } |
| if (PatternOptionBuilder.CLASS_VALUE == clazz) { |
| return (T) createClass(str); |
| } |
| if (PatternOptionBuilder.FILE_VALUE == clazz) { |
| return (T) createFile(str); |
| } |
| if (PatternOptionBuilder.EXISTING_FILE_VALUE == clazz) { |
| return (T) openFile(str); |
| } |
| if (PatternOptionBuilder.FILES_VALUE == clazz) { |
| return (T) createFiles(str); |
| } |
| if (PatternOptionBuilder.URL_VALUE == clazz) { |
| return (T) createURL(str); |
| } |
| throw new ParseException("Unable to handle the class: " + clazz); |
| } |
| |
| /** |
| * Returns the {@code Object} of type {@code obj} with the value of {@code str}. |
| * |
| * @param str the command line value |
| * @param obj the type of argument |
| * @return The instance of {@code obj} initialized with the value of {@code str}. |
| * @throws ParseException if the value creation for the given object type failed |
| */ |
| public static Object createValue(final String str, final Object obj) throws ParseException { |
| return createValue(str, (Class<?>) obj); |
| } |
| |
| /** |
| * Returns the opened FileInputStream represented by {@code str}. |
| * |
| * @param str the file location |
| * @return The file input stream represented by {@code str}. |
| * @throws ParseException if the file is not exist or not readable |
| */ |
| public static FileInputStream openFile(final String str) throws ParseException { |
| try { |
| return new FileInputStream(str); |
| } catch (final FileNotFoundException e) { |
| throw new ParseException("Unable to find file: " + str); |
| } |
| } |
| } |