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