452 lines
15 KiB
Java
452 lines
15 KiB
Java
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* 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 .
|
|
*/
|
|
package com.sun.star.wizards.common;
|
|
|
|
import com.sun.star.uno.AnyConverter;
|
|
import com.sun.star.uno.TypeClass;
|
|
|
|
/**
|
|
* A class for helping with all kinds of numerical conversions.
|
|
* Optional or named parameters in SO are of the Object type in Java.
|
|
* These objects must be converted to the right simple value type.
|
|
* Unfortunately, StarBasic does not know the original desired type,
|
|
* and a value that should be a "Float" is delivered as "Byte". This class
|
|
* handles the conversions of these types.<br>
|
|
* This class does not log warnings (or throws Exceptions) when the precision
|
|
* of a value is lost.
|
|
*/
|
|
public class NumericalHelper
|
|
{
|
|
|
|
private static final int UNKNOWN_TYPE = -32768;
|
|
private static final int BYTE_TYPE = 0;
|
|
private static final int SHORT_TYPE = 1;
|
|
private static final int INT_TYPE = 2;
|
|
private static final int LONG_TYPE = 3;
|
|
private static final int FLOAT_TYPE = 4;
|
|
private static final int DOUBLE_TYPE = 5;
|
|
private static final int CHAR_TYPE = 6;
|
|
private static final int STRING_TYPE = -1;
|
|
private static final int BOOLEAN_TYPE = -2;
|
|
private static final int SEQUENCE_TYPE = -3;
|
|
|
|
|
|
|
|
private static final int HEX_BASE = 16;
|
|
private static final int DEC_BASE = 10;
|
|
private static final int ASCII_LETTER_A_OFFSET = 55;
|
|
|
|
/**
|
|
* private c'tor to prevent instantiation
|
|
*/
|
|
private NumericalHelper()
|
|
{
|
|
// private c'tor, so no one can instantiate
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* get an int value from the object
|
|
* @return an int
|
|
* @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
|
|
*/
|
|
public static int toInt(Object aValue)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
int retValue = 0;
|
|
TypeObject aTypeObject = getTypeObject(aValue);
|
|
switch (aTypeObject.iType)
|
|
{
|
|
case BYTE_TYPE:
|
|
retValue = getByte(aTypeObject);
|
|
break;
|
|
case CHAR_TYPE:
|
|
retValue = getChar(aTypeObject);
|
|
break;
|
|
case SHORT_TYPE:
|
|
retValue = getShort(aTypeObject);
|
|
break;
|
|
case INT_TYPE:
|
|
retValue = getInt(aTypeObject);
|
|
break;
|
|
case LONG_TYPE:
|
|
retValue = (int) getLong(aTypeObject);
|
|
break;
|
|
case FLOAT_TYPE:
|
|
retValue = (int) getFloat(aTypeObject);
|
|
break;
|
|
case DOUBLE_TYPE:
|
|
retValue = (int) getDouble(aTypeObject);
|
|
break;
|
|
case STRING_TYPE:
|
|
try
|
|
{
|
|
Integer i = Integer.valueOf((String) aTypeObject.aValue);
|
|
retValue = i.intValue();
|
|
}
|
|
catch (java.lang.NumberFormatException e)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Cannot convert to int: " + aTypeObject.aValue);
|
|
}
|
|
break;
|
|
case BOOLEAN_TYPE:
|
|
retValue = getBool(aTypeObject) ? -1 : 0;
|
|
break;
|
|
default:
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Cannot convert this type: " + aValue.getClass().getName());
|
|
}
|
|
return retValue;
|
|
}
|
|
|
|
/**
|
|
* get a double value from the object
|
|
* @return a double
|
|
* @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
|
|
*/
|
|
public static double toDouble(Object aValue)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
double retValue = 0.0;
|
|
TypeObject aTypeObject = getTypeObject(aValue);
|
|
switch (aTypeObject.iType)
|
|
{
|
|
case BYTE_TYPE:
|
|
retValue = getByte(aTypeObject);
|
|
break;
|
|
case CHAR_TYPE:
|
|
retValue = getChar(aTypeObject);
|
|
break;
|
|
case SHORT_TYPE:
|
|
retValue = getShort(aTypeObject);
|
|
break;
|
|
case INT_TYPE:
|
|
retValue = getInt(aTypeObject);
|
|
break;
|
|
case LONG_TYPE:
|
|
retValue = getLong(aTypeObject);
|
|
break;
|
|
case FLOAT_TYPE:
|
|
retValue = getFloat(aTypeObject);
|
|
break;
|
|
case DOUBLE_TYPE:
|
|
retValue = getDouble(aTypeObject);
|
|
break;
|
|
case STRING_TYPE:
|
|
try
|
|
{
|
|
Float f = new Float((String) aTypeObject.aValue);
|
|
retValue = f.floatValue();
|
|
}
|
|
catch (java.lang.NumberFormatException e)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Cannot convert to short: " + aTypeObject.aValue);
|
|
}
|
|
break;
|
|
case BOOLEAN_TYPE:
|
|
retValue = getBool(aTypeObject) ? (double) -1 : (double) 0;
|
|
break;
|
|
default:
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Cannot convert this type: " + aValue.getClass().getName());
|
|
}
|
|
return retValue;
|
|
}
|
|
|
|
/**
|
|
* get a boolean value from the object
|
|
* @return a boolean
|
|
* @throws com.sun.star.lang.IllegalArgumentException if the object cannot be converted
|
|
*/
|
|
public static boolean toBoolean(Object aValue)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
boolean retValue = true;
|
|
TypeObject aTypeObject = getTypeObject(aValue);
|
|
switch (aTypeObject.iType)
|
|
{
|
|
case BYTE_TYPE:
|
|
retValue = (((Byte) aTypeObject.aValue).byteValue() != 0);
|
|
break;
|
|
case CHAR_TYPE:
|
|
retValue = (((Character) aTypeObject.aValue).charValue() != 0);
|
|
break;
|
|
case SHORT_TYPE:
|
|
retValue = (((Short) aTypeObject.aValue).shortValue() != 0);
|
|
break;
|
|
case INT_TYPE:
|
|
retValue = (((Integer) aTypeObject.aValue).intValue() != 0);
|
|
break;
|
|
case LONG_TYPE:
|
|
retValue = (((Long) aTypeObject.aValue).longValue() != 0);
|
|
break;
|
|
case FLOAT_TYPE:
|
|
retValue = (((Float) aTypeObject.aValue).floatValue() != 0);
|
|
break;
|
|
case DOUBLE_TYPE:
|
|
retValue = (((Double) aTypeObject.aValue).doubleValue() != 0);
|
|
break;
|
|
case STRING_TYPE:
|
|
try
|
|
{
|
|
Boolean b = Boolean.valueOf((String) aTypeObject.aValue);
|
|
retValue = b.booleanValue();
|
|
}
|
|
catch (java.lang.NumberFormatException e)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Cannot convert to short: " + aTypeObject.aValue);
|
|
}
|
|
break;
|
|
case BOOLEAN_TYPE:
|
|
retValue = ((Boolean) aTypeObject.aValue).booleanValue();
|
|
break;
|
|
default:
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Cannot convert this type: " + aValue.getClass().getName());
|
|
}
|
|
return retValue;
|
|
}
|
|
|
|
/**
|
|
* get the type object from the given object
|
|
* @param aValue an object representing a (numerical) value; can also be an 'any'
|
|
* @return a type object: the object together with the its type information
|
|
* @throws com.sun.star.lang.IllegalArgumentException if the object is unknown
|
|
*/
|
|
private static TypeObject getTypeObject(Object aValue)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
TypeObject aTypeObject = new TypeObject();
|
|
if (aValue == null || AnyConverter.isVoid(aValue))
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException("Cannot convert a null object.");
|
|
}
|
|
int type = AnyConverter.getType(aValue).getTypeClass().getValue();
|
|
switch (type)
|
|
{
|
|
case TypeClass.CHAR_value:
|
|
aTypeObject.iType = CHAR_TYPE;
|
|
aTypeObject.aValue = new Character(AnyConverter.toChar(aValue));
|
|
break;
|
|
case TypeClass.BYTE_value:
|
|
aTypeObject.iType = BYTE_TYPE;
|
|
aTypeObject.aValue = new Byte(AnyConverter.toByte(aValue));
|
|
break;
|
|
case TypeClass.SHORT_value:
|
|
aTypeObject.iType = SHORT_TYPE;
|
|
aTypeObject.aValue = new Short(AnyConverter.toShort(aValue));
|
|
break;
|
|
case TypeClass.LONG_value:
|
|
aTypeObject.iType = INT_TYPE;
|
|
aTypeObject.aValue = Integer.valueOf(AnyConverter.toInt(aValue));
|
|
break;
|
|
case TypeClass.HYPER_value:
|
|
aTypeObject.iType = LONG_TYPE;
|
|
aTypeObject.aValue = Long.valueOf(AnyConverter.toLong(aValue));
|
|
break;
|
|
case TypeClass.FLOAT_value:
|
|
aTypeObject.iType = FLOAT_TYPE;
|
|
aTypeObject.aValue = new Float(AnyConverter.toFloat(aValue));
|
|
break;
|
|
case TypeClass.DOUBLE_value:
|
|
aTypeObject.iType = DOUBLE_TYPE;
|
|
aTypeObject.aValue = new Double(AnyConverter.toDouble(aValue));
|
|
break;
|
|
case TypeClass.STRING_value:
|
|
aTypeObject.iType = STRING_TYPE;
|
|
aTypeObject.aValue = AnyConverter.toString(aValue);
|
|
break;
|
|
case TypeClass.BOOLEAN_value:
|
|
aTypeObject.iType = BOOLEAN_TYPE;
|
|
aTypeObject.aValue = Boolean.valueOf(AnyConverter.toBoolean(aValue));
|
|
break;
|
|
case TypeClass.SEQUENCE_value:
|
|
aTypeObject.iType = SEQUENCE_TYPE;
|
|
aTypeObject.aValue = aValue;
|
|
break;
|
|
default:
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Cannot convert this type: " + aValue.getClass().getName());
|
|
}
|
|
return aTypeObject;
|
|
}
|
|
|
|
/**
|
|
* get the simple byte type
|
|
*/
|
|
private static byte getByte(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != BYTE_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not a byte type.");
|
|
}
|
|
return ((Byte) typeObject.aValue).byteValue();
|
|
}
|
|
|
|
/**
|
|
* get the simple char type
|
|
*/
|
|
private static char getChar(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != CHAR_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not a char type.");
|
|
}
|
|
return ((Character) typeObject.aValue).charValue();
|
|
}
|
|
|
|
/**
|
|
* get the simple short type
|
|
*/
|
|
private static short getShort(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != SHORT_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not a short type.");
|
|
}
|
|
return ((Short) typeObject.aValue).shortValue();
|
|
}
|
|
|
|
/**
|
|
* get the simple int type
|
|
* @param typeObject
|
|
* @return
|
|
* @throws com.sun.star.lang.IllegalArgumentException
|
|
*/
|
|
private static int getInt(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != INT_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not an int type.");
|
|
}
|
|
return ((Integer) typeObject.aValue).intValue();
|
|
}
|
|
|
|
/**
|
|
* get the simple float type
|
|
* @throws com.sun.star.lang.IllegalArgumentException
|
|
*/
|
|
private static float getFloat(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != FLOAT_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not a float type.");
|
|
}
|
|
return ((Float) typeObject.aValue).floatValue();
|
|
}
|
|
|
|
/**
|
|
* get the simple double type
|
|
*/
|
|
private static double getDouble(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != DOUBLE_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not a double type.");
|
|
}
|
|
return ((Double) typeObject.aValue).doubleValue();
|
|
}
|
|
|
|
/**
|
|
* get the simple long type
|
|
*/
|
|
private static long getLong(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != LONG_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not a long type.");
|
|
}
|
|
return ((Long) typeObject.aValue).longValue();
|
|
}
|
|
|
|
/**
|
|
* get the simple boolean type
|
|
*/
|
|
private static boolean getBool(TypeObject typeObject)
|
|
throws com.sun.star.lang.IllegalArgumentException
|
|
{
|
|
if (typeObject.iType != BOOLEAN_TYPE)
|
|
{
|
|
throw new com.sun.star.lang.IllegalArgumentException(
|
|
"Given argument is not a boolean type.");
|
|
}
|
|
return ((Boolean) typeObject.aValue).booleanValue();
|
|
}
|
|
|
|
/**
|
|
* a class to contain a type and a value for easier conversions
|
|
*/
|
|
private static class TypeObject
|
|
{
|
|
|
|
public int iType;
|
|
public Object aValue;
|
|
}
|
|
|
|
/**
|
|
* simple class to construct a hexadecimal value from a long number
|
|
*/
|
|
private static class TransformNumToHex
|
|
{
|
|
|
|
private StringBuffer val;
|
|
|
|
public TransformNumToHex(long number)
|
|
{
|
|
val = new StringBuffer();
|
|
transform(number);
|
|
}
|
|
|
|
private void transform(long number)
|
|
{
|
|
int index = (int) (number % HEX_BASE);
|
|
number = number / HEX_BASE;
|
|
if (index < DEC_BASE)
|
|
{
|
|
val.insert(0, index);
|
|
}
|
|
else
|
|
{
|
|
val.insert(0, (char) (ASCII_LETTER_A_OFFSET + index));
|
|
}
|
|
if (number > 0)
|
|
{
|
|
transform(number);
|
|
}
|
|
}
|
|
}
|
|
}
|