bundles/org.simantics.modeling.ui/src/org/simantics/modeling/ui/property/ValueUtil.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.modeling.ui.property;
  13
  14 import java.lang.reflect.Array;
  15 import java.util.Arrays;
  16
  17 import org.simantics.db.layer0.util.PrimitiveValueParser;
  18 import org.simantics.utils.datastructures.slice.ValueRange;
  19
  20 /**
  21  * @author Tuukka Lehtonen
  22  */
  23 public class ValueUtil {
  24
  25     /**
  26      * @param object
  27      * @param range
  28      * @return
  29      * @throws ArrayIndexOutOfBoundsException if the specified index range is
  30      *         out of bounds for the specified object if it is an array.
  31      * @throws IllegalArgumentException if the specified value is not an array
  32      */
  33     public static String arrayValueToString(Object object, ValueRange range) {
  34         if (object == null)
  35             return "";
  36
  37         Class<?> clazz = object.getClass();
  38         if (!clazz.isArray())
  39             throw new IllegalArgumentException("object is not an array: " + clazz.getCanonicalName());
  40
  41         int length = Array.getLength(object);
  42         assert range != null;
  43         if (range.start() >= length || range.end() > length)
  44             throw new ArrayIndexOutOfBoundsException(range + " out of array bounds [0," + length + "]");
  45
  46         StringBuilder b = new StringBuilder();
  47
  48         boolean first = true;
  49         for (int i = range.start(); i < range.end(); ++i) {
  50             if (!first) {
  51                 b.append(",");
  52             }
  53             first = false;
  54             b.append(Array.get(object, i));
  55         }
  56         return b.toString();
  57     }
  58
  59     public static String valueToString(Object object) {
  60         if (object == null)
  61             return "";
  62
  63         if (object instanceof String[]) {
  64             String[] value = (String[]) object;
  65             if (value.length == 1)
  66                 return value[0];
  67             else
  68                 return Arrays.toString(value);
  69         } else if (object instanceof int[]) {
  70             int[] value = (int[]) object;
  71             if (value.length == 1)
  72                 return String.valueOf(value[0]);
  73             else {
  74                 StringBuffer buffer = new StringBuffer();
  75                 if (value.length > 0) {
  76                     buffer.append(value[0]);
  77                     for (int i = 1; i < value.length; ++i) {
  78                         buffer.append(", ");
  79                         buffer.append(value[i]);
  80                     }
  81                 }
  82                 return buffer.toString();
  83             }
  84         } else if (object instanceof boolean[]) {
  85             boolean[] value = (boolean[]) object;
  86             if (value.length == 1)
  87                 return String.valueOf(value[0]);
  88             else
  89                 return Arrays.toString(value);
  90         } else if (object instanceof double[]) {
  91             double[] value = (double[]) object;
  92             if (value.length == 1)
  93                 return String.valueOf(value[0]);
  94             else {
  95                 StringBuffer buffer = new StringBuffer();
  96                 if(value.length > 0) {
  97                     buffer.append(value[0]);
  98                     for(int i=1;i<value.length;++i) {
  99                         buffer.append(", ");
 100                         buffer.append(value[i]);
 101                     }
 102                 }
 103                 return buffer.toString();
 104             }
 105         } else if (object instanceof float[]) {
 106             float[] value = (float[]) object;
 107             if (value.length == 1)
 108                 return String.valueOf(value[0]);
 109             else {
 110                 StringBuffer buffer = new StringBuffer();
 111                 if(value.length > 0) {
 112                     buffer.append(value[0]);
 113                     for(int i=1;i<value.length;++i) {
 114                         buffer.append(", ");
 115                         buffer.append(value[i]);
 116                     }
 117                 }
 118                 return buffer.toString();
 119             }
 120         } else if (object instanceof long[]) {
 121             long[] value = (long[]) object;
 122             if (value.length == 1)
 123                 return String.valueOf(value[0]);
 124             else
 125                 return Arrays.toString(value);
 126         } else if (object instanceof byte[]) {
 127             byte[] value = (byte[]) object;
 128             if (value.length == 1)
 129                 return String.valueOf(value[0]);
 130             else
 131                 return Arrays.toString(value);
 132         }
 133         return object.toString();
 134     }
 135
 136     /**
 137      * @param valueClass
 138      * @param label
 139      * @return
 140      * @throws IllegalArgumentException if parsing of the specified label into
 141      *         the specified Class fails
 142      */
 143     public static Object parseLabelToObject(Class<?> valueClass, String label) {
 144         if (valueClass == boolean[].class) {
 145             return PrimitiveValueParser.parseBooleanArray(label);
 146         } else if (valueClass == int[].class) {
 147             return PrimitiveValueParser.parseIntArray(label);
 148         } else if (valueClass == long[].class) {
 149             return PrimitiveValueParser.parseLongArray(label);
 150         } else if (valueClass == float[].class) {
 151             return PrimitiveValueParser.parseFloatArray(label);
 152         } else if (valueClass == double[].class) {
 153             return PrimitiveValueParser.parseDoubleArray(label);
 154         } else if (valueClass == String[].class) {
 155             return new String[] { label };
 156         } else if (valueClass == boolean.class || valueClass == Boolean.class) {
 157             return PrimitiveValueParser.parseBoolean(label);
 158         } else if (valueClass == int.class || valueClass == Integer.class) {
 159             return PrimitiveValueParser.parseInt(label);
 160         } else if (valueClass == long.class || valueClass == Long.class) {
 161             return PrimitiveValueParser.parseLong(label);
 162         } else if (valueClass == float.class || valueClass == Float.class) {
 163             return PrimitiveValueParser.parseFloat(label);
 164         } else if (valueClass == double.class || valueClass == Double.class) {
 165             return PrimitiveValueParser.parseDouble(label);
 166         } else if (valueClass == Byte.class || valueClass == Byte.class) {
 167             return PrimitiveValueParser.parseByte(label);
 168         } else if (valueClass == String.class) {
 169             return label;
 170         }
 171         return null;
 172     }
 173
 174 }