/** * Does a transformation exist between the source and target type? * * @param sourceType * Incoming value type * @param targetType * Outgoing value type * @return True if a transform exists */ public static boolean isTransformable(Class<?> sourceType, Class<?> targetType) { return getTransform(sourceType, targetType) != null; }
/** * Does a transformation exist between the source and target type? * * @param sourceType * Incoming value type * @param targetType * Outgoing value type * @return True if a transform exists */ public static boolean isTransformable(Class<?> sourceType, Class<?> targetType) { return getTransform(sourceType, targetType) != null; }
private Transform getConvertFunctionDescriptor(Class<?> sourceType, Class<?> targetType) throws InvalidFunctionException { //If exact match no conversion necessary if(sourceType.equals(targetType)) { return null; } Transform result = DataTypeManager.getTransform(sourceType, targetType); //Else see if an implicit conversion is possible. if(result == null){ throw GENERIC_EXCEPTION; } return result; }
private Transform getConvertFunctionDescriptor(Class<?> sourceType, Class<?> targetType) throws InvalidFunctionException { //If exact match no conversion necessary if(sourceType.equals(targetType)) { return null; } Transform result = DataTypeManager.getTransform(sourceType, targetType); //Else see if an implicit conversion is possible. if(result == null){ throw GENERIC_EXCEPTION; } return result; }
private Transform getConvertFunctionDescriptor(Class<?> sourceType, Class<?> targetType) throws InvalidFunctionException { //If exact match no conversion necessary if(sourceType.equals(targetType)) { return null; } Transform result = DataTypeManager.getTransform(sourceType, targetType); //Else see if an implicit conversion is possible. if(result == null){ throw GENERIC_EXCEPTION; } return result; }
public static boolean isExplicitConversion(String srcType, String tgtType) { Transform t = getTransform(srcType, tgtType); if (t != null) { return t.isExplicit(); } return false; }
public static boolean isExplicitConversion(String srcType, String tgtType) { Transform t = getTransform(srcType, tgtType); if (t != null) { return t.isExplicit(); } return false; }
Transform transform = DataTypeManager.getTransform(value.getClass(), expectedType); if (transform != null) { try {
Transform t = DataTypeManager.getTransform(String.class, runtimeType); value = t.transform(value, runtimeType);
public static boolean isImplicitConversion(String srcType, String tgtType) { Transform t = getTransform(srcType, tgtType); if (t != null) { return !t.isExplicit(); } if (DefaultDataTypes.NULL.equals(srcType) && !DefaultDataTypes.NULL.equals(tgtType)) { return true; } if (DefaultDataTypes.OBJECT.equals(tgtType) && !DefaultDataTypes.OBJECT.equals(srcType)) { return true; } if (isArrayType(srcType) && isArrayType(tgtType)) { return isImplicitConversion(getComponentType(srcType), getComponentType(tgtType)); } return false; }
public static boolean isImplicitConversion(String srcType, String tgtType) { Transform t = getTransform(srcType, tgtType); if (t != null) { return !t.isExplicit(); } if (DefaultDataTypes.NULL.equals(srcType) && !DefaultDataTypes.NULL.equals(tgtType)) { return true; } if (DefaultDataTypes.OBJECT.equals(tgtType) && !DefaultDataTypes.OBJECT.equals(srcType)) { return true; } if (isArrayType(srcType) && isArrayType(tgtType)) { return isImplicitConversion(getComponentType(srcType), getComponentType(tgtType)); } return false; }
Transform t = DataTypeManager.getTransform(String.class, runtimeType); value = t.transform(value, runtimeType);
private static void helpTestTransform(Object value, Object expectedValue) throws TransformationException { Transform transform = DataTypeManager.getTransform(value.getClass(), expectedValue.getClass()); Object result = transform.transform(value, expectedValue.getClass()); assertEquals(expectedValue, result); }
public static Object transformValue(Object value, Class<?> sourceType, Class<?> targetClass) throws TransformationException { if (value == null || sourceType == targetClass || DefaultDataClasses.OBJECT == targetClass) { return value; } Transform transform = DataTypeManager.getTransform(sourceType, targetClass); if (transform == null) { Object[] params = new Object[] { sourceType, targetClass, value}; throw new TransformationException(CorePlugin.Event.TEIID10076, CorePlugin.Util.gs(CorePlugin.Event.TEIID10076, params)); } Object result = transform.transform(value, targetClass); return getCanonicalValue(result); }
public static Object transformValue(Object value, Class<?> sourceType, Class<?> targetClass) throws TransformationException { if (value == null || sourceType == targetClass || DefaultDataClasses.OBJECT == targetClass) { return value; } Transform transform = DataTypeManager.getTransform(sourceType, targetClass); if (transform == null) { Object[] params = new Object[] { sourceType, targetClass, value}; throw new TransformationException(CorePlugin.Event.TEIID10076, CorePlugin.Util.gs(CorePlugin.Event.TEIID10076, params)); } Object result = transform.transform(value, targetClass); return getCanonicalValue(result); }
Transform t = DataTypeManager.getTransform(sourceType, targetType); value = t != null ? t.transform(value, targetType) : value;
@Test public void testTimeConversions() { Transform t = DataTypeManager.getTransform(DataTypeManager.DefaultDataTypes.TIMESTAMP, DataTypeManager.DefaultDataTypes.DATE); assertEquals(DataTypeManager.DefaultDataClasses.DATE, t.getTargetType()); t = DataTypeManager.getTransform(DataTypeManager.DefaultDataTypes.TIME, DataTypeManager.DefaultDataTypes.TIMESTAMP); assertEquals(DataTypeManager.DefaultDataClasses.TIMESTAMP, t.getTargetType()); }
private static void validateTransform(String src, Object value, String target, Object expectedValue) throws TransformationException { try { Transform transform = DataTypeManager.getTransform(DataTypeManager.getDataTypeClass(src), expectedValue.getClass()); Object result = transform.transform(value, expectedValue.getClass()); assertTrue(expectedValue.getClass().isAssignableFrom(result.getClass())); assertFalse("Expected exception for " +src+ " to " + target, //$NON-NLS-1$ //$NON-NLS-2$ isException(DataTypeManager.getDataTypeName(value.getClass()), target,value)); } catch (TransformationException e) { if (!isException(DataTypeManager.getDataTypeName(value.getClass()), target,value)) { throw e; } } }
private static void helpTransformException(Object value, Class<?> target, String msg) { try { Transform transform = DataTypeManager.getTransform(value.getClass(), target); transform.transform(value, target); fail("Expected to get an exception during the transformation"); //$NON-NLS-1$ } catch (TransformationException e) { if (msg != null) { assertEquals(msg, e.getMessage()); } } }
@Test public void testObjectToAnyTransformFailure() { Transform transform = DataTypeManager.getTransform(DefaultDataClasses.OBJECT, DefaultDataClasses.TIME); try { transform.transform("1", DefaultDataClasses.TIME); //$NON-NLS-1$ fail("expected exception"); //$NON-NLS-1$ } catch (TransformationException e) { assertEquals("TEIID10076 Invalid conversion from type class java.lang.Object with value '1' to type class java.sql.Time", e.getMessage()); //$NON-NLS-1$ } }