-/*******************************************************************************\r
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
- * in Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.db.layer0.util;\r
-\r
-import java.util.regex.Matcher;\r
-import java.util.regex.Pattern;\r
-\r
-import org.simantics.databoard.type.BooleanType;\r
-import org.simantics.databoard.type.ByteType;\r
-import org.simantics.databoard.type.Datatype;\r
-import org.simantics.databoard.type.DoubleType;\r
-import org.simantics.databoard.type.FloatType;\r
-import org.simantics.databoard.type.IntegerType;\r
-import org.simantics.databoard.type.LongType;\r
-import org.simantics.databoard.type.StringType;\r
-\r
-/**\r
- * @author Tuukka Lehtonen\r
- */\r
-public final class PrimitiveValueParser {\r
-\r
- static final Pattern truePattern = Pattern.compile("\\s*1|[tT]([rR]([uU]([eE])?)?)?\\s*");\r
- static final Pattern falsePattern = Pattern.compile("\\s*0|[fF]([aA]([lL]([sS]([eE])?)?)?)?\\s*");\r
- static final String fpRegex =\r
- "^\\s*[\\x00-\\x20]*" +\r
- "[+-]?(" +\r
- "NaN|" +\r
- "Infinity|" +\r
- "(" +\r
- "\\p{Digit}+([\\.,]\\p{Digit}*)?|" +\r
- "[\\.,]\\p{Digit}+" +\r
- ")" +\r
- ")([eE][+-]?\\p{Digit}+)?\\s*$";\r
- static final Pattern p = Pattern.compile(fpRegex);\r
- static final Pattern commaPat = Pattern.compile(",");\r
-\r
- public interface IValidator {\r
- String isValid(String value);\r
- }\r
-\r
- public static final IValidator NON_MODIFIABLE_VALIDATOR = new IValidator() {\r
- @Override\r
- public String isValid(String value) {\r
- return "Value not modifiable";\r
- }\r
- };\r
-\r
- public static abstract class Validator implements IValidator {\r
- abstract void tryValidate(String v) throws Exception;\r
-\r
- @Override\r
- public String isValid(String value) {\r
- try {\r
- tryValidate(value);\r
- return null;\r
- } catch (Exception e) {\r
- return e.getMessage();\r
- }\r
- }\r
- }\r
-\r
- public static class DoubleArrayValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- parseDoubleArray(v);\r
- }\r
- }\r
- public static class DoubleValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- Double.parseDouble(v.trim());\r
- }\r
- }\r
- public static class FloatArrayValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- parseFloatArray(v);\r
- }\r
- }\r
- public static class FloatValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- Float.parseFloat(v.trim());\r
- }\r
- }\r
- public static class ByteArrayValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- parseByteArray(v);\r
- }\r
- }\r
- public static class ByteValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- Byte.parseByte(v);\r
- }\r
- }\r
- public static class BooleanArrayValidator extends Validator {\r
- @Override\r
- void tryValidate(String v) throws Exception {\r
- parseBooleanArray(v);\r
- }\r
- }\r
- public static class BooleanValidator extends Validator {\r
- @Override\r
- void tryValidate(String v) throws Exception {\r
- parseBoolean(v.trim());\r
- }\r
- }\r
- public static class IntegerArrayValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- parseIntArray(v);\r
- }\r
- }\r
- public static class IntegerValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- Integer.parseInt(v.trim());\r
- }\r
- }\r
- public static class LongArrayValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- parseLongArray(v);\r
- }\r
- }\r
- public static class LongValidator extends Validator {\r
- @Override\r
- public void tryValidate(String v) throws Exception {\r
- Long.parseLong(v.trim());\r
- }\r
- }\r
-\r
- public static Object parse(String value, Class<?> clazz) throws IllegalArgumentException {\r
- if(Double.class.equals(clazz)) return parseDouble(value);\r
- if(Float.class.equals(clazz)) return parseFloat(value);\r
- if(Integer.class.equals(clazz)) return parseInt(value);\r
- if(Long.class.equals(clazz)) return parseLong(value);\r
- if(Boolean.class.equals(clazz)) return parseBoolean(value);\r
- if(Byte.class.equals(clazz)) return parseByte(value);\r
- if(String.class.equals(clazz)) return value;\r
- throw new IllegalArgumentException("class=" + clazz + ", value='" + value + "'");\r
- }\r
-\r
- public static Object parse(String value, Datatype datatype) throws IllegalArgumentException {\r
- if(datatype instanceof DoubleType) return parseDouble(value);\r
- if(datatype instanceof FloatType) return parseFloat(value);\r
- if(datatype instanceof IntegerType) return parseInt(value);\r
- if(datatype instanceof LongType) return parseLong(value);\r
- if(datatype instanceof BooleanType) return parseBoolean(value);\r
- if(datatype instanceof ByteType) return parseByte(value);\r
- if(datatype instanceof StringType) return value;\r
- throw new IllegalArgumentException("datatype=" + datatype + ", value='" + value + "'");\r
- }\r
-\r
- public static double parseDouble(String value) throws IllegalArgumentException {\r
- Matcher m = p.matcher(value);\r
- if (!m.find())\r
- throw new IllegalArgumentException(value + " is not a double number");\r
- String result = m.group();\r
- if(result != null) {\r
- // "Usaify", then parse to allow both , and . as decimal separators.\r
- return Double.parseDouble(result.replace(',', '.').trim());\r
- }\r
- throw new IllegalArgumentException();\r
- }\r
-\r
- public static double[] parseDoubleArray(String value) throws IllegalArgumentException {\r
- String[] parts = commaPat.split(value);\r
- double[] ret = new double[parts.length];\r
- for(int i=0;i<parts.length;++i)\r
- ret[i] = parseDouble(parts[i].trim());\r
- return ret;\r
- }\r
-\r
- public static float parseFloat(String value) throws IllegalArgumentException {\r
- Matcher m = p.matcher(value);\r
- if (!m.find())\r
- throw new IllegalArgumentException(value + " is not a float number");\r
- String result = m.group();\r
- if(result != null) {\r
- // "USAify", then parse to allow both , and . as decimal separators.\r
- return Float.parseFloat(result.replace(',', '.').trim());\r
- }\r
- throw new IllegalArgumentException();\r
- }\r
-\r
- public static float[] parseFloatArray(String value) throws IllegalArgumentException {\r
- String[] parts = commaPat.split(value);\r
- float[] ret = new float[parts.length];\r
- for(int i=0;i<parts.length;++i)\r
- ret[i] = parseFloat(parts[i].trim());\r
- return ret;\r
- }\r
-\r
- public static boolean parseBoolean(String value) throws IllegalArgumentException {\r
- if (truePattern.matcher(value.trim()).matches())\r
- return true;\r
- if (falsePattern.matcher(value.trim()).matches())\r
- return false;\r
- throw new IllegalArgumentException("not a boolean: " + value);\r
- }\r
-\r
- public static boolean[] parseBooleanArray(String value) {\r
- String[] parts = commaPat.split(value);\r
- boolean[] ret = new boolean[parts.length];\r
- for(int i=0;i<parts.length;++i)\r
- ret[i] = parseBoolean(parts[i].trim());\r
- return ret;\r
- }\r
-\r
- public static byte parseByte(String value) throws IllegalArgumentException {\r
- try {\r
- return Byte.parseByte(value);\r
- } catch (NumberFormatException e) {\r
- throw new IllegalArgumentException(e);\r
- }\r
- }\r
-\r
- public static byte[] parseByteArray(String value) {\r
- String[] parts = commaPat.split(value);\r
- byte[] ret = new byte[parts.length];\r
- for(int i=0;i<parts.length;++i)\r
- ret[i] = parseByte(parts[i]);\r
- return ret;\r
- }\r
-\r
- public static int parseInt(String value) throws IllegalArgumentException {\r
- try {\r
- return Integer.parseInt(value.trim());\r
- } catch (NumberFormatException e) {\r
- throw new IllegalArgumentException(e);\r
- }\r
- }\r
-\r
- public static int[] parseIntArray(String value) {\r
- String[] parts = commaPat.split(value);\r
- int[] ret = new int[parts.length];\r
- for(int i=0;i<parts.length;++i)\r
- ret[i] = parseInt(parts[i].trim());\r
- return ret;\r
- }\r
-\r
- public static long parseLong(String value) throws IllegalArgumentException {\r
- try {\r
- return Long.parseLong(value.trim());\r
- } catch (NumberFormatException e) {\r
- throw new IllegalArgumentException(e);\r
- }\r
- }\r
-\r
- public static long[] parseLongArray(String value) {\r
- String[] parts = commaPat.split(value);\r
- long[] ret = new long[parts.length];\r
- for(int i=0;i<parts.length;++i)\r
- ret[i] = parseLong(parts[i].trim());\r
- return ret;\r
- }\r
-\r
-}\r
-\r
+/*******************************************************************************
+ * Copyright (c) 2007, 2010 Association for Decentralized Information Management
+ * in Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.db.layer0.util;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.simantics.databoard.type.BooleanType;
+import org.simantics.databoard.type.ByteType;
+import org.simantics.databoard.type.Datatype;
+import org.simantics.databoard.type.DoubleType;
+import org.simantics.databoard.type.FloatType;
+import org.simantics.databoard.type.IntegerType;
+import org.simantics.databoard.type.LongType;
+import org.simantics.databoard.type.StringType;
+
+/**
+ * @author Tuukka Lehtonen
+ */
+public final class PrimitiveValueParser {
+
+ static final Pattern truePattern = Pattern.compile("\\s*1|[tT]([rR]([uU]([eE])?)?)?\\s*");
+ static final Pattern falsePattern = Pattern.compile("\\s*0|[fF]([aA]([lL]([sS]([eE])?)?)?)?\\s*");
+ static final String fpRegex =
+ "^\\s*[\\x00-\\x20]*" +
+ "[+-]?(" +
+ "NaN|" +
+ "Infinity|" +
+ "(" +
+ "\\p{Digit}+([\\.,]\\p{Digit}*)?|" +
+ "[\\.,]\\p{Digit}+" +
+ ")" +
+ ")([eE][+-]?\\p{Digit}+)?\\s*$";
+ static final Pattern p = Pattern.compile(fpRegex);
+ static final Pattern commaPat = Pattern.compile(",");
+
+ public interface IValidator {
+ String isValid(String value);
+ }
+
+ public static final IValidator NON_MODIFIABLE_VALIDATOR = new IValidator() {
+ @Override
+ public String isValid(String value) {
+ return "Value not modifiable";
+ }
+ };
+
+ public static abstract class Validator implements IValidator {
+ abstract void tryValidate(String v) throws Exception;
+
+ @Override
+ public String isValid(String value) {
+ try {
+ tryValidate(value);
+ return null;
+ } catch (Exception e) {
+ return e.getMessage();
+ }
+ }
+ }
+
+ public static class DoubleArrayValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ parseDoubleArray(v);
+ }
+ }
+ public static class DoubleValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ Double.parseDouble(v.trim());
+ }
+ }
+ public static class FloatArrayValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ parseFloatArray(v);
+ }
+ }
+ public static class FloatValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ Float.parseFloat(v.trim());
+ }
+ }
+ public static class ByteArrayValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ parseByteArray(v);
+ }
+ }
+ public static class ByteValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ Byte.parseByte(v);
+ }
+ }
+ public static class BooleanArrayValidator extends Validator {
+ @Override
+ void tryValidate(String v) throws Exception {
+ parseBooleanArray(v);
+ }
+ }
+ public static class BooleanValidator extends Validator {
+ @Override
+ void tryValidate(String v) throws Exception {
+ parseBoolean(v.trim());
+ }
+ }
+ public static class IntegerArrayValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ parseIntArray(v);
+ }
+ }
+ public static class IntegerValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ Integer.parseInt(v.trim());
+ }
+ }
+ public static class LongArrayValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ parseLongArray(v);
+ }
+ }
+ public static class LongValidator extends Validator {
+ @Override
+ public void tryValidate(String v) throws Exception {
+ Long.parseLong(v.trim());
+ }
+ }
+
+ public static Object parse(String value, Class<?> clazz) throws IllegalArgumentException {
+ if(Double.class.equals(clazz)) return parseDouble(value);
+ if(Float.class.equals(clazz)) return parseFloat(value);
+ if(Integer.class.equals(clazz)) return parseInt(value);
+ if(Long.class.equals(clazz)) return parseLong(value);
+ if(Boolean.class.equals(clazz)) return parseBoolean(value);
+ if(Byte.class.equals(clazz)) return parseByte(value);
+ if(String.class.equals(clazz)) return value;
+ throw new IllegalArgumentException("class=" + clazz + ", value='" + value + "'");
+ }
+
+ public static Object parse(String value, Datatype datatype) throws IllegalArgumentException {
+ if(datatype instanceof DoubleType) return parseDouble(value);
+ if(datatype instanceof FloatType) return parseFloat(value);
+ if(datatype instanceof IntegerType) return parseInt(value);
+ if(datatype instanceof LongType) return parseLong(value);
+ if(datatype instanceof BooleanType) return parseBoolean(value);
+ if(datatype instanceof ByteType) return parseByte(value);
+ if(datatype instanceof StringType) return value;
+ throw new IllegalArgumentException("datatype=" + datatype + ", value='" + value + "'");
+ }
+
+ public static double parseDouble(String value) throws IllegalArgumentException {
+ Matcher m = p.matcher(value);
+ if (!m.find())
+ throw new IllegalArgumentException(value + " is not a double number");
+ String result = m.group();
+ if(result != null) {
+ // "Usaify", then parse to allow both , and . as decimal separators.
+ return Double.parseDouble(result.replace(',', '.').trim());
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public static double[] parseDoubleArray(String value) throws IllegalArgumentException {
+ String[] parts = commaPat.split(value);
+ double[] ret = new double[parts.length];
+ for(int i=0;i<parts.length;++i)
+ ret[i] = parseDouble(parts[i].trim());
+ return ret;
+ }
+
+ public static float parseFloat(String value) throws IllegalArgumentException {
+ Matcher m = p.matcher(value);
+ if (!m.find())
+ throw new IllegalArgumentException(value + " is not a float number");
+ String result = m.group();
+ if(result != null) {
+ // "USAify", then parse to allow both , and . as decimal separators.
+ return Float.parseFloat(result.replace(',', '.').trim());
+ }
+ throw new IllegalArgumentException();
+ }
+
+ public static float[] parseFloatArray(String value) throws IllegalArgumentException {
+ String[] parts = commaPat.split(value);
+ float[] ret = new float[parts.length];
+ for(int i=0;i<parts.length;++i)
+ ret[i] = parseFloat(parts[i].trim());
+ return ret;
+ }
+
+ public static boolean parseBoolean(String value) throws IllegalArgumentException {
+ if (truePattern.matcher(value.trim()).matches())
+ return true;
+ if (falsePattern.matcher(value.trim()).matches())
+ return false;
+ throw new IllegalArgumentException("not a boolean: " + value);
+ }
+
+ public static boolean[] parseBooleanArray(String value) {
+ String[] parts = commaPat.split(value);
+ boolean[] ret = new boolean[parts.length];
+ for(int i=0;i<parts.length;++i)
+ ret[i] = parseBoolean(parts[i].trim());
+ return ret;
+ }
+
+ public static byte parseByte(String value) throws IllegalArgumentException {
+ try {
+ return Byte.parseByte(value);
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ public static byte[] parseByteArray(String value) {
+ String[] parts = commaPat.split(value);
+ byte[] ret = new byte[parts.length];
+ for(int i=0;i<parts.length;++i)
+ ret[i] = parseByte(parts[i]);
+ return ret;
+ }
+
+ public static int parseInt(String value) throws IllegalArgumentException {
+ try {
+ return Integer.parseInt(value.trim());
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ public static int[] parseIntArray(String value) {
+ String[] parts = commaPat.split(value);
+ int[] ret = new int[parts.length];
+ for(int i=0;i<parts.length;++i)
+ ret[i] = parseInt(parts[i].trim());
+ return ret;
+ }
+
+ public static long parseLong(String value) throws IllegalArgumentException {
+ try {
+ return Long.parseLong(value.trim());
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ public static long[] parseLongArray(String value) {
+ String[] parts = commaPat.split(value);
+ long[] ret = new long[parts.length];
+ for(int i=0;i<parts.length;++i)
+ ret[i] = parseLong(parts[i].trim());
+ return ret;
+ }
+
+}
+
Code Review / simantics / platform.git / blobdiff