Mercurial > projects > dwt2
annotate org.eclipse.core.databinding/src/org/eclipse/core/databinding/UpdateStrategy.d @ 88:9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
| author | Frank Benoit <benoit@tionex.de> |
|---|---|
| date | Sun, 19 Apr 2009 11:10:09 +0200 |
| parents | 6be48cf9f95c |
| children |
| rev | line source |
|---|---|
| 78 | 1 /******************************************************************************* |
| 2 * Copyright (c) 2007, 2008 IBM Corporation and others. | |
| 3 * All rights reserved. This program and the accompanying materials | |
| 4 * are made available under the terms of the Eclipse Public License v1.0 | |
| 5 * which accompanies this distribution, and is available at | |
| 6 * http://www.eclipse.org/legal/epl-v10.html | |
| 7 * | |
| 8 * Contributors: | |
| 9 * IBM Corporation - initial API and implementation | |
| 10 * Matt Carter - Bug 180392 | |
| 11 * - Character support completed (bug 197679) | |
| 12 *******************************************************************************/ | |
| 13 | |
| 14 module org.eclipse.core.databinding.UpdateStrategy; | |
| 81 | 15 import org.eclipse.core.databinding.BindingException; |
| 78 | 16 |
| 17 import java.lang.all; | |
| 18 | |
| 19 import java.math.BigDecimal; | |
| 20 import java.math.BigInteger; | |
| 21 import java.util.HashMap; | |
| 22 import java.util.Map; | |
| 23 | |
| 24 import org.eclipse.core.databinding.conversion.IConverter; | |
| 25 import org.eclipse.core.databinding.conversion.NumberToStringConverter; | |
| 26 import org.eclipse.core.databinding.conversion.StringToNumberConverter; | |
| 27 import org.eclipse.core.databinding.util.Policy; | |
| 28 import org.eclipse.core.internal.databinding.ClassLookupSupport; | |
| 29 import org.eclipse.core.internal.databinding.Pair; | |
| 30 import org.eclipse.core.internal.databinding.conversion.CharacterToStringConverter; | |
| 31 import org.eclipse.core.internal.databinding.conversion.IdentityConverter; | |
| 32 import org.eclipse.core.internal.databinding.conversion.IntegerToStringConverter; | |
| 33 import org.eclipse.core.internal.databinding.conversion.NumberToBigDecimalConverter; | |
| 34 import org.eclipse.core.internal.databinding.conversion.NumberToBigIntegerConverter; | |
| 35 import org.eclipse.core.internal.databinding.conversion.NumberToByteConverter; | |
| 36 import org.eclipse.core.internal.databinding.conversion.NumberToDoubleConverter; | |
| 37 import org.eclipse.core.internal.databinding.conversion.NumberToFloatConverter; | |
| 38 import org.eclipse.core.internal.databinding.conversion.NumberToIntegerConverter; | |
| 39 import org.eclipse.core.internal.databinding.conversion.NumberToLongConverter; | |
| 40 import org.eclipse.core.internal.databinding.conversion.NumberToShortConverter; | |
| 41 import org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter; | |
| 42 import org.eclipse.core.internal.databinding.conversion.StringToByteConverter; | |
| 43 import org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter; | |
| 44 import org.eclipse.core.internal.databinding.conversion.StringToShortConverter; | |
| 45 import org.eclipse.core.runtime.IStatus; | |
| 46 import org.eclipse.core.runtime.Status; | |
| 47 | |
| 48 import com.ibm.icu.text.NumberFormat; | |
| 49 | |
| 50 /** | |
| 51 * @since 1.0 | |
| 52 * | |
| 53 */ | |
| 54 /* package */class UpdateStrategy { | |
| 55 | |
| 56 private static final String BOOLEAN_TYPE = "java.lang.Boolean.TYPE"; //$NON-NLS-1$ | |
| 57 | |
| 58 private static final String SHORT_TYPE = "java.lang.Short.TYPE"; //$NON-NLS-1$ | |
| 59 | |
| 60 private static final String BYTE_TYPE = "java.lang.Byte.TYPE"; //$NON-NLS-1$ | |
| 61 | |
| 62 private static final String DOUBLE_TYPE = "java.lang.Double.TYPE"; //$NON-NLS-1$ | |
| 63 | |
| 64 private static final String FLOAT_TYPE = "java.lang.Float.TYPE"; //$NON-NLS-1$ | |
| 65 | |
| 66 private static final String INTEGER_TYPE = "java.lang.Integer.TYPE"; //$NON-NLS-1$ | |
| 67 | |
| 68 private static final String LONG_TYPE = "java.lang.Long.TYPE"; //$NON-NLS-1$ | |
| 69 | |
| 70 private static final String CHARACTER_TYPE = "java.lang.Character.TYPE"; //$NON-NLS-1$ | |
| 71 | |
| 72 private static Map converterMap; | |
| 73 | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
74 private static Class autoboxed(Class clazz) { |
| 78 | 75 if (clazz is Float.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
76 return Class.fromType!(Float); |
| 78 | 77 else if (clazz is Double.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
78 return Class.fromType!(Double); |
| 78 | 79 else if (clazz is Short.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
80 return Class.fromType!(Short); |
| 78 | 81 else if (clazz is Integer.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
82 return Class.fromType!(Integer); |
| 78 | 83 else if (clazz is Long.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
84 return Class.fromType!(Long); |
| 78 | 85 else if (clazz is Byte.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
86 return Class.fromType!(Byte); |
| 78 | 87 else if (clazz is Boolean.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
88 return Class.fromType!(Boolean); |
| 78 | 89 else if (clazz is Character.TYPE) |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
90 return Class.fromType!(Character); |
| 78 | 91 return clazz; |
| 92 } | |
| 93 | |
| 94 final protected void checkAssignable(Object toType, Object fromType, | |
| 95 String errorString) { | |
| 96 Boolean assignableFromModelToModelConverter = isAssignableFromTo( | |
| 97 fromType, toType); | |
| 98 if (assignableFromModelToModelConverter !is null | |
| 99 && !assignableFromModelToModelConverter.booleanValue()) { | |
| 100 throw new BindingException(errorString | |
| 85 | 101 ~ Format(" Expected: {}, actual: {}", fromType, toType)); //$NON-NLS-1$//$NON-NLS-2$ |
| 78 | 102 } |
| 103 } | |
| 104 | |
| 105 /** | |
| 106 * Tries to create a converter that can convert from values of type | |
| 107 * fromType. Returns <code>null</code> if no converter could be created. | |
| 108 * Either toType or modelDescription can be <code>null</code>, but not | |
| 109 * both. | |
| 110 * | |
| 111 * @param fromType | |
| 112 * @param toType | |
| 113 * @return an IConverter, or <code>null</code> if unsuccessful | |
| 114 */ | |
| 115 protected IConverter createConverter(Object fromType, Object toType) { | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
116 if (!( null !is cast(Class)fromType ) || !( null !is cast(Class)toType )) { |
| 78 | 117 return new DefaultConverter(fromType, toType); |
| 118 } | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
119 Class toClass = cast(Class) toType; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
120 Class originalToClass = toClass; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
121 if (toClass.isPrimitive()) { |
| 78 | 122 toClass = autoboxed(toClass); |
| 123 } | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
124 Class fromClass = cast(Class) fromType; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
125 Class originalFromClass = fromClass; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
126 if (fromClass.isPrimitive()) { |
| 78 | 127 fromClass = autoboxed(fromClass); |
| 128 } | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
129 if (!(cast(Class) toType).isPrimitive() |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
130 && toClass.isAssignableFrom(fromClass)) { |
| 78 | 131 return new IdentityConverter(originalFromClass, originalToClass); |
| 132 } | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
133 if ((cast(Class) fromType).isPrimitive() && (cast(Class) toType).isPrimitive() |
| 85 | 134 && fromType.opEquals(toType)) { |
| 78 | 135 return new IdentityConverter(originalFromClass, originalToClass); |
| 136 } | |
| 137 Map converterMap = getConverterMap(); | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
138 Class[] supertypeHierarchyFlattened = ClassLookupSupport |
| 78 | 139 .getTypeHierarchyFlattened(fromClass); |
| 140 for (int i = 0; i < supertypeHierarchyFlattened.length; i++) { | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
141 Class currentFromClass = supertypeHierarchyFlattened[i]; |
| 78 | 142 if (currentFromClass is toType) { |
| 143 // converting to toType is just a widening | |
| 144 return new IdentityConverter(fromClass, toClass); | |
| 145 } | |
| 85 | 146 Pair key = new Pair(stringcast(getKeyForClass(fromType, currentFromClass)), |
| 147 stringcast(getKeyForClass(toType, toClass))); | |
| 78 | 148 Object converterOrClassname = converterMap.get(key); |
| 149 if ( null !is cast(IConverter)converterOrClassname ) { | |
| 150 return cast(IConverter) converterOrClassname; | |
| 85 | 151 } else if ( null !is cast(ArrayWrapperString)converterOrClassname ) { |
| 152 String classname = stringcast( converterOrClassname); | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
153 Class converterClass; |
| 78 | 154 try { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
155 converterClass = Class.forName(classname); |
| 78 | 156 IConverter result = cast(IConverter) converterClass |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
157 .newInstance(); |
| 85 | 158 converterMap.put(stringcast(key), cast(Object)result); |
| 78 | 159 return result; |
| 160 } catch (Exception e) { | |
| 161 Policy | |
| 162 .getLog() | |
| 163 .log( | |
| 164 new Status( | |
| 165 IStatus.ERROR, | |
| 166 Policy.JFACE_DATABINDING, | |
| 167 0, | |
| 168 "Error while instantiating default converter", e)); //$NON-NLS-1$ | |
| 169 } | |
| 170 } | |
| 171 } | |
| 172 // Since we found no converter yet, try a "downcast" converter; | |
| 173 // the IdentityConverter will automatically check the actual types at | |
| 174 // runtime. | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
175 if (fromClass.isAssignableFrom(toClass)) { |
| 78 | 176 return new IdentityConverter(originalFromClass, originalToClass); |
| 177 } | |
| 178 return new DefaultConverter(fromType, toType); | |
| 179 } | |
| 180 | |
| 181 private synchronized static Map getConverterMap() { | |
| 182 // using string-based lookup avoids loading of too many classes | |
| 183 if (converterMap is null) { | |
| 184 // NumberFormat to be shared across converters for the formatting of | |
| 185 // integer values | |
| 186 NumberFormat integerFormat = NumberFormat.getIntegerInstance(); | |
| 187 // NumberFormat to be shared across converters for formatting non | |
| 188 // integer values | |
| 189 NumberFormat numberFormat = NumberFormat.getNumberInstance(); | |
| 190 | |
| 191 converterMap = new HashMap(); | |
| 192 // Standard and Boxed Types | |
| 193 converterMap | |
| 194 .put( | |
| 195 new Pair("java.util.Date", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.DateToStringConverter"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ | |
| 196 converterMap | |
| 197 .put( | |
| 198 new Pair("java.lang.String", "java.lang.Boolean"), "org.eclipse.core.internal.databinding.conversion.StringToBooleanConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ | |
| 199 converterMap | |
| 200 .put( | |
| 201 new Pair("java.lang.String", "java.lang.Byte"), StringToByteConverter.toByte(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 202 converterMap | |
| 203 .put( | |
| 204 new Pair("java.lang.String", "java.util.Date"), "org.eclipse.core.internal.databinding.conversion.StringToDateConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ | |
| 205 converterMap | |
| 206 .put( | |
| 207 new Pair("java.lang.String", "java.lang.Short"), StringToShortConverter.toShort(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 208 converterMap | |
| 209 .put( | |
| 210 new Pair("java.lang.String", "java.lang.Character"), StringToCharacterConverter.toCharacter(false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 211 converterMap | |
| 212 .put( | |
| 213 new Pair("java.lang.String", "java.lang.Integer"), StringToNumberConverter.toInteger(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 214 converterMap | |
| 215 .put( | |
| 216 new Pair("java.lang.String", "java.lang.Double"), StringToNumberConverter.toDouble(numberFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 217 converterMap | |
| 218 .put( | |
| 219 new Pair("java.lang.String", "java.lang.Long"), StringToNumberConverter.toLong(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 220 converterMap | |
| 221 .put( | |
| 222 new Pair("java.lang.String", "java.lang.Float"), StringToNumberConverter.toFloat(numberFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 223 converterMap | |
| 224 .put( | |
| 225 new Pair("java.lang.String", "java.math.BigInteger"), StringToNumberConverter.toBigInteger(integerFormat)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 226 converterMap | |
| 227 .put( | |
| 228 new Pair("java.lang.Integer", "java.lang.String"), NumberToStringConverter.fromInteger(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 229 converterMap | |
| 230 .put( | |
| 231 new Pair("java.lang.Long", "java.lang.String"), NumberToStringConverter.fromLong(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 232 converterMap | |
| 233 .put( | |
| 234 new Pair("java.lang.Double", "java.lang.String"), NumberToStringConverter.fromDouble(numberFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 235 converterMap | |
| 236 .put( | |
| 237 new Pair("java.lang.Float", "java.lang.String"), NumberToStringConverter.fromFloat(numberFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 238 converterMap | |
| 239 .put( | |
| 240 new Pair("java.math.BigInteger", "java.lang.String"), NumberToStringConverter.fromBigInteger(integerFormat)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 241 converterMap | |
| 242 .put( | |
| 243 new Pair("java.lang.Byte", "java.lang.String"), IntegerToStringConverter.fromByte(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 244 converterMap | |
| 245 .put( | |
| 246 new Pair("java.lang.Short", "java.lang.String"), IntegerToStringConverter.fromShort(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 247 converterMap | |
| 248 .put( | |
| 249 new Pair("java.lang.Character", "java.lang.String"), CharacterToStringConverter.fromCharacter(false)); //$NON-NLS-1$//$NON-NLS-2$ | |
| 250 | |
| 251 converterMap | |
| 252 .put( | |
| 253 new Pair("java.lang.Object", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ | |
| 254 | |
| 255 // Integer.TYPE | |
| 256 converterMap | |
| 257 .put( | |
| 258 new Pair("java.lang.String", INTEGER_TYPE), StringToNumberConverter.toInteger(integerFormat, true)); //$NON-NLS-1$ | |
| 259 converterMap | |
| 260 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
261 new Pair(INTEGER_TYPE, "java.lang.Integer"), new IdentityConverter(Integer.TYPE, Class.fromType!(Integer))); //$NON-NLS-1$ |
| 78 | 262 converterMap |
| 263 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
264 new Pair(INTEGER_TYPE, "java.lang.Object"), new IdentityConverter(Integer.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 265 converterMap |
| 266 .put( | |
| 267 new Pair(INTEGER_TYPE, "java.lang.String"), NumberToStringConverter.fromInteger(integerFormat, true)); //$NON-NLS-1$ | |
| 268 | |
| 269 // Byte.TYPE | |
| 270 converterMap | |
| 271 .put( | |
| 272 new Pair("java.lang.String", BYTE_TYPE), StringToByteConverter.toByte(integerFormat, true)); //$NON-NLS-1$ | |
| 273 converterMap | |
| 274 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
275 new Pair(BYTE_TYPE, "java.lang.Byte"), new IdentityConverter(Byte.TYPE, Class.fromType!(Byte))); //$NON-NLS-1$ |
| 78 | 276 converterMap |
| 277 .put( | |
| 278 new Pair(BYTE_TYPE, "java.lang.String"), IntegerToStringConverter.fromByte(integerFormat, true)); //$NON-NLS-1$ | |
| 279 converterMap | |
| 280 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
281 new Pair(BYTE_TYPE, "java.lang.Object"), new IdentityConverter(Byte.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 282 |
| 283 // Double.TYPE | |
| 284 converterMap | |
| 285 .put( | |
| 286 new Pair("java.lang.String", DOUBLE_TYPE), StringToNumberConverter.toDouble(numberFormat, true)); //$NON-NLS-1$ | |
| 287 converterMap | |
| 288 .put( | |
| 289 new Pair(DOUBLE_TYPE, "java.lang.String"), NumberToStringConverter.fromDouble(numberFormat, true)); //$NON-NLS-1$ | |
| 290 | |
| 291 converterMap | |
| 292 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
293 new Pair(DOUBLE_TYPE, "java.lang.Double"), new IdentityConverter(Double.TYPE, Class.fromType!(Double))); //$NON-NLS-1$ |
| 78 | 294 converterMap |
| 295 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
296 new Pair(DOUBLE_TYPE, "java.lang.Object"), new IdentityConverter(Double.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 297 |
| 298 // Boolean.TYPE | |
| 299 converterMap | |
| 300 .put( | |
| 301 new Pair("java.lang.String", BOOLEAN_TYPE), "org.eclipse.core.internal.databinding.conversion.StringToBooleanPrimitiveConverter"); //$NON-NLS-1$ //$NON-NLS-2$ | |
| 302 converterMap | |
| 303 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
304 new Pair(BOOLEAN_TYPE, "java.lang.Boolean"), new IdentityConverter(Boolean.TYPE, Class.fromType!(Boolean))); //$NON-NLS-1$ |
| 78 | 305 converterMap |
| 306 .put( | |
| 85 | 307 new Pair(BOOLEAN_TYPE, "java.lang.String"), new ObjectToStringConverter(Boolean.TYPE)); //$NON-NLS-1$ |
| 78 | 308 converterMap |
| 309 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
310 new Pair(BOOLEAN_TYPE, "java.lang.Object"), new IdentityConverter(Boolean.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 311 |
| 312 // Float.TYPE | |
| 313 converterMap | |
| 314 .put( | |
| 315 new Pair("java.lang.String", FLOAT_TYPE), StringToNumberConverter.toFloat(numberFormat, true)); //$NON-NLS-1$ | |
| 316 converterMap | |
| 317 .put( | |
| 318 new Pair(FLOAT_TYPE, "java.lang.String"), NumberToStringConverter.fromFloat(numberFormat, true)); //$NON-NLS-1$ | |
| 319 converterMap | |
| 320 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
321 new Pair(FLOAT_TYPE, "java.lang.Float"), new IdentityConverter(Float.TYPE, Class.fromType!(Float))); //$NON-NLS-1$ |
| 78 | 322 converterMap |
| 323 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
324 new Pair(FLOAT_TYPE, "java.lang.Object"), new IdentityConverter(Float.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 325 |
| 326 // Short.TYPE | |
| 327 converterMap | |
| 328 .put( | |
| 329 new Pair("java.lang.String", SHORT_TYPE), StringToShortConverter.toShort(integerFormat, true)); //$NON-NLS-1$ | |
| 330 converterMap | |
| 331 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
332 new Pair(SHORT_TYPE, "java.lang.Short"), new IdentityConverter(Short.TYPE, Class.fromType!(Short))); //$NON-NLS-1$ |
| 78 | 333 converterMap |
| 334 .put( | |
| 335 new Pair(SHORT_TYPE, "java.lang.String"), IntegerToStringConverter.fromShort(integerFormat, true)); //$NON-NLS-1$ | |
| 336 converterMap | |
| 337 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
338 new Pair(SHORT_TYPE, "java.lang.Object"), new IdentityConverter(Short.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 339 |
| 340 // Long.TYPE | |
| 341 converterMap | |
| 342 .put( | |
| 343 new Pair("java.lang.String", LONG_TYPE), StringToNumberConverter.toLong(integerFormat, true)); //$NON-NLS-1$ | |
| 344 converterMap | |
| 345 .put( | |
| 346 new Pair(LONG_TYPE, "java.lang.String"), NumberToStringConverter.fromLong(integerFormat, true)); //$NON-NLS-1$ | |
| 347 converterMap | |
| 348 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
349 new Pair(LONG_TYPE, "java.lang.Long"), new IdentityConverter(Long.TYPE, Class.fromType!(Long))); //$NON-NLS-1$ |
| 78 | 350 converterMap |
| 351 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
352 new Pair(LONG_TYPE, "java.lang.Object"), new IdentityConverter(Long.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 353 |
| 354 // Character.TYPE | |
| 355 converterMap | |
| 356 .put( | |
| 357 new Pair("java.lang.String", CHARACTER_TYPE), StringToCharacterConverter.toCharacter(true)); //$NON-NLS-1$ | |
| 358 converterMap | |
| 359 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
360 new Pair(CHARACTER_TYPE, "java.lang.Character"), new IdentityConverter(Character.TYPE, Class.fromType!(Character))); //$NON-NLS-1$ |
| 78 | 361 converterMap |
| 362 .put( | |
| 363 new Pair(CHARACTER_TYPE, "java.lang.String"), CharacterToStringConverter.fromCharacter(true)); //$NON-NLS-1$ | |
| 364 converterMap | |
| 365 .put( | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
366 new Pair(CHARACTER_TYPE, "java.lang.Object"), new IdentityConverter(Character.TYPE, Class.fromType!(Object))); //$NON-NLS-1$ |
| 78 | 367 |
| 368 // Miscellaneous | |
| 369 converterMap | |
| 370 .put( | |
| 371 new Pair( | |
| 372 "org.eclipse.core.runtime.IStatus", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.StatusToStringConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ | |
| 373 | |
| 374 addNumberToByteConverters(converterMap, integerFormat, | |
| 375 integerClasses); | |
| 376 addNumberToByteConverters(converterMap, numberFormat, floatClasses); | |
| 377 | |
| 378 addNumberToShortConverters(converterMap, integerFormat, | |
| 379 integerClasses); | |
| 380 addNumberToShortConverters(converterMap, numberFormat, floatClasses); | |
| 381 | |
| 382 addNumberToIntegerConverters(converterMap, integerFormat, | |
| 383 integerClasses); | |
| 384 addNumberToIntegerConverters(converterMap, numberFormat, | |
| 385 floatClasses); | |
| 386 | |
| 387 addNumberToLongConverters(converterMap, integerFormat, | |
| 388 integerClasses); | |
| 389 addNumberToLongConverters(converterMap, numberFormat, floatClasses); | |
| 390 | |
| 391 addNumberToFloatConverters(converterMap, integerFormat, | |
| 392 integerClasses); | |
| 393 addNumberToFloatConverters(converterMap, numberFormat, floatClasses); | |
| 394 | |
| 395 addNumberToDoubleConverters(converterMap, integerFormat, | |
| 396 integerClasses); | |
| 397 addNumberToDoubleConverters(converterMap, numberFormat, | |
| 398 floatClasses); | |
| 399 | |
| 400 addNumberToBigIntegerConverters(converterMap, integerFormat, | |
| 401 integerClasses); | |
| 402 addNumberToBigIntegerConverters(converterMap, numberFormat, | |
| 403 floatClasses); | |
| 404 | |
| 405 addNumberToBigDecimalConverters(converterMap, integerFormat, | |
| 406 integerClasses); | |
| 407 addNumberToBigDecimalConverters(converterMap, numberFormat, | |
| 408 floatClasses); | |
| 409 } | |
| 410 | |
| 411 return converterMap; | |
| 412 } | |
| 413 | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
414 private static Class[] integerClasses; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
415 private static Class[] floatClasses; |
| 85 | 416 static this(){ |
| 417 integerClasses = [ Byte.TYPE, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
418 Class.fromType!(Byte), Short.TYPE, Class.fromType!(Short), Integer.TYPE, Class.fromType!(Integer), |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
419 Long.TYPE, Class.fromType!(Long), Class.fromType!(BigInteger) ]; |
| 85 | 420 floatClasses = [ Float.TYPE, |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
421 Class.fromType!(Float), Double.TYPE, Class.fromType!(Double), Class.fromType!(BigDecimal) ]; |
| 85 | 422 } |
| 78 | 423 |
| 424 | |
| 425 /** | |
| 426 * Registers converters to boxed and unboxed types from a list of from | |
| 427 * classes. | |
| 428 * | |
| 429 * @param map | |
| 430 * @param numberFormat | |
| 431 * @param fromTypes | |
| 432 */ | |
| 433 private static void addNumberToByteConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
434 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 435 |
| 436 for (int i = 0; i < fromTypes.length; i++) { | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
437 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
438 if (fromType != Class.fromType!(Byte) && fromType != Byte.TYPE) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
439 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
440 fromType, null) : fromType.getName(); |
| 78 | 441 |
| 442 map | |
| 443 .put(new Pair(fromName, BYTE_TYPE), | |
| 444 new NumberToByteConverter(numberFormat, | |
| 445 fromType, true)); | |
| 446 map | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
447 .put(new Pair(fromName, Class.fromType!(Byte).getName()), |
| 78 | 448 new NumberToByteConverter(numberFormat, |
| 449 fromType, false)); | |
| 450 } | |
| 451 } | |
| 452 } | |
| 453 | |
| 454 /** | |
| 455 * Registers converters to boxed and unboxed types from a list of from | |
| 456 * classes. | |
| 457 * | |
| 458 * @param map | |
| 459 * @param numberFormat | |
| 460 * @param fromTypes | |
| 461 */ | |
| 462 private static void addNumberToShortConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
463 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 464 for (int i = 0; i < fromTypes.length; i++) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
465 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
466 if (fromType != Class.fromType!(Short) && fromType != Short.TYPE) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
467 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
468 fromType, null) : fromType.getName(); |
| 78 | 469 |
| 470 map | |
| 471 .put(new Pair(fromName, SHORT_TYPE), | |
| 472 new NumberToShortConverter(numberFormat, | |
| 473 fromType, true)); | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
474 map.put(new Pair(fromName, Class.fromType!(Short).getName()), |
| 78 | 475 new NumberToShortConverter(numberFormat, fromType, |
| 476 false)); | |
| 477 } | |
| 478 } | |
| 479 } | |
| 480 | |
| 481 /** | |
| 482 * Registers converters to boxed and unboxed types from a list of from | |
| 483 * classes. | |
| 484 * | |
| 485 * @param map | |
| 486 * @param numberFormat | |
| 487 * @param fromTypes | |
| 488 */ | |
| 489 private static void addNumberToIntegerConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
490 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 491 for (int i = 0; i < fromTypes.length; i++) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
492 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
493 if (fromType != Class.fromType!(Integer) |
| 85 | 494 && fromType != Integer.TYPE) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
495 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
496 fromType, null) : fromType.getName(); |
| 78 | 497 |
| 498 map.put(new Pair(fromName, INTEGER_TYPE), | |
| 499 new NumberToIntegerConverter(numberFormat, fromType, | |
| 500 true)); | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
501 map.put(new Pair(fromName, Class.fromType!(Integer).getName()), |
| 78 | 502 new NumberToIntegerConverter(numberFormat, fromType, |
| 503 false)); | |
| 504 } | |
| 505 } | |
| 506 } | |
| 507 | |
| 508 /** | |
| 509 * Registers converters to boxed and unboxed types from a list of from | |
| 510 * classes. | |
| 511 * | |
| 512 * @param map | |
| 513 * @param numberFormat | |
| 514 * @param fromTypes | |
| 515 */ | |
| 516 private static void addNumberToLongConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
517 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 518 for (int i = 0; i < fromTypes.length; i++) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
519 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
520 if (fromType != Class.fromType!(Long) && fromType != Long.TYPE) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
521 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
522 fromType, null) : fromType.getName(); |
| 78 | 523 |
| 524 map | |
| 525 .put(new Pair(fromName, LONG_TYPE), | |
| 526 new NumberToLongConverter(numberFormat, | |
| 527 fromType, true)); | |
| 528 map | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
529 .put(new Pair(fromName, Class.fromType!(Long).getName()), |
| 78 | 530 new NumberToLongConverter(numberFormat, |
| 531 fromType, false)); | |
| 532 } | |
| 533 } | |
| 534 } | |
| 535 | |
| 536 /** | |
| 537 * Registers converters to boxed and unboxed types from a list of from | |
| 538 * classes. | |
| 539 * | |
| 540 * @param map | |
| 541 * @param numberFormat | |
| 542 * @param fromTypes | |
| 543 */ | |
| 544 private static void addNumberToFloatConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
545 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 546 for (int i = 0; i < fromTypes.length; i++) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
547 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
548 if (fromType != Class.fromType!(Float) && fromType != Float.TYPE) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
549 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
550 fromType, null) : fromType.getName(); |
| 78 | 551 |
| 552 map | |
| 553 .put(new Pair(fromName, FLOAT_TYPE), | |
| 554 new NumberToFloatConverter(numberFormat, | |
| 555 fromType, true)); | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
556 map.put(new Pair(fromName, Class.fromType!(Float).getName()), |
| 78 | 557 new NumberToFloatConverter(numberFormat, fromType, |
| 558 false)); | |
| 559 } | |
| 560 } | |
| 561 } | |
| 562 | |
| 563 /** | |
| 564 * Registers converters to boxed and unboxed types from a list of from | |
| 565 * classes. | |
| 566 * | |
| 567 * @param map | |
| 568 * @param numberFormat | |
| 569 * @param fromTypes | |
| 570 */ | |
| 571 private static void addNumberToDoubleConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
572 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 573 for (int i = 0; i < fromTypes.length; i++) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
574 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
575 if (fromType != Class.fromType!(Double) && fromType != Double.TYPE) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
576 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
577 fromType, null) : fromType.getName(); |
| 78 | 578 |
| 579 map.put(new Pair(fromName, DOUBLE_TYPE), | |
| 580 new NumberToDoubleConverter(numberFormat, fromType, | |
| 581 true)); | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
582 map.put(new Pair(fromName, Class.fromType!(Double).getName()), |
| 78 | 583 new NumberToDoubleConverter(numberFormat, fromType, |
| 584 false)); | |
| 585 } | |
| 586 } | |
| 587 } | |
| 588 | |
| 589 /** | |
| 590 * Registers converters to boxed and unboxed types from a list of from | |
| 591 * classes. | |
| 592 * | |
| 593 * @param map | |
| 594 * @param numberFormat | |
| 595 * @param fromTypes | |
| 596 */ | |
| 597 private static void addNumberToBigIntegerConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
598 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 599 for (int i = 0; i < fromTypes.length; i++) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
600 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
601 if (!fromType.opEquals(Class.fromType!(BigInteger))) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
602 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
603 fromType, null) : fromType.getName(); |
| 78 | 604 |
| 605 map | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
606 .put(new Pair(fromName, Class.fromType!(BigInteger).getName()), |
| 78 | 607 new NumberToBigIntegerConverter(numberFormat, |
| 608 fromType)); | |
| 609 } | |
| 610 } | |
| 611 } | |
| 612 | |
| 613 /** | |
| 614 * Registers converters to boxed and unboxed types from a list of from | |
| 615 * classes. | |
| 616 * | |
| 617 * @param map | |
| 618 * @param numberFormat | |
| 619 * @param fromTypes | |
| 620 */ | |
| 621 private static void addNumberToBigDecimalConverters(Map map, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
622 NumberFormat numberFormat, Class[] fromTypes) { |
| 78 | 623 for (int i = 0; i < fromTypes.length; i++) { |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
624 Class fromType = fromTypes[i]; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
625 if (!fromType.opEquals(Class.fromType!(BigDecimal))) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
626 String fromName = fromType.isPrimitive() ? getKeyForClass( |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
627 fromType, null) : fromType.getName(); |
| 78 | 628 |
| 629 map | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
630 .put(new Pair(fromName, Class.fromType!(BigDecimal).getName()), |
| 78 | 631 new NumberToBigDecimalConverter(numberFormat, |
| 632 fromType)); | |
| 633 } | |
| 634 } | |
| 635 } | |
| 636 | |
| 637 private static String getKeyForClass(Object originalValue, | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
638 Class filteredValue) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
639 if ( null !is cast(Class)originalValue ) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
640 Class originalClass = cast(Class) originalValue; |
| 85 | 641 if (originalClass == Integer.TYPE) { |
| 78 | 642 return INTEGER_TYPE; |
| 85 | 643 } else if (originalClass == Byte.TYPE) { |
| 78 | 644 return BYTE_TYPE; |
| 85 | 645 } else if (originalClass == Boolean.TYPE) { |
| 78 | 646 return BOOLEAN_TYPE; |
| 85 | 647 } else if (originalClass == Double.TYPE) { |
| 78 | 648 return DOUBLE_TYPE; |
| 85 | 649 } else if (originalClass == Float.TYPE) { |
| 78 | 650 return FLOAT_TYPE; |
| 85 | 651 } else if (originalClass == Long.TYPE) { |
| 78 | 652 return LONG_TYPE; |
| 85 | 653 } else if (originalClass == Short.TYPE) { |
| 78 | 654 return SHORT_TYPE; |
| 655 } | |
| 656 } | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
657 return filteredValue.getName(); |
| 78 | 658 } |
| 659 | |
| 660 /** | |
| 661 * Returns {@link Boolean#TRUE} if the from type is assignable to the to | |
| 662 * type, or {@link Boolean#FALSE} if it not, or <code>null</code> if | |
| 663 * unknown. | |
| 664 * | |
| 665 * @param fromType | |
| 666 * @param toType | |
| 667 * @return whether fromType is assignable to toType, or <code>null</code> | |
| 668 * if unknown | |
| 669 */ | |
| 670 protected Boolean isAssignableFromTo(Object fromType, Object toType) { | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
671 if ( null !is cast(Class)fromType && null !is cast(Class)toType ) { |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
672 Class toClass = cast(Class) toType; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
673 if (toClass.isPrimitive()) { |
| 78 | 674 toClass = autoboxed(toClass); |
| 675 } | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
676 Class fromClass = cast(Class) fromType; |
|
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
677 if (fromClass.isPrimitive()) { |
| 78 | 678 fromClass = autoboxed(fromClass); |
| 679 } | |
|
88
9e0ab372d5d8
Revert from TypeInfo/ClassInfo to java.lang.Class
Frank Benoit <benoit@tionex.de>
parents:
85
diff
changeset
|
680 return toClass.isAssignableFrom(fromClass) ? Boolean.TRUE |
| 78 | 681 : Boolean.FALSE; |
| 682 } | |
| 683 return null; | |
| 684 } | |
| 685 | |
| 686 /* | |
| 687 * Default converter implementation, does not perform any conversion. | |
| 688 */ | |
| 689 protected static final class DefaultConverter : IConverter { | |
| 690 | |
| 691 private final Object toType; | |
| 692 | |
| 693 private final Object fromType; | |
| 694 | |
| 695 /** | |
| 696 * @param fromType | |
| 697 * @param toType | |
| 698 */ | |
| 699 this(Object fromType, Object toType) { | |
| 700 this.toType = toType; | |
| 701 this.fromType = fromType; | |
| 702 } | |
| 703 | |
| 704 public Object convert(Object fromObject) { | |
| 705 return fromObject; | |
| 706 } | |
| 707 | |
| 708 public Object getFromType() { | |
| 709 return fromType; | |
| 710 } | |
| 711 | |
| 712 public Object getToType() { | |
| 713 return toType; | |
| 714 } | |
| 715 } | |
| 716 | |
| 717 } |