All Downloads are FREE. Search and download functionalities are using the official Maven repository.

uno.informatics.common.ConversionUtilities Maven / Gradle / Ivy

Go to download

There is a newer version: 1.5.0
Show newest version
/*******************************************************************************
 * Copyright 2016 Guy Davenport
 *
 * Licensed 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 uno.informatics.common;

import static uno.informatics.data.DataType.BIG_DECIMAL;
import static uno.informatics.data.DataType.BIG_INTEGER;
import static uno.informatics.data.DataType.BOOLEAN;
import static uno.informatics.data.DataType.DATE;
import static uno.informatics.data.DataType.DOUBLE;
import static uno.informatics.data.DataType.FLOAT;
import static uno.informatics.data.DataType.INTEGER;
import static uno.informatics.data.DataType.LONG;
import static uno.informatics.data.DataType.SHORT;
import static uno.informatics.data.DataType.STRING;
import static uno.informatics.data.DataTypeConstants.BIG_DECIMAL_ID;
import static uno.informatics.data.DataTypeConstants.BIG_INTEGER_ID;
import static uno.informatics.data.DataTypeConstants.BOOLEAN_ID;
import static uno.informatics.data.DataTypeConstants.DATE_ID;
import static uno.informatics.data.DataTypeConstants.DEFAULT_TYPE_IDS;
import static uno.informatics.data.DataTypeConstants.DOUBLE_ID;
import static uno.informatics.data.DataTypeConstants.FLOAT_ID;
import static uno.informatics.data.DataTypeConstants.INT_ID;
import static uno.informatics.data.DataTypeConstants.LONG_ID;
import static uno.informatics.data.DataTypeConstants.SHORT_ID;
import static uno.informatics.data.DataTypeConstants.STRING_ID;
import static uno.informatics.data.DataTypeConstants.UNKNOWN_ID;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class ConversionUtilities
{
	private static final String TRUE = "true";
	private static final String FALSE = "false";
	
	private static final DateFormat DATE_FORMAT = new SimpleDateFormat("yyyyMMddHHmmssZ");
	
  @SuppressWarnings("unused")
  private static String DEFAULT_DELIMITER    = "&" ;

  public static final String convertToString(String value)
  {
    return value;
  }

  /**
   * Converts a string to an object to an integer, double, boolean or string. Will try to convert in following order
   * Integer, Double and Boolean, or return the original String
   * 
   * @param string the string to be converted
   * @return a object representation of the string
   */
  public static final Object convertToObject(String string)
  {
    try
    {
      return convertToObject(string, DEFAULT_TYPE_IDS);
    }
    catch (ConversionException e)
    {
      return string ;
    }
  }

  /**
   * Converts a string to an object given a set of possible types to convert to. Will try to convert in following order
   * Short, Integer, Long, Float, Double, BigInteger, BigDecmal and Boolean, Date and String. An exception is throw if
   * the string can not be converted to one of the possible types.
   * 
   * @param string the string to be converted
   * @param types possible types to which to convert
   * @return a object representation of the string
   * @throws ConversionException if the string can not be converted to one of the possible types
   */
  public static final Object convertToObject(String string, int types) throws ConversionException
  {
    Object value = null ;
    
    if (string != null)
    {      
      if (value == null && (types & SHORT_ID) != 0)
        value = convertToShortInternal(string) ;
      
      if (value == null && (types & INT_ID) != 0)
        value = convertToIntegerInternal(string) ;
      
      if (value == null && (types & LONG_ID) != 0)
        value = convertToLongInternal(string) ;
      
      if (value == null && (types & FLOAT_ID) != 0)
        value = convertToFloatInternal(string) ;
      
      if (value == null && (types & DOUBLE_ID) != 0)
        value = convertToDoubleInternal(string) ;
      
      if (value == null && (types & BIG_INTEGER_ID) != 0)
        value = convertToBigIntegerInternal(string) ;

      if (value == null && (types & BIG_DECIMAL_ID) != 0)
        value = convertToBigDecimalInternal(string) ;
      
      if (value == null && (types & BOOLEAN_ID) != 0)
        value = convertToBooleanInternal(string) ;
      
      if (value == null && (types & DATE_ID) != 0)
        value = convertToDateInternal(string) ;
      
      if (value == null && (types & STRING_ID) != 0)
        value = string ;
      
      if (value == null)
        throw new ConversionException("Can not convert to Object using requested types " + getTypesNames(types) + "!") ;
    }
    
    return value;
  }
  
  public static List getTypesNames(int types)
  {
    List labels = new LinkedList() ;
         
    if ((types & SHORT_ID) != 0)
      labels.add(SHORT.getName()) ;

    if ((types & INT_ID) != 0)
      labels.add(INTEGER.getName()) ;
    
    if ((types & SHORT_ID) != 0)
      labels.add(SHORT.getName()) ;

    if ((types & LONG_ID) != 0)
      labels.add(LONG.getName()) ;  
    
    if ((types & FLOAT_ID) != 0)
      labels.add(FLOAT.getName()) ;

    if ((types & DOUBLE_ID) != 0)
      labels.add(DOUBLE.getName()) ;
    
    if ((types & BIG_INTEGER_ID) != 0)
      labels.add(BIG_INTEGER.getName()) ;

    if ((types & BIG_DECIMAL_ID) != 0)
      labels.add(BIG_DECIMAL.getName()) ; 
    
    if ((types & BOOLEAN_ID) != 0)
      labels.add(BOOLEAN.getName()) ;
    
    if ((types & DATE_ID) != 0)
      labels.add(DATE.getName()) ;

    if ((types & STRING_ID) != 0)
      labels.add(STRING.getName()) ; 
    
    return labels ;
  }

  /**
   * Converts a string to an number given a set of possible types to convert to. Will try to convert in following order
   * Short, Integer, Long, Float, Double, BigInteger, BigDecmal
   * 
   * @param string the string to be converted
   * @param types types to convert
   * @return a object representation of the string
   * @throws ConversionException if conversion to all given types fails
   */
  public static final Number convertToNumber(String string, int types) throws ConversionException
  {
    Object value = null ;
    
    if (string != null)
    {      
      if (value == null && (types & SHORT_ID) != 0)
        value = convertToShortInternal(string) ;
      
      if (value == null && (types & INT_ID) != 0)
        value = convertToIntegerInternal(string) ;
      
      if (value == null && (types & LONG_ID) != 0)
        value = convertToLongInternal(string) ;
      
      if (value == null && (types & FLOAT_ID) != 0)
        value = convertToFloatInternal(string) ;
      
      if (value == null && (types & DOUBLE_ID) != 0)
        value = convertToDoubleInternal(string) ;
      
      if (value == null && (types & BIG_INTEGER_ID) != 0)
        value = convertToBigIntegerInternal(string) ;

      if (value == null && (types & BIG_DECIMAL_ID) != 0)
        value = convertToBigDecimalInternal(string) ;
      
      if (value == null)
        throw new ConversionException("Can not convert to Number using requested types " + getTypesNames(types) + "!") ;
    }
    
    return (Number)value;
  }


  public static final BigDecimal convertToBigDecimal(String string) throws ConversionException
  {
    BigDecimal value = null ;
    
    if (string != null)
    {
      try
      {
        value = new BigDecimal(string) ;
      }
      catch (NumberFormatException e)
      {
        throw new ConversionException(e.getMessage(), e);
      }
    }
    
    return value ;
  }
  
  public static final BigInteger convertToBigInteger(String string) throws ConversionException
  {
    BigInteger value = null ;
    
    if (string != null)
    {
      try
      {
        value = new BigInteger(string) ;
      }
      catch (NumberFormatException e)
      {
        throw new ConversionException(e.getMessage(), e);
      }
    }
    
    return value ;
  }
  
  public static final Double convertToDouble(String string) throws ConversionException
  {
    Double value = null ;
    
    if (string != null)
    {
      try
      {
        value = Double.valueOf(string);
      }
      catch (NumberFormatException e)
      {
        throw new ConversionException(e.getMessage(), e);
      }
    }
    
    return value ;
  }

  public static final Float convertToFloat(String string) throws ConversionException
  {
    Float value = null ;
    
    if (string != null)
    {
      try
      {
        value = Float.valueOf(string);
      }
      catch (NumberFormatException e)
      {
        throw new ConversionException(e.getMessage(), e);
      }
    }
    
    return value ;
  }
  
  public static final Long convertToLong(String string) throws ConversionException
  {
    Long value = null ;
    
    if (string != null)
    {
      try
      {
        value = Long.valueOf(string);
      }
      catch (NumberFormatException e)
      {
        throw new ConversionException(e.getMessage(), e);
      }
    }
    
    return value ;
  }
  public static final Integer convertToInteger(String string) throws ConversionException
  {
    Integer value = null ;
    
    if (string != null)
    {
      try
      {
        value = Integer.valueOf(string);
      }
      catch (NumberFormatException e)
      {
        throw new ConversionException(e.getMessage(), e);
      }
    }
    
    return value ;
  }
  
  public static final Short convertToShort(String string) throws ConversionException
  {
    Short value = null ;
    
    if (string != null)
    {
      try
      {
        value = Short.valueOf(string);
      }
      catch (NumberFormatException e)
      {
        throw new ConversionException(e.getMessage(), e);
      }
    }
    
    return value ;
  }
  
  public static final Boolean convertToBoolean(String string) throws ConversionException
  {
  	Boolean value = null ;
    
    if (string != null)
    {
    	if (TRUE.equals(string.toLowerCase()))
    	{
    		return true ;
    	}
    	else
      {
      	if (FALSE.equals(string.toLowerCase()))
      	{
      		return false ;
      	}
      }
    }
    
    return value ;
  }
  
  @SuppressWarnings("deprecation")
  public static final Date convertToDate(String value) throws ConversionException
  {
    if (value != null)
    {
	    try
      {
	      return DATE_FORMAT.parse(value) ;
      }
      catch (Exception e)
      {
  	    try
        {
  	      return new Date(value) ;
        }
        catch (Exception e2)
        {
  	      throw new ConversionException(e2) ;
        }
      }
    }
    else
    {
      return null ;
    }
  }

  public static final String convertToString(Object value)
  {
    if (value != null)
    	if (value instanceof Date)
    		return DATE_FORMAT.format((Date)value) ;
    	else
    		return value.toString() ;
    else
      return null ;
  }

  public static final Double convertToDouble(Object value) throws ConversionException
  {
    if (value != null)
    {
      if (value instanceof Double)
      {
        return (Double)value ;
      }
      else
      {
        if (value instanceof Number)
        {
          return ((Number)value).doubleValue() ;
        }
        else
        {
          if (value instanceof String)
          {
            return convertToDouble((String)value) ;
          }
          else
          {
            throw new ConversionException("Can not convert value to double : " + value) ;
          }
        }
      }
    }
    else
    {
      return null ;
    }  
  }
  
  public static final Integer convertToInteger(Object value) throws ConversionException
  {
    if (value != null)
    {
      if (value instanceof Integer)
      {
        return (Integer)value ;
      }
      else
      {
        if (value instanceof Number)
        {
          return ((Number)value).intValue() ;
        }
        else
        {
          if (value instanceof String)
          {
            return convertToInteger((String)value) ;
          }
          else
          {
            throw new ConversionException("Can not convert value to integer : " + value) ;
          }
        }
      }
    }
    else
    {
      return null ;
    }  
  }
  
  public static List convertToShortList(List values) throws ConversionException
  {
  	List list = new ArrayList() ;

  	Iterator iterator = values.iterator() ;
  	
  	while(iterator.hasNext())
  	{
  		list.add(convertToShort(iterator.next())) ;
  	}
  	
	  return list;
  }
  
  public static List convertToIntegerList(List values) throws ConversionException
  {
  	List list = new ArrayList() ;

  	Iterator iterator = values.iterator() ;
  	
  	while(iterator.hasNext())
  	{
  		list.add(convertToInteger(iterator.next())) ;
  	}
  	
	  return list;
  }
  
  public static List convertToLongList(List values) throws ConversionException
  {
  	List list = new ArrayList() ;

  	Iterator iterator = values.iterator() ;
  	
  	while(iterator.hasNext())
  	{
  		list.add(convertToLong(iterator.next())) ;
  	}
  	
	  return list;
  }
  
  public static List convertToFloatList(List values) throws ConversionException
  {
  	List list = new ArrayList() ;

  	Iterator iterator = values.iterator() ;
  	
  	while(iterator.hasNext())
  	{
  		list.add(convertToFloat(iterator.next())) ;
  	}
  	
	  return list;
  }
  
  public static List convertToDoubleList(List values) throws ConversionException
  {
  	List list = new ArrayList() ;

  	Iterator iterator = values.iterator() ;
  	
  	while(iterator.hasNext())
  	{
  		list.add(convertToDouble(iterator.next())) ;
  	}
  	
	  return list;
  }
  
  public static List convertToObjectList(List values, int type) throws ConversionException
  {
  	List list = new ArrayList() ;

  	Iterator iterator = values.iterator() ;
  	
  	while(iterator.hasNext())
  	{
  		list.add(convertToObject(iterator.next(), type)) ;
  	}
  	
	  return list;
  }
  
  public static List convertToObjectList(List values, int[] types) throws ConversionException
  {
  	List list = new ArrayList() ;

  	Iterator iterator = values.iterator() ;
  	
  	int i = 0 ;
  	
  	while(iterator.hasNext())
  	{
  		if (i < types.length)
  			list.add(convertToObject(iterator.next(), types[i])) ;
  		else
  			list.add(convertToObject(iterator.next())) ;
  		
  		++i ;
  	}
  	
	  return list;
  }
  
  public static final int getDataType(String string)
  {
    int datatype = UNKNOWN_ID ;
    
    if (string != null)
    {   
    	datatype = STRING_ID ;
    	
      if (convertToShortInternal(string) != null)
      	datatype = datatype | SHORT_ID ;
      
      if (convertToIntegerInternal(string)!= null)
      	datatype = datatype | INT_ID ;
      
      if (convertToLongInternal(string)!= null)
      	datatype = datatype | LONG_ID ;
      
      if (convertToFloatInternal(string) != null)
      	datatype = datatype | FLOAT_ID ;
      
      if (convertToDoubleInternal(string) != null)
      	datatype = datatype | DOUBLE_ID ;
      
      if (convertToBigIntegerInternal(string) != null)
      	datatype = datatype | BIG_INTEGER_ID ;

      if (convertToBigDecimalInternal(string) != null)
      	datatype = datatype | BIG_DECIMAL_ID ;
      
      if (convertToBooleanInternal(string) != null)
      	datatype = datatype | BOOLEAN_ID ;
      
      if (convertToDateInternal(string) != null)
      	datatype = datatype | DATE_ID ;
    }
    
    return datatype ;
  }
  
  public static final List getDataTypes(List strings)
  {
  	List datatypes ;

    if (strings != null)
    {      
    	datatypes = new ArrayList(strings.size()) ;
    	
    	Iterator iterator = strings.iterator() ;
    	
      while(iterator.hasNext())
      	datatypes.add(getDataType(iterator.next())) ;
    }
    else
    {
    	datatypes = new ArrayList() ;
    }
    
    return datatypes ;
  }
  
  public static final int[] getDataTypes(String[] strings)
  {
  	int[] datatypes ;

    if (strings != null)
    {      
    	datatypes = new int[strings.length];
    	  	
      for(int i = 0 ; i < strings.length ; ++i)
      	datatypes[i] = getDataType(strings[i]) ;
    }
    else
    {
    	datatypes = new int[0];
    }
    
    return datatypes ;
  }
  
  public static final List getDataTypes(List strings, List currentDatatypes)
  {
  	List datatypes ;

    if (strings != null && currentDatatypes != null && strings.size() == currentDatatypes.size())
    {      
    	datatypes = new ArrayList(strings.size()) ;
    	
    	Iterator iterator = strings.iterator() ;
    	Iterator iterator2 = currentDatatypes.iterator() ;
    	
      while(iterator.hasNext() && iterator2.hasNext())
      	datatypes.add(iterator2.next() & getDataType(iterator.next())) ;
    }
    else
    {
    	datatypes = new ArrayList(currentDatatypes) ;
    }
    
    return datatypes ;
  }
  
  public static final int[] getDataTypes(String[] strings, int[] currentDatatypes)
  {
  	int[] datatypes ;

    if (strings != null && currentDatatypes != null && strings.length == currentDatatypes.length)
    {      
    	datatypes = new int[strings.length];
    	  	
      for(int i = 0 ; i < strings.length ; ++i)
      	datatypes[i] = currentDatatypes[i] & getDataType(strings[i]) ;
    }
    else
    {
    	datatypes = currentDatatypes ;
    }

    return datatypes ;
  }

  private static final BigDecimal convertToBigDecimalInternal(String string)
  {
    try
    {
      return convertToBigDecimal(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }

  private static final BigInteger convertToBigIntegerInternal(String string)
  {
    try
    {
      return convertToBigInteger(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }

  private static final Double convertToDoubleInternal(String string)
  {
    try
    {
      return convertToDouble(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }

  private static final Float convertToFloatInternal(String string)
  {
    try
    {
      return convertToFloat(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }

  private static final Long convertToLongInternal(String string)
  {
    try
    {
      return convertToLong(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }

  private static final Integer convertToIntegerInternal(String string)
  {
    try
    {
      return convertToInteger(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }

  private static final Short convertToShortInternal(String string)
  {
    try
    {
      return convertToShort(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }
  
  private static final Boolean convertToBooleanInternal(String string)
  {
    try
    {
      return convertToBoolean(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }
  
  private static final Date convertToDateInternal(String string)
  {
    try
    {
      return convertToDate(string);
    }
    catch (ConversionException e)
    {
      return null ;
    }
  }
}
 















© 2015 - 2024 Weber Informatics LLC | Privacy Policy