bundles/org.simantics.utils.datastructures/src/org/simantics/utils/datastructures/ValueUtils.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.utils.datastructures;\r
  13 \r
  14 import java.io.DataInput;\r
  15 import java.io.DataOutput;\r
  16 import java.io.IOException;\r
  17 import java.lang.reflect.Array;\r
  18 import java.security.InvalidParameterException;\r
  19 import java.util.Arrays;\r
  20 import java.util.Calendar;\r
  21 \r
  22 /**\r
  23  * Object type casting tools.\r
  24  * \r
  25  * @author Toni Kalajainen\r
  26  * @author Hannu Niemist&ouml;\r
  27  */\r
  28 public class ValueUtils {\r
  29 \r
  30     /**\r
  31      * Convert double value to a number class.\r
  32      * \r
  33      * @param value\r
  34      * @param numberClass\r
  35      * @return\r
  36      * @throws ClassCastException\r
  37      */\r
  38     public static Number doubleToNumberClass(double value, Class<? extends Number> numberClass)\r
  39     throws ClassCastException\r
  40     {\r
  41         if (numberClass==Integer.class)\r
  42             return (int)value;\r
  43         if (numberClass==Byte.class)\r
  44             return (byte)value;\r
  45         if (numberClass==Float.class)\r
  46             return (float)value;\r
  47         if (numberClass==Short.class)\r
  48             return (short)value;\r
  49         if (numberClass==Long.class)\r
  50             return (long)value;\r
  51         if (numberClass==Double.class)\r
  52             return (double)value;\r
  53         throw new ClassCastException("Cannot convert to "+numberClass.getName());\r
  54     }\r
  55 \r
  56     /**\r
  57      * Possible object types:\r
  58      * \r
  59      */\r
  60 \r
  61     static final Boolean True = new Boolean(true);\r
  62     static final Boolean False = new Boolean(false);\r
  63 \r
  64     public static void serialize(DataOutput stream, Object obj) throws IOException {\r
  65         try {\r
  66             Class<?> clazz = obj.getClass();\r
  67             if(clazz.isArray()) {\r
  68                 if(obj instanceof double[]) {\r
  69                     double[] array = (double[])obj;\r
  70                     stream.writeByte(16);\r
  71                     stream.writeInt(array.length);\r
  72                     for(double v : array)\r
  73                         stream.writeDouble(v);\r
  74                 }\r
  75                 else if(obj instanceof float[]) {\r
  76                     float[] array = (float[])obj;\r
  77                     stream.writeByte(15);\r
  78                     stream.writeInt(array.length);\r
  79                     for(float v : array)\r
  80                         stream.writeFloat(v);\r
  81                 }\r
  82                 else if(obj instanceof int[]) {\r
  83                     int[] array = (int[])obj;\r
  84                     stream.writeByte(13);\r
  85                     stream.writeInt(array.length);\r
  86                     for(int v : array)\r
  87                         stream.writeInt(v);\r
  88                 }\r
  89                 else if(obj instanceof String[]) {\r
  90                     String[] array = (String[])obj;\r
  91                     stream.writeByte(17);\r
  92                     stream.writeInt(array.length);\r
  93                     for(String v : array)\r
  94                         stream.writeUTF(v);\r
  95                 }\r
  96                 else if(obj instanceof boolean[]) {\r
  97                     boolean[] array = (boolean[])obj;\r
  98                     stream.writeByte(11);\r
  99                     stream.writeInt(array.length);\r
 100                     for(boolean v : array)\r
 101                         stream.writeByte(v ? (byte)1 : (byte)0);\r
 102                 }\r
 103                 else if(obj instanceof byte[]) {\r
 104                     byte[] array = (byte[])obj;\r
 105                     stream.writeByte(12);\r
 106                     stream.writeInt(array.length);\r
 107                     for(byte v : array)\r
 108                         stream.writeByte(v);\r
 109                 }\r
 110                 else if(obj instanceof long[]) {\r
 111                     long[] array = (long[])obj;\r
 112                     stream.writeByte(14);\r
 113                     stream.writeInt(array.length);\r
 114                     for(long v : array)\r
 115                         stream.writeLong(v);\r
 116                 }\r
 117                 else {\r
 118                     System.out.println("ValueUtils.serialize failed (invalid type).");\r
 119                     throw new InvalidParameterException();\r
 120                 }\r
 121             }\r
 122             else {\r
 123                 if(clazz == Double.class) {\r
 124                     stream.writeByte(6);\r
 125                     stream.writeDouble((Double)obj);\r
 126                 }\r
 127                 else if(clazz == Float.class) {\r
 128                     stream.writeByte(5);\r
 129                     stream.writeDouble((Float)obj);\r
 130                 }\r
 131                 else if(clazz == Integer.class) {\r
 132                     stream.writeByte(3);\r
 133                     stream.writeInt((Integer)obj);\r
 134                 }\r
 135                 else if(clazz == String.class) {\r
 136                     stream.writeByte(7);\r
 137                     stream.writeUTF((String)obj);\r
 138                 }\r
 139                 else if(clazz == Boolean.class) {\r
 140                     stream.writeByte((Boolean)obj ? 1 : 0);\r
 141                 }\r
 142                 else if(clazz == Byte.class) {\r
 143                     stream.writeByte(2);\r
 144                     stream.writeByte((Byte)obj);\r
 145                 }\r
 146                 else if(clazz == Long.class) {\r
 147                     stream.writeByte(4);\r
 148                     stream.writeLong((Long)obj);\r
 149                 }\r
 150                 else {\r
 151                     System.out.println("ValueUtils.serialize failed (invalid type).");\r
 152                     throw new InvalidParameterException();\r
 153                 }\r
 154             }\r
 155         } catch(IOException e) {\r
 156             System.out.println("ValueUtils.serialize failed (write failure).");\r
 157             e.printStackTrace();\r
 158             throw e;\r
 159         }\r
 160     }\r
 161 \r
 162     public static Object deserialize(DataInput stream) throws IOException {\r
 163         try {\r
 164             byte typeCode = stream.readByte();\r
 165             switch(typeCode) {\r
 166                 case 0: return False;\r
 167                 case 1: return True;\r
 168                 case 2: return stream.readByte();\r
 169                 case 3: return stream.readInt();\r
 170                 case 4: return stream.readLong();\r
 171                 case 5: return stream.readFloat();\r
 172                 case 6: return stream.readDouble();\r
 173                 case 7: return stream.readUTF();\r
 174 \r
 175                 case 11: {\r
 176                     int length = stream.readInt();\r
 177                     boolean[] value = new boolean[length];\r
 178                     for(int i=0;i<length;++i)\r
 179                         value[i] = stream.readByte() != 0;\r
 180                     return value;\r
 181                 }\r
 182                 case 12: {\r
 183                     int length = stream.readInt();\r
 184                     byte[] value = new byte[length];\r
 185                     for(int i=0;i<length;++i)\r
 186                         value[i] = stream.readByte();\r
 187                     return value;\r
 188                 }\r
 189                 case 13: {\r
 190                     int length = stream.readInt();\r
 191                     int[] value = new int[length];\r
 192                     for(int i=0;i<length;++i)\r
 193                         value[i] = stream.readInt();\r
 194                     return value;\r
 195                 }\r
 196                 case 14: {\r
 197                     int length = stream.readInt();\r
 198                     long[] value = new long[length];\r
 199                     for(int i=0;i<length;++i)\r
 200                         value[i] = stream.readLong();\r
 201                     return value;\r
 202                 }\r
 203                 case 15: {\r
 204                     int length = stream.readInt();\r
 205                     float[] value = new float[length];\r
 206                     for(int i=0;i<length;++i)\r
 207                         value[i] = stream.readFloat();\r
 208                     return value;\r
 209                 }\r
 210                 case 16: {\r
 211                     int length = stream.readInt();\r
 212                     double[] value = new double[length];\r
 213                     for(int i=0;i<length;++i)\r
 214                         value[i] = stream.readDouble();\r
 215                     return value;\r
 216                 }\r
 217                 case 17: {\r
 218                     int length = stream.readInt();\r
 219                     String[] value = new String[length];\r
 220                     for(int i=0;i<length;++i)\r
 221                         value[i] = stream.readUTF();\r
 222                     return value;\r
 223                 }\r
 224 \r
 225             }\r
 226 \r
 227             System.out.println("ValueUtils.deserialize failed (invalid type code).");\r
 228             throw new IOException("Invalid value data.");\r
 229         } catch(IOException e) {\r
 230             System.out.println("ValueUtils.deserialize failed (reading failure).");\r
 231             e.printStackTrace();\r
 232             throw e;\r
 233         }\r
 234     }\r
 235 \r
 236 \r
 237 \r
 238 \r
 239 \r
 240 \r
 241     /**\r
 242      * is object an array type\r
 243      * @param obj the object\r
 244      * @return true if it is object array (Integer[], Short[], ect)\r
 245      */\r
 246     public static boolean isArray(Object obj) {\r
 247         return obj.getClass().isArray();\r
 248     }\r
 249 \r
 250     /**\r
 251      * Get the array length\r
 252      * @param obj object\r
 253      * @return the length\r
 254      */\r
 255     public static int getArrayLength(Object obj) {\r
 256         return Array.getLength(obj);\r
 257     }\r
 258 \r
 259     /**\r
 260      * Type casts an array to double.\r
 261      * \r
 262      * String types are attempted to be converted. If string\r
 263      * doesn't represent numeric value, 0 will be returned\r
 264      * \r
 265      * boolean types return 0/1, for false/true respectively\r
 266      * \r
 267      * @return type casted value\r
 268      */\r
 269     public static double[] toDoubleArray(Object obj)\r
 270     throws TypeCastException\r
 271     {\r
 272         if (!isArray(obj)) {\r
 273             double scalar = toDoubleScalar(obj);\r
 274             return new double[] {scalar};\r
 275         }\r
 276         int len = getArrayLength(obj);\r
 277         double[] result = new double[len];\r
 278         // TODO add support for int[] double[] float[], ect..\r
 279         if (obj instanceof Calendar[])\r
 280         {\r
 281             Calendar[] array = (Calendar[]) obj;\r
 282             for (int i=0; i<len; i++)\r
 283                 result[i] = array[i].getTimeInMillis();\r
 284             return result;\r
 285         }\r
 286         if (obj instanceof Integer[])\r
 287         {\r
 288             Integer[] array = (Integer[]) obj;\r
 289             for (int i=0; i<len; i++)\r
 290                 result[i] = array[i].doubleValue();\r
 291             return result;\r
 292         }\r
 293         if (obj instanceof int[])\r
 294         {\r
 295             int[] array = (int[]) obj;\r
 296             for (int i=0; i<len; i++)\r
 297                 result[i] = array[i];\r
 298             return result;\r
 299         }\r
 300         if (obj instanceof Double[])\r
 301         {\r
 302             Double[] array = (Double[]) obj;\r
 303             for (int i=0; i<len; i++)\r
 304                 result[i] = array[i].doubleValue();\r
 305             return result;\r
 306         }\r
 307         if (obj instanceof double[])\r
 308         {\r
 309             return (double[])obj;\r
 310         }\r
 311         if (obj instanceof Float[])\r
 312         {\r
 313             Float[] array = (Float[]) obj;\r
 314             for (int i=0; i<len; i++)\r
 315                 result[i] = array[i].doubleValue();\r
 316             return result;\r
 317         }\r
 318         if (obj instanceof float[])\r
 319         {\r
 320             float[] array = (float[]) obj;\r
 321             for (int i=0; i<len; i++)\r
 322                 result[i] = array[i];\r
 323             return result;\r
 324         }\r
 325         if (obj instanceof Long[])\r
 326         {\r
 327             Long[] array = (Long[]) obj;\r
 328             for (int i=0; i<len; i++)\r
 329                 result[i] = array[i].doubleValue();\r
 330             return result;\r
 331         }\r
 332         if (obj instanceof long[])\r
 333         {\r
 334             long[] array = (long[]) obj;\r
 335             for (int i=0; i<len; i++)\r
 336                 result[i] = array[i];\r
 337             return result;\r
 338         }\r
 339         if (obj instanceof Short[])\r
 340         {\r
 341             Short[] array = (Short[]) obj;\r
 342             for (int i=0; i<len; i++)\r
 343                 result[i] = array[i].doubleValue();\r
 344             return result;\r
 345         }\r
 346         if (obj instanceof short[])\r
 347         {\r
 348             short[] array = (short[]) obj;\r
 349             for (int i=0; i<len; i++)\r
 350                 result[i] = array[i];\r
 351             return result;\r
 352         }\r
 353         if (obj instanceof Byte[])\r
 354         {\r
 355             Byte[] array = (Byte[]) obj;\r
 356             for (int i=0; i<len; i++)\r
 357                 result[i] = array[i].doubleValue();\r
 358             return result;\r
 359         }\r
 360         if (obj instanceof byte[])\r
 361         {\r
 362             byte[] array = (byte[]) obj;\r
 363             for (int i=0; i<len; i++)\r
 364                 result[i] = array[i];\r
 365             return result;\r
 366         }\r
 367         if (obj instanceof String[])\r
 368         {\r
 369             String[] array = (String[]) obj;\r
 370             for (int i=0; i<len; i++)\r
 371                 try {\r
 372                     result[i] = new Double(array[i]);\r
 373                 } catch (NumberFormatException e) {\r
 374                     throw new TypeCastException(obj.getClass());\r
 375                 }\r
 376                 return result;\r
 377         }\r
 378         if (obj instanceof Boolean[])\r
 379         {\r
 380             Boolean[] array = (Boolean[]) obj;\r
 381             for (int i=0; i<len; i++)\r
 382                 result[i] = (array[i].booleanValue()?1:0);\r
 383             return result;\r
 384         }\r
 385         if (obj instanceof boolean[])\r
 386         {\r
 387             boolean[] array = (boolean[]) obj;\r
 388             for (int i=0; i<len; i++)\r
 389                 result[i] = (array[i]?1:0);\r
 390             return result;\r
 391         }\r
 392         throw new TypeCastException(obj.getClass());\r
 393     }\r
 394 \r
 395     /**\r
 396      * Type casts an object to long.\r
 397      * \r
 398      * String types are attempted to be converted. If string\r
 399      * doesn't represent numeric value, 0 will be returned\r
 400      * \r
 401      * boolean types return 0/1, for false/true respectively\r
 402      * \r
 403      * @return type casted value\r
 404      */\r
 405     public static double toDoubleScalar(Object obj)\r
 406     throws TypeCastException\r
 407     {\r
 408         if (!isArray(obj)) {\r
 409             if (obj instanceof Number)\r
 410                 return ((Number)obj).doubleValue();\r
 411             if (obj instanceof Calendar)\r
 412                 return ((Calendar) obj).getTimeInMillis();\r
 413             if (obj instanceof String)\r
 414             {\r
 415                 String str = (String) obj;\r
 416                 try {\r
 417                     Double d = new Double(str);\r
 418                     return d.doubleValue();\r
 419                 } catch (NumberFormatException e) {\r
 420                     throw new TypeCastException(obj.getClass());\r
 421                 }\r
 422             }\r
 423             if (obj instanceof Boolean) {\r
 424                 return (((Boolean)obj).booleanValue())?1:0;\r
 425             }\r
 426             throw new TypeCastException(obj.getClass());\r
 427         }\r
 428         int len = getArrayLength(obj);\r
 429         if (len!=1)\r
 430             throw new TypeCastException("Expected length of array is 1");\r
 431 \r
 432         if (obj instanceof double[])\r
 433         {\r
 434             return ((double[])obj)[0];\r
 435         }\r
 436         if (obj instanceof int[])\r
 437         {\r
 438             int[] array = (int[]) obj;\r
 439             return array[0];\r
 440         }\r
 441         if (obj instanceof Calendar[])\r
 442         {\r
 443             Calendar[] array = (Calendar[]) obj;\r
 444             return array[0].getTimeInMillis();\r
 445         }\r
 446         if (obj instanceof Integer[])\r
 447         {\r
 448             Integer[] array = (Integer[]) obj;\r
 449             return array[0].doubleValue();\r
 450         }\r
 451         if (obj instanceof Double[])\r
 452         {\r
 453             Double[] array = (Double[]) obj;\r
 454             return array[0].doubleValue();\r
 455         }\r
 456         if (obj instanceof Float[])\r
 457         {\r
 458             Float[] array = (Float[]) obj;\r
 459             return array[0].doubleValue();\r
 460         }\r
 461         if (obj instanceof float[])\r
 462         {\r
 463             float[] array = (float[]) obj;\r
 464             return array[0];\r
 465         }\r
 466         if (obj instanceof Long[])\r
 467         {\r
 468             Long[] array = (Long[]) obj;\r
 469             return array[0].doubleValue();\r
 470         }\r
 471         if (obj instanceof long[])\r
 472         {\r
 473             long[] array = (long[]) obj;\r
 474             return array[0];\r
 475         }\r
 476         if (obj instanceof Short[])\r
 477         {\r
 478             Short[] array = (Short[]) obj;\r
 479             return array[0].doubleValue();\r
 480         }\r
 481         if (obj instanceof short[])\r
 482         {\r
 483             short[] array = (short[]) obj;\r
 484             return array[0];\r
 485         }\r
 486         if (obj instanceof Byte[])\r
 487         {\r
 488             Byte[] array = (Byte[]) obj;\r
 489             return array[0].doubleValue();\r
 490         }\r
 491         if (obj instanceof byte[])\r
 492         {\r
 493             byte[] array = (byte[]) obj;\r
 494             return array[0];\r
 495         }\r
 496         if (obj instanceof String[])\r
 497         {\r
 498             String[] array = (String[]) obj;\r
 499             try {\r
 500                 return new Double(array[0]);\r
 501             } catch (NumberFormatException e) {\r
 502                 throw new TypeCastException(obj.getClass());\r
 503             }\r
 504         }\r
 505         if (obj instanceof Boolean[])\r
 506         {\r
 507             Boolean[] array = (Boolean[]) obj;\r
 508             return (array[0].booleanValue()?1:0);\r
 509         }\r
 510         if (obj instanceof boolean[])\r
 511         {\r
 512             boolean[] array = (boolean[]) obj;\r
 513             return (array[0]?1:0);\r
 514         }\r
 515         throw new TypeCastException(obj.getClass());\r
 516     }\r
 517 \r
 518 \r
 519     /**\r
 520      * Type casts an array to float.\r
 521      * \r
 522      * String types are attempted to be converted. If string\r
 523      * doesn't represent numeric value, 0 will be returned\r
 524      * \r
 525      * boolean types return 0/1, for false/true respectively\r
 526      * \r
 527      * @return type casted value\r
 528      */\r
 529     public static float[] toFloatArray(Object obj)\r
 530     throws TypeCastException\r
 531     {\r
 532         if (!isArray(obj)) {\r
 533             float scalar = toFloatScalar(obj);\r
 534             return new float[] {scalar};\r
 535         }\r
 536         int len = getArrayLength(obj);\r
 537         float[] result = new float[len];\r
 538         // TODO add support for int[] float[] float[], ect..\r
 539         if (obj instanceof Calendar[])\r
 540         {\r
 541             Calendar[] array = (Calendar[]) obj;\r
 542             for (int i=0; i<len; i++)\r
 543                 result[i] = array[i].getTimeInMillis();\r
 544             return result;\r
 545         }\r
 546         if (obj instanceof Integer[])\r
 547         {\r
 548             Integer[] array = (Integer[]) obj;\r
 549             for (int i=0; i<len; i++)\r
 550                 result[i] = array[i].floatValue();\r
 551             return result;\r
 552         }\r
 553         if (obj instanceof int[])\r
 554         {\r
 555             int[] array = (int[]) obj;\r
 556             for (int i=0; i<len; i++)\r
 557                 result[i] = array[i];\r
 558             return result;\r
 559         }\r
 560         if (obj instanceof Float[])\r
 561         {\r
 562             Float[] array = (Float[]) obj;\r
 563             for (int i=0; i<len; i++)\r
 564                 result[i] = array[i].floatValue();\r
 565             return result;\r
 566         }\r
 567         if (obj instanceof float[])\r
 568         {\r
 569             return (float[])obj;\r
 570         }\r
 571         if (obj instanceof Double[])\r
 572         {\r
 573             Double[] array = (Double[]) obj;\r
 574             for (int i=0; i<len; i++)\r
 575                 result[i] = array[i].floatValue();\r
 576             return result;\r
 577         }\r
 578         if (obj instanceof double[])\r
 579         {\r
 580             double[] array = (double[]) obj;\r
 581             for (int i=0; i<len; i++)\r
 582                 result[i] = (float)array[i];\r
 583             return result;\r
 584         }\r
 585         if (obj instanceof Long[])\r
 586         {\r
 587             Long[] array = (Long[]) obj;\r
 588             for (int i=0; i<len; i++)\r
 589                 result[i] = array[i].floatValue();\r
 590             return result;\r
 591         }\r
 592         if (obj instanceof long[])\r
 593         {\r
 594             long[] array = (long[]) obj;\r
 595             for (int i=0; i<len; i++)\r
 596                 result[i] = array[i];\r
 597             return result;\r
 598         }\r
 599         if (obj instanceof Short[])\r
 600         {\r
 601             Short[] array = (Short[]) obj;\r
 602             for (int i=0; i<len; i++)\r
 603                 result[i] = array[i].floatValue();\r
 604             return result;\r
 605         }\r
 606         if (obj instanceof short[])\r
 607         {\r
 608             short[] array = (short[]) obj;\r
 609             for (int i=0; i<len; i++)\r
 610                 result[i] = array[i];\r
 611             return result;\r
 612         }\r
 613         if (obj instanceof Byte[])\r
 614         {\r
 615             Byte[] array = (Byte[]) obj;\r
 616             for (int i=0; i<len; i++)\r
 617                 result[i] = array[i].floatValue();\r
 618             return result;\r
 619         }\r
 620         if (obj instanceof byte[])\r
 621         {\r
 622             byte[] array = (byte[]) obj;\r
 623             for (int i=0; i<len; i++)\r
 624                 result[i] = array[i];\r
 625             return result;\r
 626         }\r
 627         if (obj instanceof String[])\r
 628         {\r
 629             String[] array = (String[]) obj;\r
 630             for (int i=0; i<len; i++)\r
 631                 try {\r
 632                     result[i] = new Float(array[i]);\r
 633                 } catch (NumberFormatException e) {\r
 634                     throw new TypeCastException(obj.getClass());\r
 635                 }\r
 636                 return result;\r
 637         }\r
 638         if (obj instanceof Boolean[])\r
 639         {\r
 640             Boolean[] array = (Boolean[]) obj;\r
 641             for (int i=0; i<len; i++)\r
 642                 result[i] = (array[i].booleanValue()?1:0);\r
 643             return result;\r
 644         }\r
 645         if (obj instanceof boolean[])\r
 646         {\r
 647             boolean[] array = (boolean[]) obj;\r
 648             for (int i=0; i<len; i++)\r
 649                 result[i] = (array[i]?1:0);\r
 650             return result;\r
 651         }\r
 652         throw new TypeCastException(obj.getClass());\r
 653     }\r
 654 \r
 655     /**\r
 656      * Type casts an object to float.\r
 657      * \r
 658      * String types are attempted to be converted. If string\r
 659      * doesn't represent numeric value, 0 will be returned\r
 660      * \r
 661      * boolean types return 0/1, for false/true respectively\r
 662      * \r
 663      * @return type casted value\r
 664      */\r
 665     public static float toFloatScalar(Object obj)\r
 666     throws TypeCastException\r
 667     {\r
 668         if (!isArray(obj)) {\r
 669             if (obj instanceof Number)\r
 670                 return ((Number)obj).floatValue();\r
 671             if (obj instanceof Calendar)\r
 672                 return ((Calendar) obj).getTimeInMillis();\r
 673             if (obj instanceof String)\r
 674             {\r
 675                 String str = (String) obj;\r
 676                 try {\r
 677                     Float d = new Float(str);\r
 678                     return d.floatValue();\r
 679                 } catch (NumberFormatException e) {\r
 680                     throw new TypeCastException(obj.getClass());\r
 681                 }\r
 682             }\r
 683             if (obj instanceof Boolean) {\r
 684                 return (((Boolean)obj).booleanValue())?1:0;\r
 685             }\r
 686             throw new TypeCastException(obj.getClass());\r
 687         }\r
 688         int len = getArrayLength(obj);\r
 689         if (len!=1)\r
 690             throw new TypeCastException("Expected length of array is 1");\r
 691 \r
 692         if (obj instanceof float[])\r
 693         {\r
 694             return ((float[])obj)[0];\r
 695         }\r
 696         if (obj instanceof int[])\r
 697         {\r
 698             int[] array = (int[]) obj;\r
 699             return array[0];\r
 700         }\r
 701         if (obj instanceof Calendar[])\r
 702         {\r
 703             Calendar[] array = (Calendar[]) obj;\r
 704             return array[0].getTimeInMillis();\r
 705         }\r
 706         if (obj instanceof Integer[])\r
 707         {\r
 708             Integer[] array = (Integer[]) obj;\r
 709             return array[0].floatValue();\r
 710         }\r
 711         if (obj instanceof Float[])\r
 712         {\r
 713             Float[] array = (Float[]) obj;\r
 714             return array[0].floatValue();\r
 715         }\r
 716         if (obj instanceof Float[])\r
 717         {\r
 718             Float[] array = (Float[]) obj;\r
 719             return array[0].floatValue();\r
 720         }\r
 721         if (obj instanceof double[])\r
 722         {\r
 723             double[] array = (double[]) obj;\r
 724             return (float)array[0];\r
 725         }\r
 726         if (obj instanceof Long[])\r
 727         {\r
 728             Long[] array = (Long[]) obj;\r
 729             return array[0].floatValue();\r
 730         }\r
 731         if (obj instanceof long[])\r
 732         {\r
 733             long[] array = (long[]) obj;\r
 734             return array[0];\r
 735         }\r
 736         if (obj instanceof Short[])\r
 737         {\r
 738             Short[] array = (Short[]) obj;\r
 739             return array[0].floatValue();\r
 740         }\r
 741         if (obj instanceof short[])\r
 742         {\r
 743             short[] array = (short[]) obj;\r
 744             return array[0];\r
 745         }\r
 746         if (obj instanceof Byte[])\r
 747         {\r
 748             Byte[] array = (Byte[]) obj;\r
 749             return array[0].floatValue();\r
 750         }\r
 751         if (obj instanceof byte[])\r
 752         {\r
 753             byte[] array = (byte[]) obj;\r
 754             return array[0];\r
 755         }\r
 756         if (obj instanceof String[])\r
 757         {\r
 758             String[] array = (String[]) obj;\r
 759             try {\r
 760                 return new Float(array[0]);\r
 761             } catch (NumberFormatException e) {\r
 762                 throw new TypeCastException(obj.getClass());\r
 763             }\r
 764         }\r
 765         if (obj instanceof Boolean[])\r
 766         {\r
 767             Boolean[] array = (Boolean[]) obj;\r
 768             return (array[0].booleanValue()?1:0);\r
 769         }\r
 770         if (obj instanceof boolean[])\r
 771         {\r
 772             boolean[] array = (boolean[]) obj;\r
 773             return (array[0]?1:0);\r
 774         }\r
 775         throw new TypeCastException(obj.getClass());\r
 776     }\r
 777 \r
 778 \r
 779     /**\r
 780      * Type casts an object to long.\r
 781      * \r
 782      * String types are attempted to be converted. If string\r
 783      * doesn't represent numeric value, 0 will be returned\r
 784      * \r
 785      * boolean types return 0/1, for false/true respectively\r
 786      * \r
 787      * @return type casted value\r
 788      */\r
 789     public static long toLongScalar(Object obj)\r
 790     throws TypeCastException\r
 791     {\r
 792         if (!isArray(obj)) {\r
 793             if (obj instanceof Number)\r
 794                 return ((Number)obj).longValue();\r
 795             if (obj instanceof Calendar)\r
 796                 return ((Calendar) obj).getTimeInMillis();\r
 797             if (obj instanceof String)\r
 798             {\r
 799                 String str = (String) obj;\r
 800                 try {\r
 801                     Long d = new Long(str);\r
 802                     return d.longValue();\r
 803                 } catch (NumberFormatException e) {\r
 804                     throw new TypeCastException(obj.getClass());\r
 805                 }\r
 806             }\r
 807             if (obj instanceof Boolean) {\r
 808                 return (((Boolean)obj).booleanValue())?1:0;\r
 809             }\r
 810             throw new TypeCastException(obj.getClass());\r
 811         }\r
 812         int len = getArrayLength(obj);\r
 813         if (len!=1)\r
 814             throw new TypeCastException("Expected length of array is 1");\r
 815 \r
 816         if (obj instanceof double[])\r
 817         {\r
 818             return ((long[])obj)[0];\r
 819         }\r
 820         if (obj instanceof int[])\r
 821         {\r
 822             int[] array = (int[]) obj;\r
 823             return array[0];\r
 824         }\r
 825         if (obj instanceof Calendar[])\r
 826         {\r
 827             Calendar[] array = (Calendar[]) obj;\r
 828             return array[0].getTimeInMillis();\r
 829         }\r
 830         if (obj instanceof Integer[])\r
 831         {\r
 832             Integer[] array = (Integer[]) obj;\r
 833             return array[0].longValue();\r
 834         }\r
 835         if (obj instanceof Double[])\r
 836         {\r
 837             Double[] array = (Double[]) obj;\r
 838             return array[0].longValue();\r
 839         }\r
 840         if (obj instanceof Float[])\r
 841         {\r
 842             Float[] array = (Float[]) obj;\r
 843             return array[0].longValue();\r
 844         }\r
 845         if (obj instanceof float[])\r
 846         {\r
 847             float[] array = (float[]) obj;\r
 848             return (long)array[0];\r
 849         }\r
 850         if (obj instanceof Long[])\r
 851         {\r
 852             Long[] array = (Long[]) obj;\r
 853             return array[0].longValue();\r
 854         }\r
 855         if (obj instanceof long[])\r
 856         {\r
 857             long[] array = (long[]) obj;\r
 858             return array[0];\r
 859         }\r
 860         if (obj instanceof Short[])\r
 861         {\r
 862             Short[] array = (Short[]) obj;\r
 863             return array[0].longValue();\r
 864         }\r
 865         if (obj instanceof short[])\r
 866         {\r
 867             short[] array = (short[]) obj;\r
 868             return array[0];\r
 869         }\r
 870         if (obj instanceof Byte[])\r
 871         {\r
 872             Byte[] array = (Byte[]) obj;\r
 873             return array[0].longValue();\r
 874         }\r
 875         if (obj instanceof byte[])\r
 876         {\r
 877             byte[] array = (byte[]) obj;\r
 878             return array[0];\r
 879         }\r
 880         if (obj instanceof String[])\r
 881         {\r
 882             String[] array = (String[]) obj;\r
 883             try {\r
 884                 return new Long(array[0]);\r
 885             } catch (NumberFormatException e) {\r
 886                 throw new TypeCastException(obj.getClass());\r
 887             }\r
 888         }\r
 889         if (obj instanceof Boolean[])\r
 890         {\r
 891             Boolean[] array = (Boolean[]) obj;\r
 892             return (array[0].booleanValue()?1:0);\r
 893         }\r
 894         if (obj instanceof boolean[])\r
 895         {\r
 896             boolean[] array = (boolean[]) obj;\r
 897             return (array[0]?1:0);\r
 898         }\r
 899         throw new TypeCastException(obj.getClass());\r
 900     }\r
 901 \r
 902     /**\r
 903      * Type casts an array to long.\r
 904      * \r
 905      * String types are attempted to be converted. If string\r
 906      * doesn't represent numeric value, 0 will be returned\r
 907      * \r
 908      * boolean types return 0/1, for false/true respectively\r
 909      * \r
 910      * @return type casted value\r
 911      */\r
 912     public static long[] toLongArray(Object obj)\r
 913     throws TypeCastException\r
 914     {\r
 915         if (!isArray(obj)) {\r
 916             long scalar = toLongScalar(obj);\r
 917             return new long[] {scalar};\r
 918         }\r
 919         int len = getArrayLength(obj);\r
 920         long[] result = new long[len];\r
 921         // TODO add support for int[] long[] float[], ect..\r
 922         if (obj instanceof Calendar[])\r
 923         {\r
 924             Calendar[] array = (Calendar[]) obj;\r
 925             for (int i=0; i<len; i++)\r
 926                 result[i] = array[i].getTimeInMillis();\r
 927             return result;\r
 928         }\r
 929         if (obj instanceof Integer[])\r
 930         {\r
 931             Integer[] array = (Integer[]) obj;\r
 932             for (int i=0; i<len; i++)\r
 933                 result[i] = array[i].longValue();\r
 934             return result;\r
 935         }\r
 936         if (obj instanceof int[])\r
 937         {\r
 938             int[] array = (int[]) obj;\r
 939             for (int i=0; i<len; i++)\r
 940                 result[i] = array[i];\r
 941             return result;\r
 942         }\r
 943         if (obj instanceof Long[])\r
 944         {\r
 945             Long[] array = (Long[]) obj;\r
 946             for (int i=0; i<len; i++)\r
 947                 result[i] = array[i].longValue();\r
 948             return result;\r
 949         }\r
 950         if (obj instanceof long[])\r
 951         {\r
 952             return (long[])obj;\r
 953         }\r
 954         if (obj instanceof Float[])\r
 955         {\r
 956             Float[] array = (Float[]) obj;\r
 957             for (int i=0; i<len; i++)\r
 958                 result[i] = array[i].longValue();\r
 959             return result;\r
 960         }\r
 961         if (obj instanceof float[])\r
 962         {\r
 963             float[] array = (float[]) obj;\r
 964             for (int i=0; i<len; i++)\r
 965                 result[i] = (long)array[i];\r
 966             return result;\r
 967         }\r
 968         if (obj instanceof Double[])\r
 969         {\r
 970             Double[] array = (Double[]) obj;\r
 971             for (int i=0; i<len; i++)\r
 972                 result[i] = array[i].longValue();\r
 973             return result;\r
 974         }\r
 975         if (obj instanceof double[])\r
 976         {\r
 977             double[] array = (double[]) obj;\r
 978             for (int i=0; i<len; i++)\r
 979                 result[i] = (long)array[i];\r
 980             return result;\r
 981         }\r
 982         if (obj instanceof Short[])\r
 983         {\r
 984             Short[] array = (Short[]) obj;\r
 985             for (int i=0; i<len; i++)\r
 986                 result[i] = array[i].longValue();\r
 987             return result;\r
 988         }\r
 989         if (obj instanceof short[])\r
 990         {\r
 991             short[] array = (short[]) obj;\r
 992             for (int i=0; i<len; i++)\r
 993                 result[i] = array[i];\r
 994             return result;\r
 995         }\r
 996         if (obj instanceof Byte[])\r
 997         {\r
 998             Byte[] array = (Byte[]) obj;\r
 999             for (int i=0; i<len; i++)\r
1000                 result[i] = array[i].longValue();\r
1001             return result;\r
1002         }\r
1003         if (obj instanceof byte[])\r
1004         {\r
1005             byte[] array = (byte[]) obj;\r
1006             for (int i=0; i<len; i++)\r
1007                 result[i] = array[i];\r
1008             return result;\r
1009         }\r
1010         if (obj instanceof String[])\r
1011         {\r
1012             String[] array = (String[]) obj;\r
1013             for (int i=0; i<len; i++)\r
1014                 try {\r
1015                     result[i] = new Long(array[i]);\r
1016                 } catch (NumberFormatException e) {\r
1017                     throw new TypeCastException(obj.getClass());\r
1018                 }\r
1019                 return result;\r
1020         }\r
1021         if (obj instanceof Boolean[])\r
1022         {\r
1023             Boolean[] array = (Boolean[]) obj;\r
1024             for (int i=0; i<len; i++)\r
1025                 result[i] = (array[i].booleanValue()?1:0);\r
1026             return result;\r
1027         }\r
1028         if (obj instanceof boolean[])\r
1029         {\r
1030             boolean[] array = (boolean[]) obj;\r
1031             for (int i=0; i<len; i++)\r
1032                 result[i] = (array[i]?1:0);\r
1033             return result;\r
1034         }\r
1035         throw new TypeCastException(obj.getClass());\r
1036     }\r
1037 \r
1038 \r
1039 \r
1040 \r
1041 \r
1042 \r
1043     /**\r
1044      * Type casts an object to int.\r
1045      * \r
1046      * String types are attempted to be converted. If string\r
1047      * doesn't represent numeric value, 0 will be returned\r
1048      * \r
1049      * boolean types return 0/1, for false/true respectively\r
1050      * \r
1051      * @return type casted value\r
1052      */\r
1053     public static int toIntegerScalar(Object obj)\r
1054     throws TypeCastException\r
1055     {\r
1056         if (!isArray(obj)) {\r
1057             if (obj instanceof Number)\r
1058                 return ((Number)obj).intValue();\r
1059             if (obj instanceof String)\r
1060             {\r
1061                 String str = (String) obj;\r
1062                 try {\r
1063                     Integer d = new Integer(str);\r
1064                     return d.intValue();\r
1065                 } catch (NumberFormatException e) {\r
1066                     throw new TypeCastException(obj.getClass());\r
1067                 }\r
1068             }\r
1069             if (obj instanceof Boolean) {\r
1070                 return (((Boolean)obj).booleanValue())?1:0;\r
1071             }\r
1072             throw new TypeCastException(obj.getClass());\r
1073         }\r
1074         int len = getArrayLength(obj);\r
1075         if (len!=1)\r
1076             throw new TypeCastException("Expected length of array is 1");\r
1077 \r
1078         if (obj instanceof double[])\r
1079         {\r
1080             return ((int[])obj)[0];\r
1081         }\r
1082         if (obj instanceof int[])\r
1083         {\r
1084             int[] array = (int[]) obj;\r
1085             return array[0];\r
1086         }\r
1087         if (obj instanceof Integer[])\r
1088         {\r
1089             Integer[] array = (Integer[]) obj;\r
1090             return array[0].intValue();\r
1091         }\r
1092         if (obj instanceof Double[])\r
1093         {\r
1094             Double[] array = (Double[]) obj;\r
1095             return array[0].intValue();\r
1096         }\r
1097         if (obj instanceof Float[])\r
1098         {\r
1099             Float[] array = (Float[]) obj;\r
1100             return array[0].intValue();\r
1101         }\r
1102         if (obj instanceof float[])\r
1103         {\r
1104             float[] array = (float[]) obj;\r
1105             return (int)array[0];\r
1106         }\r
1107         if (obj instanceof Long[])\r
1108         {\r
1109             Long[] array = (Long[]) obj;\r
1110             return array[0].intValue();\r
1111         }\r
1112         if (obj instanceof long[])\r
1113         {\r
1114             long[] array = (long[]) obj;\r
1115             return (int)array[0];\r
1116         }\r
1117         if (obj instanceof Short[])\r
1118         {\r
1119             Short[] array = (Short[]) obj;\r
1120             return array[0].intValue();\r
1121         }\r
1122         if (obj instanceof short[])\r
1123         {\r
1124             short[] array = (short[]) obj;\r
1125             return array[0];\r
1126         }\r
1127         if (obj instanceof Byte[])\r
1128         {\r
1129             Byte[] array = (Byte[]) obj;\r
1130             return array[0].intValue();\r
1131         }\r
1132         if (obj instanceof byte[])\r
1133         {\r
1134             byte[] array = (byte[]) obj;\r
1135             return array[0];\r
1136         }\r
1137         if (obj instanceof String[])\r
1138         {\r
1139             String[] array = (String[]) obj;\r
1140             try {\r
1141                 return new Integer(array[0]);\r
1142             } catch (NumberFormatException e) {\r
1143                 throw new TypeCastException(obj.getClass());\r
1144             }\r
1145         }\r
1146         if (obj instanceof Boolean[])\r
1147         {\r
1148             Boolean[] array = (Boolean[]) obj;\r
1149             return (array[0].booleanValue()?1:0);\r
1150         }\r
1151         if (obj instanceof boolean[])\r
1152         {\r
1153             boolean[] array = (boolean[]) obj;\r
1154             return (array[0]?1:0);\r
1155         }\r
1156         throw new TypeCastException(obj.getClass());\r
1157     }\r
1158 \r
1159     /**\r
1160      * Type casts an array to int.\r
1161      * \r
1162      * String types are attempted to be converted. If string\r
1163      * doesn't represent numeric value, 0 will be returned\r
1164      * \r
1165      * boolean types return 0/1, for false/true respectively\r
1166      * \r
1167      * @return type casted value\r
1168      */\r
1169     public static int[] toIntegerArray(Object obj)\r
1170     throws TypeCastException\r
1171     {\r
1172         if (!isArray(obj)) {\r
1173             int scalar = toIntegerScalar(obj);\r
1174             return new int[] {scalar};\r
1175         }\r
1176         int len = getArrayLength(obj);\r
1177         int[] result = new int[len];\r
1178         // TODO add support for int[] int[] float[], ect..\r
1179         if (obj instanceof Integer[])\r
1180         {\r
1181             Integer[] array = (Integer[]) obj;\r
1182             for (int i=0; i<len; i++)\r
1183                 result[i] = array[i].intValue();\r
1184             return result;\r
1185         }\r
1186         if (obj instanceof long[])\r
1187         {\r
1188             long[] array = (long[]) obj;\r
1189             for (int i=0; i<len; i++)\r
1190                 result[i] = (int)array[i];\r
1191             return result;\r
1192         }\r
1193         if (obj instanceof Integer[])\r
1194         {\r
1195             Integer[] array = (Integer[]) obj;\r
1196             for (int i=0; i<len; i++)\r
1197                 result[i] = array[i].intValue();\r
1198             return result;\r
1199         }\r
1200         if (obj instanceof int[])\r
1201         {\r
1202             return (int[])obj;\r
1203         }\r
1204         if (obj instanceof Float[])\r
1205         {\r
1206             Float[] array = (Float[]) obj;\r
1207             for (int i=0; i<len; i++)\r
1208                 result[i] = array[i].intValue();\r
1209             return result;\r
1210         }\r
1211         if (obj instanceof float[])\r
1212         {\r
1213             float[] array = (float[]) obj;\r
1214             for (int i=0; i<len; i++)\r
1215                 result[i] = (int)array[i];\r
1216             return result;\r
1217         }\r
1218         if (obj instanceof Double[])\r
1219         {\r
1220             Double[] array = (Double[]) obj;\r
1221             for (int i=0; i<len; i++)\r
1222                 result[i] = array[i].intValue();\r
1223             return result;\r
1224         }\r
1225         if (obj instanceof double[])\r
1226         {\r
1227             double[] array = (double[]) obj;\r
1228             for (int i=0; i<len; i++)\r
1229                 result[i] = (int)array[i];\r
1230             return result;\r
1231         }\r
1232         if (obj instanceof Short[])\r
1233         {\r
1234             Short[] array = (Short[]) obj;\r
1235             for (int i=0; i<len; i++)\r
1236                 result[i] = array[i].intValue();\r
1237             return result;\r
1238         }\r
1239         if (obj instanceof short[])\r
1240         {\r
1241             short[] array = (short[]) obj;\r
1242             for (int i=0; i<len; i++)\r
1243                 result[i] = array[i];\r
1244             return result;\r
1245         }\r
1246         if (obj instanceof Byte[])\r
1247         {\r
1248             Byte[] array = (Byte[]) obj;\r
1249             for (int i=0; i<len; i++)\r
1250                 result[i] = array[i].intValue();\r
1251             return result;\r
1252         }\r
1253         if (obj instanceof byte[])\r
1254         {\r
1255             byte[] array = (byte[]) obj;\r
1256             for (int i=0; i<len; i++)\r
1257                 result[i] = array[i];\r
1258             return result;\r
1259         }\r
1260         if (obj instanceof String[])\r
1261         {\r
1262             String[] array = (String[]) obj;\r
1263             for (int i=0; i<len; i++)\r
1264                 try {\r
1265                     result[i] = new Integer(array[i]);\r
1266                 } catch (NumberFormatException e) {\r
1267                     throw new TypeCastException(obj.getClass());\r
1268                 }\r
1269                 return result;\r
1270         }\r
1271         if (obj instanceof Boolean[])\r
1272         {\r
1273             Boolean[] array = (Boolean[]) obj;\r
1274             for (int i=0; i<len; i++)\r
1275                 result[i] = (array[i].booleanValue()?1:0);\r
1276             return result;\r
1277         }\r
1278         if (obj instanceof boolean[])\r
1279         {\r
1280             boolean[] array = (boolean[]) obj;\r
1281             for (int i=0; i<len; i++)\r
1282                 result[i] = (array[i]?1:0);\r
1283             return result;\r
1284         }\r
1285         throw new TypeCastException(obj.getClass());\r
1286     }\r
1287 \r
1288 \r
1289 \r
1290 \r
1291     /**\r
1292      * Type casts an array to boolean.\r
1293      *\r
1294      * 0 is converted to false, 1 is converted to true, others throw TypeCastException\r
1295      * \r
1296      * @return type casted value\r
1297      * @throws TypeCastException\r
1298      */\r
1299     public static boolean[] toBooleanArray(Object obj)\r
1300     throws TypeCastException\r
1301     {\r
1302         if (!isArray(obj)) {\r
1303             boolean scalar = toBooleanScalar(obj);\r
1304             return new boolean[] {scalar};\r
1305         }\r
1306         int len = getArrayLength(obj);\r
1307         boolean[] result = new boolean[len];\r
1308         if (obj instanceof Integer[])\r
1309         {\r
1310             Integer[] array = (Integer[]) obj;\r
1311             for (int i=0; i<len; i++) {\r
1312                 int value = array[i];\r
1313                 if (value==0) result[i] = false;\r
1314                 else if (value==1) result[i] = true;\r
1315                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1316             }\r
1317             return result;\r
1318         }\r
1319         if (obj instanceof int[])\r
1320         {\r
1321             int[] array = (int[]) obj;\r
1322             for (int i=0; i<len; i++) {\r
1323                 int value = array[i];\r
1324                 if (value==0) result[i] = false;\r
1325                 else if (value==1) result[i] = true;\r
1326                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1327             }\r
1328             return result;\r
1329         }\r
1330         if (obj instanceof Boolean[])\r
1331         {\r
1332             Boolean[] array = (Boolean[]) obj;\r
1333             for (int i=0; i<len; i++)\r
1334                 result[i] = array[i].booleanValue();\r
1335             return result;\r
1336         }\r
1337         if (obj instanceof boolean[])\r
1338         {\r
1339             return (boolean[])obj;\r
1340         }\r
1341         if (obj instanceof Float[])\r
1342         {\r
1343             Float[] array = (Float[]) obj;\r
1344             for (int i=0; i<len; i++) {\r
1345                 float value = array[i];\r
1346                 if (value==0) result[i] = false;\r
1347                 else if (value==1) result[i] = true;\r
1348                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1349             }\r
1350             return result;\r
1351         }\r
1352         if (obj instanceof float[])\r
1353         {\r
1354             float[] array = (float[]) obj;\r
1355             for (int i=0; i<len; i++) {\r
1356                 float value = array[i];\r
1357                 if (value==0) result[i] = false;\r
1358                 else if (value==1) result[i] = true;\r
1359                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1360             }\r
1361             return result;\r
1362         }\r
1363         if (obj instanceof Long[])\r
1364         {\r
1365             Long[] array = (Long[]) obj;\r
1366             for (int i=0; i<len; i++) {\r
1367                 long value = array[i];\r
1368                 if (value==0) result[i] = false;\r
1369                 else if (value==1) result[i] = true;\r
1370                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1371             }\r
1372             return result;\r
1373         }\r
1374         if (obj instanceof long[])\r
1375         {\r
1376             long[] array = (long[]) obj;\r
1377             for (int i=0; i<len; i++) {\r
1378                 long value = array[i];\r
1379                 if (value==0) result[i] = false;\r
1380                 else if (value==1) result[i] = true;\r
1381                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1382             }\r
1383             return result;\r
1384         }\r
1385         if (obj instanceof Short[])\r
1386         {\r
1387             Short[] array = (Short[]) obj;\r
1388             for (int i=0; i<len; i++) {\r
1389                 short value = array[i];\r
1390                 if (value==0) result[i] = false;\r
1391                 else if (value==1) result[i] = true;\r
1392                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1393             }\r
1394             return result;\r
1395         }\r
1396         if (obj instanceof short[])\r
1397         {\r
1398             short[] array = (short[]) obj;\r
1399             for (int i=0; i<len; i++) {\r
1400                 short value = array[i];\r
1401                 if (value==0) result[i] = false;\r
1402                 else if (value==1) result[i] = true;\r
1403                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1404             }\r
1405             return result;\r
1406         }\r
1407         if (obj instanceof Byte[])\r
1408         {\r
1409             Byte[] array = (Byte[]) obj;\r
1410             for (int i=0; i<len; i++) {\r
1411                 byte value = array[i];\r
1412                 if (value==0) result[i] = false;\r
1413                 else if (value==1) result[i] = true;\r
1414                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1415             }\r
1416             return result;\r
1417         }\r
1418         if (obj instanceof byte[])\r
1419         {\r
1420             byte[] array = (byte[]) obj;\r
1421             for (int i=0; i<len; i++) {\r
1422                 byte value = array[i];\r
1423                 if (value==0) result[i] = false;\r
1424                 else if (value==1) result[i] = true;\r
1425                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1426             }\r
1427             return result;\r
1428         }\r
1429         if (obj instanceof String[])\r
1430         {\r
1431             String[] array = (String[]) obj;\r
1432             for (int i=0; i<len; i++)\r
1433                 try {\r
1434                     result[i] = new Boolean(array[i]);\r
1435                 } catch (NumberFormatException e) {\r
1436                     throw new TypeCastException(obj.getClass());\r
1437                 }\r
1438                 return result;\r
1439         }\r
1440         if (obj instanceof Double[])\r
1441         {\r
1442             Double[] array = (Double[]) obj;\r
1443             for (int i=0; i<len; i++) {\r
1444                 double value = array[i];\r
1445                 if (value==0) result[i] = false;\r
1446                 else if (value==1) result[i] = true;\r
1447                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1448             }\r
1449             return result;\r
1450         }\r
1451         if (obj instanceof double[])\r
1452         {\r
1453             double[] array = (double[]) obj;\r
1454             for (int i=0; i<len; i++) {\r
1455                 double value = array[i];\r
1456                 if (value==0) result[i] = false;\r
1457                 else if (value==1) result[i] = true;\r
1458                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1459             }\r
1460             return result;\r
1461         }\r
1462         throw new TypeCastException(obj.getClass());\r
1463     }\r
1464 \r
1465     /**\r
1466      * Type casts an object to long.\r
1467      * \r
1468      * String types are attempted to be converted. If string\r
1469      * doesn't represent numeric value, 0 will be returned\r
1470      * \r
1471      * boolean types return 0/1, for false/true respectively\r
1472      * \r
1473      * @return type casted value\r
1474      */\r
1475     public static boolean toBooleanScalar(Object obj)\r
1476     throws TypeCastException\r
1477     {\r
1478         if (!isArray(obj)) {\r
1479             if (obj instanceof Boolean) {\r
1480                 return ((Boolean)obj).booleanValue();\r
1481             }\r
1482             if (obj instanceof Byte) {\r
1483                 byte value = (Byte)obj;\r
1484                 if (value==0) return false;\r
1485                 else if (value==1) return true;\r
1486                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1487             }\r
1488             if (obj instanceof Short) {\r
1489                 short value = (Short)obj;\r
1490                 if (value==0) return false;\r
1491                 else if (value==1) return true;\r
1492                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1493             }\r
1494             if (obj instanceof Integer) {\r
1495                 int value = (Integer)obj;\r
1496                 if (value==0) return false;\r
1497                 else if (value==1) return true;\r
1498                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1499             }\r
1500             if (obj instanceof Long) {\r
1501                 long value = (Long)obj;\r
1502                 if (value==0) return false;\r
1503                 else if (value==1) return true;\r
1504                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1505             }\r
1506             if (obj instanceof Float) {\r
1507                 float value = (Float)obj;\r
1508                 if (value==0) return false;\r
1509                 else if (value==1) return true;\r
1510                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1511             }\r
1512             if (obj instanceof Double) {\r
1513                 double value = (Double)obj;\r
1514                 if (value==0) return false;\r
1515                 else if (value==1) return true;\r
1516                 else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1517             }\r
1518             if (obj instanceof String) {\r
1519                 String value = (String)obj;\r
1520                 if (value.equals("true") || value.equals("1")) return true;\r
1521                 if (value.equals("false") || value.equals("0")) return false;\r
1522                 throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1523             }\r
1524             throw new TypeCastException(obj.getClass());\r
1525         }\r
1526         int len = getArrayLength(obj);\r
1527         if (len!=1)\r
1528             throw new TypeCastException("Expected length of array is 1");\r
1529 \r
1530         if (obj instanceof boolean[])\r
1531         {\r
1532             return ((boolean[])obj)[0];\r
1533         }\r
1534         if (obj instanceof Boolean[])\r
1535         {\r
1536             Boolean[] array = (Boolean[]) obj;\r
1537             return array[0].booleanValue();\r
1538         }\r
1539         if (obj instanceof int[])\r
1540         {\r
1541             int value = ((int[])obj)[0];\r
1542             if (value==0) return false;\r
1543             else if (value==1) return true;\r
1544             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1545         }\r
1546         if (obj instanceof Integer[])\r
1547         {\r
1548             int value = ((Integer[])obj)[0];\r
1549             if (value==0) return false;\r
1550             else if (value==1) return true;\r
1551             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1552         }\r
1553         if (obj instanceof Float[])\r
1554         {\r
1555             float value = ((Float[])obj)[0];\r
1556             if (value==0) return false;\r
1557             else if (value==1) return true;\r
1558             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1559         }\r
1560         if (obj instanceof float[])\r
1561         {\r
1562             float value = ((float[])obj)[0];\r
1563             if (value==0) return false;\r
1564             else if (value==1) return true;\r
1565             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1566         }\r
1567         if (obj instanceof Long[])\r
1568         {\r
1569             long value = ((Long[])obj)[0];\r
1570             if (value==0) return false;\r
1571             else if (value==1) return true;\r
1572             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1573         }\r
1574         if (obj instanceof long[])\r
1575         {\r
1576             long value = ((long[])obj)[0];\r
1577             if (value==0) return false;\r
1578             else if (value==1) return true;\r
1579             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1580         }\r
1581         if (obj instanceof Short[])\r
1582         {\r
1583             Short value = ((Short[])obj)[0];\r
1584             if (value==0) return false;\r
1585             else if (value==1) return true;\r
1586             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1587         }\r
1588         if (obj instanceof short[])\r
1589         {\r
1590             short value = ((short[])obj)[0];\r
1591             if (value==0) return false;\r
1592             else if (value==1) return true;\r
1593             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1594         }\r
1595         if (obj instanceof Byte[])\r
1596         {\r
1597             Byte value = ((Byte[])obj)[0];\r
1598             if (value==0) return false;\r
1599             else if (value==1) return true;\r
1600             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1601         }\r
1602         if (obj instanceof byte[])\r
1603         {\r
1604             byte value = ((byte[])obj)[0];\r
1605             if (value==0) return false;\r
1606             else if (value==1) return true;\r
1607             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1608         }\r
1609         if (obj instanceof String[])\r
1610         {\r
1611             String[] array = (String[]) obj;\r
1612             String value = array[0];\r
1613             if (value.equals("true") || value.equals("1")) return true;\r
1614             if (value.equals("false") || value.equals("0")) return false;\r
1615             throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1616         }\r
1617         if (obj instanceof Double[])\r
1618         {\r
1619             double value = ((Double[])obj)[0];\r
1620             if (value==0) return false;\r
1621             else if (value==1) return true;\r
1622             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1623         }\r
1624         if (obj instanceof double[])\r
1625         {\r
1626             double value = ((double[])obj)[0];\r
1627             if (value==0) return false;\r
1628             else if (value==1) return true;\r
1629             else throw new TypeCastException("Cannot convert "+value+" to boolean value - 0 or 1 is expected");\r
1630         }\r
1631         throw new TypeCastException(obj.getClass());\r
1632     }\r
1633 \r
1634 \r
1635     @SuppressWarnings("unchecked")\r
1636     public static <T> T adaptToClass(Object obj, Class<T> clazz)\r
1637     throws TypeCastException\r
1638     {\r
1639         if (clazz.equals(double[].class))\r
1640             return (T) toDoubleArray(obj);\r
1641         if (clazz.equals(Double.class))\r
1642             return (T) new Double(toDoubleScalar(obj));\r
1643 \r
1644         if (clazz.equals(float[].class))\r
1645             return (T) toFloatArray(obj);\r
1646         if (clazz.equals(Float.class))\r
1647             return (T) new Float(toFloatScalar(obj));\r
1648 \r
1649         if (clazz.equals(long[].class))\r
1650             return (T) toLongArray(obj);\r
1651         if (clazz.equals(Long.class))\r
1652             return (T) new Long(toLongScalar(obj));\r
1653 \r
1654         if (clazz.equals(int[].class))\r
1655             return (T) toIntegerArray(obj);\r
1656         if (clazz.equals(Integer.class))\r
1657             return (T) new Integer(toIntegerScalar(obj));\r
1658 \r
1659         if (clazz.equals(boolean[].class))\r
1660             return (T) toBooleanArray(obj);\r
1661         if (clazz.equals(Boolean.class))\r
1662             return (T) new Long(toLongScalar(obj));\r
1663 \r
1664         throw new TypeCastException("Unsupported conversion type from "+obj.getClass()+" to "+clazz);\r
1665     }\r
1666 \r
1667 \r
1668 \r
1669     public static String toString(Object obj) {\r
1670         if (obj instanceof Object[]) {\r
1671             return Arrays.toString((Object[])obj);\r
1672         }\r
1673         if (obj instanceof double[]) return Arrays.toString((double[])obj);\r
1674         if (obj instanceof boolean[]) return Arrays.toString((boolean[])obj);\r
1675         if (obj instanceof byte[]) return Arrays.toString((byte[])obj);\r
1676         if (obj instanceof char[]) return Arrays.toString((char[])obj);\r
1677         if (obj instanceof float[]) return Arrays.toString((float[])obj);\r
1678         if (obj instanceof int[]) return Arrays.toString((int[])obj);\r
1679         if (obj instanceof long[]) return Arrays.toString((long[])obj);\r
1680         if (obj instanceof short[]) return Arrays.toString((short[])obj);\r
1681         return obj.toString();\r
1682     }\r
1683 }\r