bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/util/PrimitiveValueParser.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.db.layer0.util;\r
  13 \r
  14 import java.util.regex.Matcher;\r
  15 import java.util.regex.Pattern;\r
  16 \r
  17 import org.simantics.databoard.type.BooleanType;\r
  18 import org.simantics.databoard.type.ByteType;\r
  19 import org.simantics.databoard.type.Datatype;\r
  20 import org.simantics.databoard.type.DoubleType;\r
  21 import org.simantics.databoard.type.FloatType;\r
  22 import org.simantics.databoard.type.IntegerType;\r
  23 import org.simantics.databoard.type.LongType;\r
  24 import org.simantics.databoard.type.StringType;\r
  25 \r
  26 /**\r
  27  * @author Tuukka Lehtonen\r
  28  */\r
  29 public final class PrimitiveValueParser {\r
  30 \r
  31     static final Pattern truePattern  = Pattern.compile("\\s*1|[tT]([rR]([uU]([eE])?)?)?\\s*");\r
  32     static final Pattern falsePattern = Pattern.compile("\\s*0|[fF]([aA]([lL]([sS]([eE])?)?)?)?\\s*");\r
  33     static final String  fpRegex      =\r
  34         "^\\s*[\\x00-\\x20]*" +\r
  35         "[+-]?(" +\r
  36         "NaN|" +\r
  37         "Infinity|" +\r
  38         "(" +\r
  39         "\\p{Digit}+([\\.,]\\p{Digit}*)?|" +\r
  40         "[\\.,]\\p{Digit}+" +\r
  41         ")" +\r
  42         ")([eE][+-]?\\p{Digit}+)?\\s*$";\r
  43     static final Pattern p            = Pattern.compile(fpRegex);\r
  44     static final Pattern commaPat     = Pattern.compile(",");\r
  45 \r
  46     public interface IValidator {\r
  47         String isValid(String value);\r
  48     }\r
  49 \r
  50     public static final IValidator NON_MODIFIABLE_VALIDATOR = new IValidator() {\r
  51         @Override\r
  52         public String isValid(String value) {\r
  53             return "Value not modifiable";\r
  54         }\r
  55     };\r
  56 \r
  57     public static abstract class Validator implements IValidator {\r
  58         abstract void tryValidate(String v) throws Exception;\r
  59 \r
  60         @Override\r
  61         public String isValid(String value) {\r
  62             try {\r
  63                 tryValidate(value);\r
  64                 return null;\r
  65             } catch (Exception e) {\r
  66                 return e.getMessage();\r
  67             }\r
  68         }\r
  69     }\r
  70 \r
  71     public static class DoubleArrayValidator extends Validator {\r
  72         @Override\r
  73         public void tryValidate(String v) throws Exception {\r
  74             parseDoubleArray(v);\r
  75         }\r
  76     }\r
  77     public static class DoubleValidator extends Validator {\r
  78         @Override\r
  79         public void tryValidate(String v) throws Exception {\r
  80             Double.parseDouble(v.trim());\r
  81         }\r
  82     }\r
  83     public static class FloatArrayValidator extends Validator {\r
  84         @Override\r
  85         public void tryValidate(String v) throws Exception {\r
  86             parseFloatArray(v);\r
  87         }\r
  88     }\r
  89     public static class FloatValidator extends Validator {\r
  90         @Override\r
  91         public void tryValidate(String v) throws Exception {\r
  92             Float.parseFloat(v.trim());\r
  93         }\r
  94     }\r
  95     public static class ByteArrayValidator extends Validator {\r
  96         @Override\r
  97         public void tryValidate(String v) throws Exception {\r
  98             parseByteArray(v);\r
  99         }\r
 100     }\r
 101     public static class ByteValidator extends Validator {\r
 102         @Override\r
 103         public void tryValidate(String v) throws Exception {\r
 104             Byte.parseByte(v);\r
 105         }\r
 106     }\r
 107     public static class BooleanArrayValidator extends Validator {\r
 108         @Override\r
 109         void tryValidate(String v) throws Exception {\r
 110             parseBooleanArray(v);\r
 111         }\r
 112     }\r
 113     public static class BooleanValidator extends Validator {\r
 114         @Override\r
 115         void tryValidate(String v) throws Exception {\r
 116             parseBoolean(v.trim());\r
 117         }\r
 118     }\r
 119     public static class IntegerArrayValidator extends Validator {\r
 120         @Override\r
 121         public void tryValidate(String v) throws Exception {\r
 122             parseIntArray(v);\r
 123         }\r
 124     }\r
 125     public static class IntegerValidator extends Validator {\r
 126         @Override\r
 127         public void tryValidate(String v) throws Exception {\r
 128             Integer.parseInt(v.trim());\r
 129         }\r
 130     }\r
 131     public static class LongArrayValidator extends Validator {\r
 132         @Override\r
 133         public void tryValidate(String v) throws Exception {\r
 134             parseLongArray(v);\r
 135         }\r
 136     }\r
 137     public static class LongValidator extends Validator {\r
 138         @Override\r
 139         public void tryValidate(String v) throws Exception {\r
 140             Long.parseLong(v.trim());\r
 141         }\r
 142     }\r
 143 \r
 144     public static Object parse(String value, Class<?> clazz) throws IllegalArgumentException {\r
 145         if(Double.class.equals(clazz)) return parseDouble(value);\r
 146         if(Float.class.equals(clazz)) return parseFloat(value);\r
 147         if(Integer.class.equals(clazz)) return parseInt(value);\r
 148         if(Long.class.equals(clazz)) return parseLong(value);\r
 149         if(Boolean.class.equals(clazz)) return parseBoolean(value);\r
 150         if(Byte.class.equals(clazz)) return parseByte(value);\r
 151         if(String.class.equals(clazz)) return value;\r
 152         throw new IllegalArgumentException("class=" + clazz + ", value='" + value + "'");\r
 153     }\r
 154 \r
 155     public static Object parse(String value, Datatype datatype) throws IllegalArgumentException {\r
 156         if(datatype instanceof DoubleType) return parseDouble(value);\r
 157         if(datatype instanceof FloatType) return parseFloat(value);\r
 158         if(datatype instanceof IntegerType) return parseInt(value);\r
 159         if(datatype instanceof LongType) return parseLong(value);\r
 160         if(datatype instanceof BooleanType) return parseBoolean(value);\r
 161         if(datatype instanceof ByteType) return parseByte(value);\r
 162         if(datatype instanceof StringType) return value;\r
 163         throw new IllegalArgumentException("datatype=" + datatype + ", value='" + value + "'");\r
 164     }\r
 165 \r
 166     public static double parseDouble(String value) throws IllegalArgumentException {\r
 167         Matcher m = p.matcher(value);\r
 168         if (!m.find())\r
 169             throw new IllegalArgumentException(value + " is not a double number");\r
 170         String result = m.group();\r
 171         if(result != null) {\r
 172             // "Usaify", then parse to allow both , and . as decimal separators.\r
 173             return Double.parseDouble(result.replace(',', '.').trim());\r
 174         }\r
 175         throw new IllegalArgumentException();\r
 176     }\r
 177 \r
 178     public static double[] parseDoubleArray(String value) throws IllegalArgumentException {\r
 179         String[] parts = commaPat.split(value);\r
 180         double[] ret = new double[parts.length];\r
 181         for(int i=0;i<parts.length;++i)\r
 182             ret[i] = parseDouble(parts[i].trim());\r
 183         return ret;\r
 184     }\r
 185 \r
 186     public static float parseFloat(String value) throws IllegalArgumentException {\r
 187         Matcher m = p.matcher(value);\r
 188         if (!m.find())\r
 189             throw new IllegalArgumentException(value + " is not a float number");\r
 190         String result = m.group();\r
 191         if(result != null) {\r
 192             // "USAify", then parse to allow both , and . as decimal separators.\r
 193             return Float.parseFloat(result.replace(',', '.').trim());\r
 194         }\r
 195         throw new IllegalArgumentException();\r
 196     }\r
 197 \r
 198     public static float[] parseFloatArray(String value) throws IllegalArgumentException {\r
 199         String[] parts = commaPat.split(value);\r
 200         float[] ret = new float[parts.length];\r
 201         for(int i=0;i<parts.length;++i)\r
 202             ret[i] = parseFloat(parts[i].trim());\r
 203         return ret;\r
 204     }\r
 205 \r
 206     public static boolean parseBoolean(String value) throws IllegalArgumentException {\r
 207         if (truePattern.matcher(value.trim()).matches())\r
 208             return true;\r
 209         if (falsePattern.matcher(value.trim()).matches())\r
 210             return false;\r
 211         throw new IllegalArgumentException("not a boolean: " + value);\r
 212     }\r
 213 \r
 214     public static boolean[] parseBooleanArray(String value) {\r
 215         String[] parts = commaPat.split(value);\r
 216         boolean[] ret = new boolean[parts.length];\r
 217         for(int i=0;i<parts.length;++i)\r
 218             ret[i] = parseBoolean(parts[i].trim());\r
 219         return ret;\r
 220     }\r
 221 \r
 222     public static byte parseByte(String value) throws IllegalArgumentException {\r
 223         try {\r
 224             return Byte.parseByte(value);\r
 225         } catch (NumberFormatException e) {\r
 226             throw new IllegalArgumentException(e);\r
 227         }\r
 228     }\r
 229 \r
 230     public static byte[] parseByteArray(String value) {\r
 231         String[] parts = commaPat.split(value);\r
 232         byte[] ret = new byte[parts.length];\r
 233         for(int i=0;i<parts.length;++i)\r
 234             ret[i] = parseByte(parts[i]);\r
 235         return ret;\r
 236     }\r
 237 \r
 238     public static int parseInt(String value) throws IllegalArgumentException {\r
 239         try {\r
 240             return Integer.parseInt(value.trim());\r
 241         } catch (NumberFormatException e) {\r
 242             throw new IllegalArgumentException(e);\r
 243         }\r
 244     }\r
 245 \r
 246     public static int[] parseIntArray(String value) {\r
 247         String[] parts = commaPat.split(value);\r
 248         int[] ret = new int[parts.length];\r
 249         for(int i=0;i<parts.length;++i)\r
 250             ret[i] = parseInt(parts[i].trim());\r
 251         return ret;\r
 252     }\r
 253 \r
 254     public static long parseLong(String value) throws IllegalArgumentException {\r
 255         try {\r
 256             return Long.parseLong(value.trim());\r
 257         } catch (NumberFormatException e) {\r
 258             throw new IllegalArgumentException(e);\r
 259         }\r
 260     }\r
 261 \r
 262     public static long[] parseLongArray(String value) {\r
 263         String[] parts = commaPat.split(value);\r
 264         long[] ret = new long[parts.length];\r
 265         for(int i=0;i<parts.length;++i)\r
 266             ret[i] = parseLong(parts[i].trim());\r
 267         return ret;\r
 268     }\r
 269 \r
 270 }\r
 271 \r