diff options
Diffstat (limited to 'jurt/com/sun/star/uno/AnyConverter.java')
| -rw-r--r-- | jurt/com/sun/star/uno/AnyConverter.java | 543 |
1 files changed, 543 insertions, 0 deletions
diff --git a/jurt/com/sun/star/uno/AnyConverter.java b/jurt/com/sun/star/uno/AnyConverter.java new file mode 100644 index 000000000000..cbd13fe8589a --- /dev/null +++ b/jurt/com/sun/star/uno/AnyConverter.java @@ -0,0 +1,543 @@ +package com.sun.star.uno; + +/** This class provides static methods which aim at exploring the contents of an + * Any and extracting its value. All public methods take an Object argument that + * either is the immediate object, such as Boolean, Type, interface implementation, + * or an Any that contains an object. <br>The methods which extract the value do a + * widening conversion. See the method comments for the respective conversions. + */ +public class AnyConverter +{ + /** Determines the type of an any object. + + @param object any object + @return type object + */ + static public Type getType( Object object ) + { + Type t; + if (null == object) + { + t = m_XInterface_type; + } + else if (object instanceof Any) + { + t = ((Any)object).getType(); + // nested any + if (TypeClass.ANY_value == t.getTypeClass().getValue()) + return getType( ((Any)object).getObject() ); + } + else + { + t = new Type( object.getClass() ); + } + return t; + } + + /** checks if the any contains the idl type <code>void</code>. + @param object the object to check + @return true when the any is void, false otherwise + */ + static public boolean isVoid(Object object){ + return containsType(TypeClass.VOID, object); + } + + /** checks if the any contains a value of the idl type <code>char</code>. + @param object the object to check + @return true when the any contains a char, false otherwise. + */ + static public boolean isChar(Object object){ + return containsType(TypeClass.CHAR, object); + } + + /** checks if the any contains a value of the idl type <code>boolean</code>. + @param object the object to check + @return true when the any contains a boolean, false otherwise. + */ + static public boolean isBoolean(Object object){ + return containsType(TypeClass.BOOLEAN, object); + } + + /** checks if the any contains a value of the idl type <code>byte</code>. + @param object the object to check + @return true when the any contains a byte, false otherwise. + */ + static public boolean isByte(Object object){ + return containsType(TypeClass.BYTE, object); + } + + /** checks if the any contains a value of the idl type <code>short</code>. + @param object the object to check + @return true when the any contains a short, false otherwise. + */ + static public boolean isShort(Object object){ + return containsType(TypeClass.SHORT, object); + } + + /** checks if the any contains a value of the idl type <code>long</code> (which maps to a java-int). + @param object the object to check + @return true when the any contains a int, false otherwise. + */ + static public boolean isInt(Object object){ + return containsType(TypeClass.LONG, object); + } + + /** checks if the any contains a value of the idl type <code>hyper</code> (which maps to a java-long). + @param object the object to check + @return true when the any contains a long, false otherwise. + */ + static public boolean isLong(Object object){ + return containsType(TypeClass.HYPER, object); + } + + /** checks if the any contains a value of the idl type <code>float</code>. + @param object the object to check + @return true when the any contains a float, false otherwise. + */ + static public boolean isFloat(Object object){ + return containsType(TypeClass.FLOAT, object); + } + + /** checks if the any contains a value of the idl type <code>double</code>. + @param object the object to check + @return true when the any contains a double, false otherwise. + */ + static public boolean isDouble(Object object){ + return containsType(TypeClass.DOUBLE, object); + } + + /** checks if the any contains a value of the idl type <code>string</code>. + @param object the object to check + @return true when the any contains a string, false otherwise. + */ + static public boolean isString(Object object){ + return containsType(TypeClass.STRING, object); + } + + /** checks if the any contains a value of the idl type <code>enum</code>. + @param object the object to check + @return true if the any contains an enum, false otherwise + */ + static public boolean isEnum(Object object) + { + return containsType(TypeClass.ENUM, object); + } + + /** checks if the any contains a value of the idl type <code>type</code>. + @param object the object to check + @return true when the any contains a type, false otherwise. + */ + static public boolean isType(Object object){ + return containsType(TypeClass.TYPE, object); + } + + /** checks if the any contains an interface, struct, exception, sequence or enum. + If <em>object</em> is an any with an interface type, then true is also returned if + the any contains a null reference. This is because interfaces are allowed to have + a null value contrary to other UNO types. + @param object the object to check + @return true if the any contains an object + */ + static public boolean isObject(Object object) + { + int tc = getType(object).getTypeClass().getValue(); + return (TypeClass.INTERFACE_value == tc || + TypeClass.STRUCT_value == tc || + TypeClass.EXCEPTION_value == tc || + TypeClass.SEQUENCE_value == tc || + TypeClass.ENUM_value == tc); + } + + /** checks if the any contains UNO idl sequence value (meaning a java array + containing elements which are values of UNO idl types). + @param object the object to check + @return true when the any contains an object which implements interfaces, false otherwise. + */ + static public boolean isArray(Object object){ + return containsType(TypeClass.SEQUENCE, object); + } + + /** converts an Char object or an Any object containing a Char object into a simple char. + @param object the object to convert + @return the char contained within the object + @throws com.sun.star.lang.IllegalArgumentException in case no char is contained within object + @see #isChar + */ + static public char toChar(Object object) throws com.sun.star.lang.IllegalArgumentException{ + Character ret= (Character)convertSimple(TypeClass.CHAR, null, object); + return ret.charValue(); + } + + /** converts an Boolean object or an Any object containing a Boolean object into a simple boolean. + @param object the object to convert + @return the boolean contained within the object + @throws com.sun.star.lang.IllegalArgumentException in case no boolean is contained within object + @see #isBoolean + */ + static public boolean toBoolean(Object object) throws com.sun.star.lang.IllegalArgumentException{ + Boolean ret= (Boolean)convertSimple(TypeClass.BOOLEAN, null, object); + return ret.booleanValue(); + } + + /** converts an Byte object or an Any object containing a Byte object into a simple byte. + @param object the object to convert + @return the boolean contained within the object + @throws com.sun.star.lang.IllegalArgumentException in case no byte is contained within object + @see #isBoolean + */ + static public byte toByte(Object object) throws com.sun.star.lang.IllegalArgumentException{ + Byte ret= (Byte)convertSimple(TypeClass.BYTE, null, object); + return ret.byteValue(); + } + + /** converts a number object into a simple short and allows widening conversions. + Allowed argument types are Byte, Short or Any containing these types. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no short or byte is contained within object + @return the short contained within the object + */ + static public short toShort(Object object) throws com.sun.star.lang.IllegalArgumentException{ + Short ret= (Short)convertSimple(TypeClass.SHORT, null, object); + return ret.shortValue(); + } + /** converts a number object into an idl unsigned short and allows widening conversions. + Allowed argument types are Anies containing idl unsigned short values. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException + in case no idl unsigned short is contained within Any + @return an (unsigned) short + */ + static public short toUnsignedShort(Object object) + throws com.sun.star.lang.IllegalArgumentException + { + Short ret= (Short)convertSimple(TypeClass.UNSIGNED_SHORT, null, object); + return ret.shortValue(); + } + + /** converts a number object into a simple int and allows widening conversions. + Allowed argument types are Byte, Short, Integer or Any containing these types. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no short, byte or int is contained within object. + @return the int contained within the object + */ + static public int toInt(Object object) throws com.sun.star.lang.IllegalArgumentException{ + Integer ret= (Integer) convertSimple( TypeClass.LONG, null, object); + return ret.intValue(); + } + /** converts a number object into an idl unsigned long and allows widening conversions. + Allowed argument types are Anies containing idl unsigned short or unsigned long values. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException + in case no idl unsigned short nor unsigned long is contained within Any + @return an (unsigned) int + */ + static public int toUnsignedInt(Object object) + throws com.sun.star.lang.IllegalArgumentException + { + Integer ret = (Integer)convertSimple(TypeClass.UNSIGNED_LONG, null, object); + return ret.intValue(); + } + + /** converts a number object into a simple long and allows widening conversions. + Allowed argument types are Byte, Short, Integer, Long or Any containing these types. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no short, byte, int or long + is contained within object. + @return the long contained within the object + */ + static public long toLong(Object object) throws com.sun.star.lang.IllegalArgumentException{ + Long ret= (Long) convertSimple( TypeClass.HYPER, null, object); + return ret.longValue(); + } + /** converts a number object into an idl unsigned hyper and allows widening conversions. + Allowed argument types are Anies containing idl unsigned short, unsigned long or + unsigned hyper values. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException + in case no idl unsigned short, nor unsigned long nor unsigned hyper + is contained within object. + @return an (unsigned) long + */ + static public long toUnsignedLong(Object object) + throws com.sun.star.lang.IllegalArgumentException + { + Long ret = (Long)convertSimple(TypeClass.UNSIGNED_HYPER, null, object); + return ret.longValue(); + } + + /** converts a number object into a simple float and allows widening conversions. + Allowed argument types are Byte, Short, Float or Any containing these types. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no byte, short or float + is contained within object. + @return the float contained within the object + */ + static public float toFloat(Object object) throws com.sun.star.lang.IllegalArgumentException{ + Float ret= (Float) convertSimple( TypeClass.FLOAT,null, object); + return ret.floatValue(); + } + + /** converts a number object into a simple double and allows widening conversions. + Allowed argument types are Byte, Short, Int, Float, Double or Any containing these types. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no byte, short, int, float + or double is contained within object. + @return the double contained within the object + */ + static public double toDouble(Object object) throws com.sun.star.lang.IllegalArgumentException { + Double ret= (Double) convertSimple( TypeClass.DOUBLE, null, object); + return ret.doubleValue(); + } + + /** converts a string or an any containing a string into a string. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no string is contained within object. + @return the string contained within the object + */ + static public String toString(Object object) throws com.sun.star.lang.IllegalArgumentException { + return (String) convertSimple( TypeClass.STRING, null, object); + } + + /** converts a Type or an any containing a Type into a Type. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no type is contained within object. + @return the type contained within the object + */ + static public Type toType(Object object) throws com.sun.star.lang.IllegalArgumentException { + return (Type) convertSimple( TypeClass.TYPE, null, object); + } + + /** converts a UNO object (struct, exception, sequence, enum or interface) or an Any containing + * these types into an UNO object of a specified destination type. + * For interfaces, the argument <em>object</em> is queried for the interface specified + * by the <em>type</em> argument. That query (UnoRuntime.queryInterface) might return null, + * if the interface is not implemented or a null-ref or a VOID any is given. + * + * @param type type of the returned value + * @param object the object that is to be converted + * @return destination object + * @throws com.sun.star.lang.IllegalArgumentException + * in case conversion is not possible + */ + static public Object toObject(Type type, Object object) + throws com.sun.star.lang.IllegalArgumentException + { + return convertSimple( type.getTypeClass(), type, object ); + } + /** converts a UNO object (struct, exception, sequence, enum or interface) or an Any containing + * these types into an UNO object of a specified destination type. + * For interfaces, the argument <em>object</em> is queried for the interface specified + * by the <em>type</em> argument. That query (UnoRuntime.queryInterface) might return null, + * if the interface is not implemented or a null-ref or a VOID any is given. + * + * @param clazz class of the returned value + * @param object the object that is to be converted + * @return destination object + * @throws com.sun.star.lang.IllegalArgumentException + * in case conversion is not possible + */ + static public Object toObject(Class clazz, Object object) + throws com.sun.star.lang.IllegalArgumentException + { + return toObject( new Type( clazz ), object ); + } + + /** converts an array or an any containing an array into an array. + @param object the object to convert + @throws com.sun.star.lang.IllegalArgumentException in case no array is contained within object. + @return the array contained within the object + */ + static public Object toArray( Object object) throws com.sun.star.lang.IllegalArgumentException { + return convertSimple( TypeClass.SEQUENCE, null, object); + } + + /** + Examines the argument <em>object</em> if is correspond to the type in argument <em>what</em>. + <em>object</em> is either matched directly against the type or if it is an any then the + contained object is matched against the type. + */ + static private boolean containsType( TypeClass what, Object object){ + return (getType(object).getTypeClass().getValue() == what.getValue()); + } + + static private final Type m_XInterface_type = new Type( XInterface.class ); + + static private Object convertSimple( TypeClass destTClass, Type destType, Object object_ ) + throws com.sun.star.lang.IllegalArgumentException + { + Object object; + Type type; + if (object_ instanceof Any) + { + // unbox + Any a = (Any)object_; + object = a.getObject(); + type = a.getType(); + // nested any + if (TypeClass.ANY_value == type.getTypeClass().getValue()) + return convertSimple( destTClass, destType, object ); + } + else + { + object = object_; + type = (null == object ? m_XInterface_type : new Type( object.getClass() )); + } + + int tc = type.getTypeClass().getValue(); + int dest_tc = destTClass.getValue(); + + if (null == object) + { + // special for interfaces + if (TypeClass.INTERFACE_value == tc && dest_tc == tc) + return null; + } + else + { + switch (dest_tc) + { + case TypeClass.CHAR_value: + if (tc == TypeClass.CHAR_value) + return object; + break; + case TypeClass.BOOLEAN_value: + if (tc == TypeClass.BOOLEAN_value) + return object; + break; + case TypeClass.BYTE_value: + if (tc == TypeClass.BYTE_value) + return object; + break; + case TypeClass.SHORT_value: + switch (tc) + { + case TypeClass.BYTE_value: + return new Short( ((Byte)object).byteValue() ); + case TypeClass.SHORT_value: + return object; + } + break; + case TypeClass.UNSIGNED_SHORT_value: + switch (tc) + { + case TypeClass.UNSIGNED_SHORT_value: + return object; + } + break; + case TypeClass.LONG_value: + switch (tc) + { + case TypeClass.BYTE_value: + return new Integer( ((Byte)object).byteValue() ); + case TypeClass.SHORT_value: + case TypeClass.UNSIGNED_SHORT_value: + return new Integer( ((Short)object).shortValue() ); + case TypeClass.LONG_value: + return object; + } + break; + case TypeClass.UNSIGNED_LONG_value: + switch (tc) + { + case TypeClass.UNSIGNED_SHORT_value: + return new Integer( ((Short)object).shortValue() ); + case TypeClass.UNSIGNED_LONG_value: + return object; + } + break; + case TypeClass.HYPER_value: + switch (tc) + { + case TypeClass.BYTE_value: + return new Long( ((Byte)object).byteValue() ); + case TypeClass.SHORT_value: + case TypeClass.UNSIGNED_SHORT_value: + return new Long( ((Short)object).shortValue() ); + case TypeClass.LONG_value: + case TypeClass.UNSIGNED_LONG_value: + return new Long( ((Integer)object).intValue() ); + case TypeClass.HYPER_value: + return object; + } + break; + case TypeClass.UNSIGNED_HYPER_value: + switch (tc) + { + case TypeClass.UNSIGNED_SHORT_value: + return new Long( ((Short)object).shortValue() ); + case TypeClass.UNSIGNED_LONG_value: + return new Long( ((Integer)object).intValue() ); + case TypeClass.UNSIGNED_HYPER_value: + return object; + } + break; + case TypeClass.FLOAT_value: + switch (tc) + { + case TypeClass.BYTE_value: + return new Float( ((Byte)object).byteValue() ); + case TypeClass.SHORT_value: + return new Float( ((Short)object).shortValue() ); + case TypeClass.FLOAT_value: + return object; + } + break; + case TypeClass.DOUBLE_value: + switch (tc) + { + case TypeClass.BYTE_value: + return new Double( ((Byte)object).byteValue() ); + case TypeClass.SHORT_value: + return new Double( ((Short)object).shortValue() ); + case TypeClass.LONG_value: + return new Double( ((Integer)object).intValue() ); + case TypeClass.FLOAT_value: + return new Double( ((Float)object).floatValue() ); + case TypeClass.DOUBLE_value: + return object; + } + break; + case TypeClass.ENUM_value: + if (tc == TypeClass.ENUM_value && + (null == destTClass || destType.equals( type ) /* optional destType */)) + { + return object; + } + break; + case TypeClass.STRING_value: + if (tc == TypeClass.STRING_value) + return object; + break; + case TypeClass.TYPE_value: + if (tc == TypeClass.TYPE_value) + return object; + break; + case TypeClass.INTERFACE_value: + // Because object is a class, not an interface, it is + // controversial what kind of Type "new Type(object.class)" + // above should return (UNKNOWN or INTERFACE), so that we should + // not check here for "tc == TypeClass.INTERFACE_value". + // Instead, we check whether object (indirectly) derives from + // XInterface: + if (object instanceof XInterface) + return UnoRuntime.queryInterface( destType, object ); + break; + case TypeClass.STRUCT_value: + case TypeClass.EXCEPTION_value: + if (destType.isSupertypeOf(type)) { + return object; + } + break; + case TypeClass.SEQUENCE_value: + if (tc == TypeClass.SEQUENCE_value && + (null == destType || destType.equals( type ) /* optional destType */)) + { + return object; + } + break; + } + } + throw new com.sun.star.lang.IllegalArgumentException( + "The Argument did not hold the proper type"); + } +} |