X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.db.layer0%2Fsrc%2Forg%2Fsimantics%2Fdb%2Flayer0%2Futil%2FPrimitiveValueParser.java;h=afd5e5babc86b26ee5556cf955ff5a92d3dd4fe9;hp=2e44e49f6d0201b2c7daa95d131a7c348021d799;hb=HEAD;hpb=969bd23cab98a79ca9101af33334000879fb60c5

diff --git a/bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/util/PrimitiveValueParser.java b/bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/util/PrimitiveValueParser.java
index 2e44e49f6..afd5e5bab 100644
--- a/bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/util/PrimitiveValueParser.java
+++ b/bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/util/PrimitiveValueParser.java
@@ -1,271 +1,271 @@
-/*******************************************************************************
- * 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;
-    }
-
-}
-
+/*******************************************************************************
+ * 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;
+    }
+
+}
+