X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.db.common%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fcommon%2Futils%2FLiterals.java;h=e05627fa8098df68874dbfe35a3f2c4267787209;hb=HEAD;hp=d7db63c98386fc00d96de1562892879cacd916fd;hpb=969bd23cab98a79ca9101af33334000879fb60c5;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/Literals.java b/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/Literals.java
index d7db63c98..e05627fa8 100644
--- a/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/Literals.java
+++ b/bundles/org.simantics.db.common/src/org/simantics/db/common/utils/Literals.java
@@ -1,297 +1,297 @@
-/*******************************************************************************
- * 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.common.utils;
-
-import java.math.BigDecimal;
-import java.math.MathContext;
-import java.math.RoundingMode;
-import java.util.Arrays;
-import java.util.regex.Pattern;
-
-/**
- * Common utility methods for handling and visualising literal values.
- * 
- * @author Tuukka Lehtonen
- * 
- * PROBLEMS:
- * - ProCore does not support zero length vectors at the moment
- * - String[] literals could be parsed from a String assuming a StringMemento String serialization.
- */
-public final class Literals {
-    
-    final private static Pattern comma = Pattern.compile(",");
-    
-    private static int precision = 8;
-    
-//    public static final boolean[] FALSE = { false };
-//
-//    public static final boolean[] TRUE  = { true };
-
-    public static int getPrecision() {
-        return precision;
-    }
-    
-    public static void setPrecision(int precision) {
-        Literals.precision = precision;
-    }
-
-    private static String formattedDouble(double a) {
-        try {
-            BigDecimal dec = new BigDecimal(String.valueOf(a), new MathContext(precision, RoundingMode.HALF_UP));
-            dec = dec.stripTrailingZeros();
-            if(dec.scale() < 1) dec = dec.setScale(1);
-            return dec.toString();
-        } catch (NumberFormatException e) {
-            return "Invalid Value";
-        }
-    }
-    
-    public static String toString(double[] a) {
-        if (a == null)
-            return "null";
-        int iMax = a.length - 1;
-        if (iMax == -1)
-            return "[]";
-
-        StringBuilder b = new StringBuilder();
-        b.append('[');
-        for (int i = 0; ; i++) {
-            b.append(formattedDouble(a[i]));
-        if (i == iMax)
-        return b.append(']').toString();
-            b.append(", ");
-        }
-    }
-
-    /**
-     * Convert a literal object (of any allowed type) into to a String.
-     * 
-     * @param literal
-     * @return
-     * @throws IllegalArgumentException
-     */
-    public static String literalToString(Object literal) throws IllegalArgumentException {
-        Class<?> literalClass = literal.getClass();
-        
-        if (literalClass == String.class) {
-            return (String)literal;
-        } else if (literalClass == Double.class) {
-            return literal.toString();
-        } else if (literalClass == Float.class) {
-            return literal.toString();
-        } else if (literalClass == Long.class) {
-            return literal.toString();
-        } else if (literalClass == Integer.class) {
-            return literal.toString();
-        } else if (literalClass == Byte.class) {
-            return literal.toString();
-        } else if (literalClass == Boolean.class) {
-            return literal.toString();
-        } else if (literalClass == String[].class) {
-            return literalToString((String[]) literal);
-        } else if (literalClass == double[].class) {
-            return literalToString((double[]) literal);
-        } else if (literalClass == float[].class) {
-            return literalToString((float[]) literal);
-        } else if (literalClass == long[].class) {
-            return literalToString((long[]) literal);
-        } else if (literalClass == int[].class) {
-            return literalToString((int[]) literal);
-        } else if (literalClass == byte[].class) {
-            return literalToString((byte[]) literal);
-        } else if (literalClass == boolean[].class) {
-            return literalToString((boolean[]) literal);
-        }
-        
-        throw new IllegalArgumentException(String.format("Literal object type not recognized: %s", literal.getClass().getName()));
-    }
-    
-    public static String shortString(Object original) {
-    	if(original.toString().length() > 100) return original.toString().substring(0, 99) + "...";
-    	else return original.toString();
-    }
-
-    public static String literalToString(boolean[] l) throws IllegalArgumentException {
-        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
-    }
-
-    public static String literalToString(byte[] l) throws IllegalArgumentException {
-        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
-    }
-
-    public static String literalToString(int[] l) throws IllegalArgumentException {
-        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
-    }
-
-    public static String literalToString(long[] l) throws IllegalArgumentException {
-        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
-    }
-
-    public static String literalToString(float[] l) throws IllegalArgumentException {
-        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
-    }
-
-    public static String literalToString(double[] l) throws IllegalArgumentException {
-        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
-    }
-
-    public static String literalToString(String[] l) throws IllegalArgumentException {
-        // FIXME BEWARE!!! THIS BREAKS UP WITH STRINGS CONTAINING ',' CHARACTERS
-        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
-    }
-
-
-//    /**
-//     * Convert a literal object (of any allowed type) into to a String.
-//     * 
-//     * @param literal a literal as string
-//     * @return the same literal as its native type
-//     * @throws IllegalArgumentException
-//     */
-//    public static Object stringToLiteral(Graph g, Resource property, String literal) throws IllegalArgumentException, ResourceNotFoundException {
-//        if (property == null)
-//            throw new IllegalArgumentException("null property");
-//        if (literal == null)
-//            throw new IllegalArgumentException("null literal string");
-//
-//        // Attempt to parse the property value by its type.
-//        if (g.isInstanceOf(property, g.getBuiltins().Double)) {
-//            return parseDoubleLiteral(literal);
-//        } else if (g.isInstanceOf(property, g.getBuiltins().Float)) {
-//            return parseFloatLiteral(literal);
-//        } else if (g.isInstanceOf(property, g.getBuiltins().Long)) {
-//            return parseLongLiteral(literal);
-//        } else if (g.isInstanceOf(property, g.getBuiltins().Integer)) {
-//            return parseIntegerLiteral(literal);
-//        } else if (g.isInstanceOf(property, g.getBuiltins().Byte)) {
-//            return parseByteLiteral(literal);
-//        } else if (g.isInstanceOf(property, g.getBuiltins().Boolean)) {
-//            return parseBooleanLiteral(literal);
-//        } else if (g.isInstanceOf(property, g.getBuiltins().String)) {
-//            return parseStringLiteral(literal);
-//        }
-//        
-//        throw new IllegalArgumentException("unrecognized property type for resource");
-//    }
-    
-    /**
-     * @param literal
-     * @return
-     * @throws IllegalArgumentException if the parsing fails
-     */
-    public static boolean[] parseBooleanLiteral(String literal) {
-        literal = trimLiteralString(literal);
-        try {
-            String parts[] = comma.split(literal);
-            boolean[] result = new boolean[parts.length];
-            for (int i = 0; i < parts.length; i++)
-                result[i] = Boolean.parseBoolean(parts[i]);
-            return result;
-        } catch(NumberFormatException e) {
-            throw new IllegalArgumentException("Invalid boolean value: " + literal, e);
-        }
-    }
-
-    /**
-     * @param literal
-     * @return
-     * @throws IllegalArgumentException if the parsing fails
-     */
-    public static double[] parseDoubleLiteral(String literal) {
-        literal = trimLiteralString(literal);
-        try {
-            String parts[] = comma.split(literal);
-            // " " would be more common delimiter for primitive arrays since 
-            // it is also default delimiter in XML documents
-            double result[] = new double[parts.length];
-            for (int i = 0; i < parts.length; i++)
-                result[i] = Double.parseDouble(parts[i]);
-            return result;
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("Invalid double value: " + literal, e);
-        }
-    }
-    
-    /**
-     * @param literal
-     * @return
-     * @throws IllegalArgumentException if the parsing fails
-     */
-    public static int[] parseIntegerLiteral(String literal) {
-        literal = trimLiteralString(literal);
-        try {
-            String parts[] = comma.split(literal);
-            int result[] = new int[parts.length];
-            for (int i = 0; i < parts.length; i++)
-                result[i] = Integer.parseInt(parts[i]);
-            return result;
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("Invalid integer value: " + literal, e);
-        }
-    }
-
-    public static byte[] parseByteLiteral(String literal) {
-        literal = trimLiteralString(literal);
-        try {
-            String parts[] = comma.split(literal);
-            byte result[] = new byte[parts.length];
-            for (int i = 0; i < parts.length; i++)
-                result[i] = Byte.parseByte(parts[i]);
-            return result;
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("Invalid byte value: " + literal, e);
-        }
-    }
-
-    public static long[] parseLongLiteral(String literal) {
-        literal = trimLiteralString(literal);
-        try {
-            String parts[] = comma.split(literal);
-            long result[] = new long[parts.length];
-            for (int i = 0; i < parts.length; i++)
-                result[i] = Long.parseLong(parts[i]);
-            return result;
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("Invalid long value: " + literal, e);
-        }
-    }
-
-    public static float[] parseFloatLiteral(String literal) {
-        literal = trimLiteralString(literal);
-        try {
-            String parts[] = comma.split(literal);
-            float result[] = new float[parts.length];
-            for (int i = 0; i < parts.length; i++)
-                result[i] = Float.parseFloat(parts[i]);
-            return result;
-        } catch (NumberFormatException e) {
-            throw new IllegalArgumentException("Invalid float value: " + literal, e);
-        }
-    }
-    
-    private static String[] parseStringLiteral(String literal) {
-        // TODO: support StringMemento serialized literals!
-        return new String[] {literal};
-    }
-    
-    private static String trimLiteralString(String literal) {
-        // First trim the literal to make the input more canonical.
-        // Also remove possible '[' and ']' prefix and suffix.
-        literal = literal.trim();
-        if (literal.startsWith("["))
-            literal = literal.substring(1);
-        if (literal.endsWith("]"))
-            literal = literal.substring(0, literal.length() - 1);
-        return literal;
-    }
-
-}
+/*******************************************************************************
+ * 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.common.utils;
+
+import java.math.BigDecimal;
+import java.math.MathContext;
+import java.math.RoundingMode;
+import java.util.Arrays;
+import java.util.regex.Pattern;
+
+/**
+ * Common utility methods for handling and visualising literal values.
+ * 
+ * @author Tuukka Lehtonen
+ * 
+ * PROBLEMS:
+ * - ProCore does not support zero length vectors at the moment
+ * - String[] literals could be parsed from a String assuming a StringMemento String serialization.
+ */
+public final class Literals {
+    
+    final private static Pattern comma = Pattern.compile(",");
+    
+    private static int precision = 8;
+    
+//    public static final boolean[] FALSE = { false };
+//
+//    public static final boolean[] TRUE  = { true };
+
+    public static int getPrecision() {
+        return precision;
+    }
+    
+    public static void setPrecision(int precision) {
+        Literals.precision = precision;
+    }
+
+    private static String formattedDouble(double a) {
+        try {
+            BigDecimal dec = new BigDecimal(String.valueOf(a), new MathContext(precision, RoundingMode.HALF_UP));
+            dec = dec.stripTrailingZeros();
+            if(dec.scale() < 1) dec = dec.setScale(1);
+            return dec.toString();
+        } catch (NumberFormatException e) {
+            return "Invalid Value";
+        }
+    }
+    
+    public static String toString(double[] a) {
+        if (a == null)
+            return "null";
+        int iMax = a.length - 1;
+        if (iMax == -1)
+            return "[]";
+
+        StringBuilder b = new StringBuilder();
+        b.append('[');
+        for (int i = 0; ; i++) {
+            b.append(formattedDouble(a[i]));
+        if (i == iMax)
+        return b.append(']').toString();
+            b.append(", ");
+        }
+    }
+
+    /**
+     * Convert a literal object (of any allowed type) into to a String.
+     * 
+     * @param literal
+     * @return
+     * @throws IllegalArgumentException
+     */
+    public static String literalToString(Object literal) throws IllegalArgumentException {
+        Class<?> literalClass = literal.getClass();
+        
+        if (literalClass == String.class) {
+            return (String)literal;
+        } else if (literalClass == Double.class) {
+            return literal.toString();
+        } else if (literalClass == Float.class) {
+            return literal.toString();
+        } else if (literalClass == Long.class) {
+            return literal.toString();
+        } else if (literalClass == Integer.class) {
+            return literal.toString();
+        } else if (literalClass == Byte.class) {
+            return literal.toString();
+        } else if (literalClass == Boolean.class) {
+            return literal.toString();
+        } else if (literalClass == String[].class) {
+            return literalToString((String[]) literal);
+        } else if (literalClass == double[].class) {
+            return literalToString((double[]) literal);
+        } else if (literalClass == float[].class) {
+            return literalToString((float[]) literal);
+        } else if (literalClass == long[].class) {
+            return literalToString((long[]) literal);
+        } else if (literalClass == int[].class) {
+            return literalToString((int[]) literal);
+        } else if (literalClass == byte[].class) {
+            return literalToString((byte[]) literal);
+        } else if (literalClass == boolean[].class) {
+            return literalToString((boolean[]) literal);
+        }
+        
+        throw new IllegalArgumentException(String.format("Literal object type not recognized: %s", literal.getClass().getName()));
+    }
+    
+    public static String shortString(Object original) {
+    	if(original.toString().length() > 100) return original.toString().substring(0, 99) + "...";
+    	else return original.toString();
+    }
+
+    public static String literalToString(boolean[] l) throws IllegalArgumentException {
+        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
+    }
+
+    public static String literalToString(byte[] l) throws IllegalArgumentException {
+        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
+    }
+
+    public static String literalToString(int[] l) throws IllegalArgumentException {
+        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
+    }
+
+    public static String literalToString(long[] l) throws IllegalArgumentException {
+        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
+    }
+
+    public static String literalToString(float[] l) throws IllegalArgumentException {
+        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
+    }
+
+    public static String literalToString(double[] l) throws IllegalArgumentException {
+        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
+    }
+
+    public static String literalToString(String[] l) throws IllegalArgumentException {
+        // FIXME BEWARE!!! THIS BREAKS UP WITH STRINGS CONTAINING ',' CHARACTERS
+        return l.length == 1 ? String.valueOf(l[0]) : Arrays.toString(l);
+    }
+
+
+//    /**
+//     * Convert a literal object (of any allowed type) into to a String.
+//     * 
+//     * @param literal a literal as string
+//     * @return the same literal as its native type
+//     * @throws IllegalArgumentException
+//     */
+//    public static Object stringToLiteral(Graph g, Resource property, String literal) throws IllegalArgumentException, ResourceNotFoundException {
+//        if (property == null)
+//            throw new IllegalArgumentException("null property");
+//        if (literal == null)
+//            throw new IllegalArgumentException("null literal string");
+//
+//        // Attempt to parse the property value by its type.
+//        if (g.isInstanceOf(property, g.getBuiltins().Double)) {
+//            return parseDoubleLiteral(literal);
+//        } else if (g.isInstanceOf(property, g.getBuiltins().Float)) {
+//            return parseFloatLiteral(literal);
+//        } else if (g.isInstanceOf(property, g.getBuiltins().Long)) {
+//            return parseLongLiteral(literal);
+//        } else if (g.isInstanceOf(property, g.getBuiltins().Integer)) {
+//            return parseIntegerLiteral(literal);
+//        } else if (g.isInstanceOf(property, g.getBuiltins().Byte)) {
+//            return parseByteLiteral(literal);
+//        } else if (g.isInstanceOf(property, g.getBuiltins().Boolean)) {
+//            return parseBooleanLiteral(literal);
+//        } else if (g.isInstanceOf(property, g.getBuiltins().String)) {
+//            return parseStringLiteral(literal);
+//        }
+//        
+//        throw new IllegalArgumentException("unrecognized property type for resource");
+//    }
+    
+    /**
+     * @param literal
+     * @return
+     * @throws IllegalArgumentException if the parsing fails
+     */
+    public static boolean[] parseBooleanLiteral(String literal) {
+        literal = trimLiteralString(literal);
+        try {
+            String parts[] = comma.split(literal);
+            boolean[] result = new boolean[parts.length];
+            for (int i = 0; i < parts.length; i++)
+                result[i] = Boolean.parseBoolean(parts[i]);
+            return result;
+        } catch(NumberFormatException e) {
+            throw new IllegalArgumentException("Invalid boolean value: " + literal, e);
+        }
+    }
+
+    /**
+     * @param literal
+     * @return
+     * @throws IllegalArgumentException if the parsing fails
+     */
+    public static double[] parseDoubleLiteral(String literal) {
+        literal = trimLiteralString(literal);
+        try {
+            String parts[] = comma.split(literal);
+            // " " would be more common delimiter for primitive arrays since 
+            // it is also default delimiter in XML documents
+            double result[] = new double[parts.length];
+            for (int i = 0; i < parts.length; i++)
+                result[i] = Double.parseDouble(parts[i]);
+            return result;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Invalid double value: " + literal, e);
+        }
+    }
+    
+    /**
+     * @param literal
+     * @return
+     * @throws IllegalArgumentException if the parsing fails
+     */
+    public static int[] parseIntegerLiteral(String literal) {
+        literal = trimLiteralString(literal);
+        try {
+            String parts[] = comma.split(literal);
+            int result[] = new int[parts.length];
+            for (int i = 0; i < parts.length; i++)
+                result[i] = Integer.parseInt(parts[i]);
+            return result;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Invalid integer value: " + literal, e);
+        }
+    }
+
+    public static byte[] parseByteLiteral(String literal) {
+        literal = trimLiteralString(literal);
+        try {
+            String parts[] = comma.split(literal);
+            byte result[] = new byte[parts.length];
+            for (int i = 0; i < parts.length; i++)
+                result[i] = Byte.parseByte(parts[i]);
+            return result;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Invalid byte value: " + literal, e);
+        }
+    }
+
+    public static long[] parseLongLiteral(String literal) {
+        literal = trimLiteralString(literal);
+        try {
+            String parts[] = comma.split(literal);
+            long result[] = new long[parts.length];
+            for (int i = 0; i < parts.length; i++)
+                result[i] = Long.parseLong(parts[i]);
+            return result;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Invalid long value: " + literal, e);
+        }
+    }
+
+    public static float[] parseFloatLiteral(String literal) {
+        literal = trimLiteralString(literal);
+        try {
+            String parts[] = comma.split(literal);
+            float result[] = new float[parts.length];
+            for (int i = 0; i < parts.length; i++)
+                result[i] = Float.parseFloat(parts[i]);
+            return result;
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Invalid float value: " + literal, e);
+        }
+    }
+    
+    private static String[] parseStringLiteral(String literal) {
+        // TODO: support StringMemento serialized literals!
+        return new String[] {literal};
+    }
+    
+    private static String trimLiteralString(String literal) {
+        // First trim the literal to make the input more canonical.
+        // Also remove possible '[' and ']' prefix and suffix.
+        literal = literal.trim();
+        if (literal.startsWith("["))
+            literal = literal.substring(1);
+        if (literal.endsWith("]"))
+            literal = literal.substring(0, literal.length() - 1);
+        return literal;
+    }
+
+}