]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.utils/src/org/simantics/utils/strings/format/MetricsFormat.java
TransferableGraphUtils.getObjects2 for fixing not-found handling
[simantics/platform.git] / bundles / org.simantics.utils / src / org / simantics / utils / strings / format / MetricsFormat.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.utils.strings.format;
13
14 import java.io.Serializable;
15 import java.text.DecimalFormat;
16 import java.util.IllegalFormatConversionException;
17 import java.util.IllegalFormatException;
18
19 /**
20  * Value metrics data
21  * 
22  * Use 'S' Prefix to use String formatting rules http://java.sun.com/javase/6/docs/api/java/util/Formatter.html#syntax
23  * Use 'D' Prefix to use DecimalFormat rules http://java.sun.com/javase/6/docs/api/java/text/DecimalFormat.html
24  * 
25  * If no prefix is detected, String rules are used.
26  * 
27  * @author Toni Kalajainen
28  * @Author Marko Luukkainen
29  */
30 public class MetricsFormat implements Serializable {
31
32     /**
33      * Define serial version of this class
34      */
35     private static final long serialVersionUID = 8036591251300342995L;
36
37     
38     /** Presentation format */
39     private String pattern;
40         
41     /** Presentation format */
42     private String internalPattern;
43     
44     /** Presentation format */
45     private String[] internalPatternDivided;   
46     
47     /** flag if format can adjust decimals */
48     private boolean canUseDecimals = false;
49         
50     /** scale */
51     private double scale;
52     
53     /** name */
54     private String name;
55     
56     /** hash */
57     private int hash;
58     
59     /** Is double or long */
60     private boolean isDouble = true;
61     
62     private boolean useDecimalFormat = false;
63     
64     /** Array reserved for formatter use */
65     private Object args[] = new Object[1];
66     
67     
68     public String getName() {
69         return name;
70     }
71
72     public MetricsFormat(String pattern, double scale, String name)
73     throws IllegalArgumentException
74     {
75         this.scale  = scale;
76         pattern = setPattern(pattern);
77         this.internalPattern = formatPattern( pattern );
78         this.internalPatternDivided = formatPatternDivided( pattern );
79         this.name = name;
80         this.hash = makeHash();
81     }
82
83     public MetricsFormat(String pattern, double scale) 
84     throws IllegalArgumentException
85     {
86         this.scale  = scale;
87         pattern = setPattern(pattern);
88         this.internalPattern = formatPattern( pattern );
89         this.internalPatternDivided = formatPatternDivided( pattern );
90         this.name = "";
91         this.hash = makeHash();
92     }
93     
94     public MetricsFormat(String pattern) 
95     throws IllegalArgumentException
96     {
97         this.scale  = 1.0f;
98         pattern = setPattern(pattern);
99         this.internalPattern = formatPattern( pattern );
100         this.internalPatternDivided = formatPatternDivided( pattern );
101         this.name = "";
102         this.hash = makeHash();
103         
104     }
105     
106     private String setPattern(String pattern) {
107         this.pattern = pattern;
108         if (pattern.startsWith("D")) {
109                 pattern = pattern.substring(1);
110                 useDecimalFormat = true;
111         } else {
112                 if (pattern.startsWith("S"))
113                         pattern = pattern.substring(1);
114                 useDecimalFormat = false;
115         }
116         return pattern;
117     }
118     
119     /**
120      * Replacs all % with %1$ unless % precedes with \ 
121      * 
122      * @param pattern
123      * @return
124      */
125     private String formatPattern(String pattern) {
126         int pos = 0;
127         if (!useDecimalFormat) {
128                 while ( (pos = pattern.indexOf('%', pos)) >= 0 ) {
129                 if (pos==0 || pattern.indexOf(pos-1)!='\\') {
130                     pattern = pattern.substring(0, pos+1) + "1$" + pattern.substring(pos+1, pattern.length());
131                     pos += 3;
132                     continue;
133                 }
134                 pos++;    
135             }
136         }
137                 
138         double value = 0;
139         if (useDecimalFormat) {
140                 isDouble = true;
141                 useDecimalFormat = true;
142                 canUseDecimals = false;
143                 DecimalFormat format = new DecimalFormat(pattern);
144                 format.format(value);
145             
146         } else {
147             try {
148                 isDouble = true;
149                 useDecimalFormat = false;
150                 args[0] = value;
151                 String.format(pattern, args);           
152             } catch(IllegalFormatConversionException e1) {
153                 try {
154                         isDouble = false;
155                         useDecimalFormat = false;
156                     args[0] = (long)value;
157                     String.format(pattern, args); 
158                 } catch (Exception e2) {
159                         throw e1;
160                 }
161             }
162         }
163         
164         return pattern;
165     }
166     
167     /**
168      * Replacs all % with %1$ unless % precedes with \ 
169      * 
170      * Divides formatString into half so that
171      * formats precision can be adjusted with .(n)<br>
172      * Currently only format which supports adjustable
173      * decimals is f/F (floating point as decimal number)
174      * 
175      * 
176      * @param pattern
177      * @return
178      */
179     private String[] formatPatternDivided(String pattern) {
180         String divPattern[] = new String[]{"",""};
181         if (useDecimalFormat)
182                 return divPattern;
183         int pos = 0;
184         while ( (pos = pattern.indexOf('%', pos)) >= 0 ) {
185             if (pos==0 || pattern.indexOf(pos-1)!='\\') {
186                 divPattern[0] = pattern.substring(0, pos+1) + "1$";
187                 divPattern[1] =  pattern.substring(pos+1, pattern.length());
188                 // parse flags
189                 int pos2 = 0;
190                 while(true) {
191                     char c = divPattern[1].charAt(pos2);
192                     if (c == '-' ||
193                         c == '#' ||
194                         c == '+' ||
195                         c == ' ' ||
196                         c == '0' ||
197                         c == ',' ||
198                         c == '(' ||
199                         Character.isDigit(c))
200                         pos2++;
201                     else
202                         break;
203                 }
204                 // get rid of possible precisision setting
205                 // TODO : maybe we should let the user to set the precision
206                 // and then use user given precision instead of dynamic precision
207                 int pos3 = pos2;
208                 while(true) {
209                     char c = divPattern[1].charAt(pos3);
210                     if (c == '.' || Character.isDigit(c)) {
211                         pos3++;
212                     } else if (c == 'f'|| c == 'F') {
213                         this.canUseDecimals = true;
214                         break;
215                     } else {
216                         this.canUseDecimals = false;
217                         break;
218                     }
219                 }
220                 if (pos2 > 0 || pos3 > 0) {
221                     divPattern[0] += divPattern[1].substring(0,pos2);
222                     divPattern[1] = divPattern[1].substring(pos3, divPattern[1].length());
223                 }
224                 pos += 3;
225                 // divided patterns can have only one %
226                 break;
227             }
228             pos++;    
229         }
230                 
231         double value = 0;
232         try {
233             // checking if format can be used
234             args[0] = value;
235             String.format(divPattern[0] + ".2" + divPattern[1] , args);
236         } catch (IllegalFormatException e1) {
237             try {
238                 pattern = formatPattern(pattern);
239                 isDouble = false;
240                 args[0] = (long)value;
241                 String.format(pattern, args);  
242                 // if we get this far by not using decimals something strange has happened...
243                 divPattern[0] = null;
244                 divPattern[1] = null;
245                 canUseDecimals = false;
246             } catch(Exception e2) {
247                 throw e1;
248             }
249         }
250         
251         return divPattern;
252     }
253     
254     /**
255      * Formats value
256      * @param value
257      * @return
258      */
259     public String formatValue(double value) {
260         return _formatValue(internalPattern, value);
261     }
262     
263     /**
264      * Format value
265      * Note: cannot DecimalFormatter syntax does not work with this method
266      * @param value
267      * @param numDecimals
268      * @return
269      */
270     public String formatValue(double value, int numDecimals) {
271         if (canUseDecimals) {
272             if (numDecimals < 0) 
273                 numDecimals = 0;
274             return _formatValue(value, numDecimals);
275         } else {
276             return _formatValue(internalPattern, value);
277         }
278     
279     }
280
281
282     private String _formatValue(String pattern, double value) {
283         //value *= scale;
284         if (!useDecimalFormat) {
285                 if (isDouble) {
286                         args[0] = value;
287                         return String.format(pattern, args);
288                 } else {
289                         args[0] = new Long((long)value);
290                         return String.format(pattern, args);                
291                 }
292         } else {
293                 DecimalFormat format = new DecimalFormat(pattern);
294                 return format.format(value);
295         }
296     }
297     
298     private String _formatValue(double value, int decimals) {
299         //value *= scale;
300         args[0] = value;
301         return String.format(internalPatternDivided[0] + "." + decimals + internalPatternDivided[1], args);
302              
303     }
304
305     public String getPattern() {
306         return pattern;
307     }
308
309     public double getScale() {
310         return scale;
311     }
312     
313     public String toString() {
314         return name;
315     }
316     
317    
318     
319     public boolean equals(Object obj) {
320         if (this == obj) return true;
321         if (obj == null) return false;
322         if (!(obj instanceof MetricsFormat)) return false;
323         MetricsFormat other = (MetricsFormat) obj;
324         if (other.hash!=hash) return false;
325         return other.pattern.equals(pattern) && other.scale==scale && other.name.equals(name);
326     }
327     
328     private int makeHash() {
329         long longBits = Double.doubleToLongBits(scale);
330         int scaleHash = ((int)longBits)^(int)(longBits<<16);
331         return pattern.hashCode() ^ scaleHash ^ name.hashCode();
332     }
333     
334     public int hashCode() {
335         return hash;
336     }
337
338     /*
339     private void changeContent(MetricsFormat newContent) {
340         this.name = newContent.name;
341         this.pattern = newContent.pattern;
342         this.scale = newContent.scale;
343         this.internalPattern = newContent.internalPattern;
344         this.hash = newContent.hash;
345     }*/
346     
347      
348     
349 }