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
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.db.layer0.util;
\r
14 import java.util.regex.Matcher;
\r
15 import java.util.regex.Pattern;
\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
27 * @author Tuukka Lehtonen
\r
29 public final class PrimitiveValueParser {
\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
39 "\\p{Digit}+([\\.,]\\p{Digit}*)?|" +
\r
40 "[\\.,]\\p{Digit}+" +
\r
42 ")([eE][+-]?\\p{Digit}+)?\\s*$";
\r
43 static final Pattern p = Pattern.compile(fpRegex);
\r
44 static final Pattern commaPat = Pattern.compile(",");
\r
46 public interface IValidator {
\r
47 String isValid(String value);
\r
50 public static final IValidator NON_MODIFIABLE_VALIDATOR = new IValidator() {
\r
52 public String isValid(String value) {
\r
53 return "Value not modifiable";
\r
57 public static abstract class Validator implements IValidator {
\r
58 abstract void tryValidate(String v) throws Exception;
\r
61 public String isValid(String value) {
\r
65 } catch (Exception e) {
\r
66 return e.getMessage();
\r
71 public static class DoubleArrayValidator extends Validator {
\r
73 public void tryValidate(String v) throws Exception {
\r
74 parseDoubleArray(v);
\r
77 public static class DoubleValidator extends Validator {
\r
79 public void tryValidate(String v) throws Exception {
\r
80 Double.parseDouble(v.trim());
\r
83 public static class FloatArrayValidator extends Validator {
\r
85 public void tryValidate(String v) throws Exception {
\r
89 public static class FloatValidator extends Validator {
\r
91 public void tryValidate(String v) throws Exception {
\r
92 Float.parseFloat(v.trim());
\r
95 public static class ByteArrayValidator extends Validator {
\r
97 public void tryValidate(String v) throws Exception {
\r
101 public static class ByteValidator extends Validator {
\r
103 public void tryValidate(String v) throws Exception {
\r
107 public static class BooleanArrayValidator extends Validator {
\r
109 void tryValidate(String v) throws Exception {
\r
110 parseBooleanArray(v);
\r
113 public static class BooleanValidator extends Validator {
\r
115 void tryValidate(String v) throws Exception {
\r
116 parseBoolean(v.trim());
\r
119 public static class IntegerArrayValidator extends Validator {
\r
121 public void tryValidate(String v) throws Exception {
\r
125 public static class IntegerValidator extends Validator {
\r
127 public void tryValidate(String v) throws Exception {
\r
128 Integer.parseInt(v.trim());
\r
131 public static class LongArrayValidator extends Validator {
\r
133 public void tryValidate(String v) throws Exception {
\r
137 public static class LongValidator extends Validator {
\r
139 public void tryValidate(String v) throws Exception {
\r
140 Long.parseLong(v.trim());
\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
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
166 public static double parseDouble(String value) throws IllegalArgumentException {
\r
167 Matcher m = p.matcher(value);
\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
175 throw new IllegalArgumentException();
\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
186 public static float parseFloat(String value) throws IllegalArgumentException {
\r
187 Matcher m = p.matcher(value);
\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
195 throw new IllegalArgumentException();
\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
206 public static boolean parseBoolean(String value) throws IllegalArgumentException {
\r
207 if (truePattern.matcher(value.trim()).matches())
\r
209 if (falsePattern.matcher(value.trim()).matches())
\r
211 throw new IllegalArgumentException("not a boolean: " + value);
\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
222 public static byte parseByte(String value) throws IllegalArgumentException {
\r
224 return Byte.parseByte(value);
\r
225 } catch (NumberFormatException e) {
\r
226 throw new IllegalArgumentException(e);
\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
238 public static int parseInt(String value) throws IllegalArgumentException {
\r
240 return Integer.parseInt(value.trim());
\r
241 } catch (NumberFormatException e) {
\r
242 throw new IllegalArgumentException(e);
\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
254 public static long parseLong(String value) throws IllegalArgumentException {
\r
256 return Long.parseLong(value.trim());
\r
257 } catch (NumberFormatException e) {
\r
258 throw new IllegalArgumentException(e);
\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