Clover Coverage Report
Coverage timestamp: Fri May 24 2013 13:47:27 UTC
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../../../img/srcFileCovDistChart6.png 80% of files have more coverage
235   319   123   39.17
26   252   0.52   6
6     20.5  
1    
 
  Latex2UnicodeSpecials       Line # 24 235 123 51.3% 0.5131086
 
  (12)
 
1    /* This file is part of the project "Hilbert II" - http://www.qedeq.org
2    *
3    * Copyright 2000-2013, Michael Meyling <mime@qedeq.org>.
4    *
5    * "Hilbert II" is free software; you can redistribute
6    * it and/or modify it under the terms of the GNU General Public
7    * License as published by the Free Software Foundation; either
8    * version 2 of the License, or (at your option) any later version.
9    *
10    * This program is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13    * GNU General Public License for more details.
14    */
15   
16    package org.qedeq.kernel.bo.service.unicode;
17   
18   
19    /**
20    * Special LaTeX into UTF-8 transformations.
21    *
22    * @author Michael Meyling
23    */
 
24    public final class Latex2UnicodeSpecials {
25   
26    /** Available subscript characters. */
27    private static final String SUBSCRIPT_CHARACTERS = "0123456789()+-=";
28   
29    /** Available superscript characters. */
30    private static final String SUPERSCRIPT_CHARACTERS = "0123456789()+-=n";
31   
32    /**
33    * Constructor.
34    */
 
35  0 toggle private Latex2UnicodeSpecials() {
36    // never used
37    }
38   
39    /**
40    * Transform into bold characters.
41    *
42    * @param token String to transform.
43    * @return Result of transformation.
44    */
 
45  124 toggle public static String transform2Bold(final String token) {
46  124 final StringBuffer buffer = new StringBuffer();
47  636 for (int i = 0; i < token.length(); i++) {
48  512 final char c = token.charAt(i);
49  512 switch (c) {
50  0 case 'A':
51  0 case 'B':
52  0 case 'C':
53  0 case 'D':
54  0 case 'E':
55  0 case 'F':
56  0 case 'G':
57  54 case 'H':
58  108 case 'I':
59  0 case 'J':
60  0 case 'K':
61  0 case 'L':
62  0 case 'M':
63  0 case 'N':
64  0 case 'O':
65  0 case 'P':
66  0 case 'Q':
67  0 case 'R':
68  0 case 'S':
69  0 case 'T':
70  0 case 'U':
71  0 case 'V':
72  0 case 'W':
73  0 case 'X':
74  0 case 'Y':
75  0 case 'Z':
76  162 buffer.append((char) ('\uFF21' - 'A' + c));
77  162 break;
78  0 case 'a':
79  54 case 'b':
80  0 case 'c':
81  0 case 'd':
82  54 case 'e':
83  2 case 'f':
84  0 case 'g':
85  2 case 'h':
86  54 case 'i':
87  0 case 'j':
88  0 case 'k':
89  54 case 'l':
90  0 case 'm':
91  0 case 'n':
92  0 case 'o':
93  4 case 'p':
94  0 case 'q':
95  54 case 'r':
96  0 case 's':
97  60 case 't':
98  0 case 'u':
99  0 case 'v':
100  0 case 'w':
101  0 case 'x':
102  0 case 'y':
103  0 case 'z':
104  338 buffer.append((char) ('\uFF41' - 'a' + c));
105  338 break;
106  12 default:
107  12 buffer.append(c);
108    }
109    }
110  124 return buffer.toString();
111    }
112   
113    /**
114    * Transform into mathfrak characters.
115    *
116    * @param token String to transform.
117    * @return Result of transformation.
118    */
 
119  506 toggle public static String transform2Mathfrak(final String token) {
120  506 final StringBuffer buffer = new StringBuffer();
121  1138 for (int i = 0; i < token.length(); i++) {
122  632 final char c = token.charAt(i);
123  632 switch (c) {
124  0 case 'A': buffer.append("\u13AF");
125  0 break;
126  0 case 'B': buffer.append("\u212C");
127  0 break;
128  0 case 'b': buffer.append("\u13B2");
129  0 break;
130  0 case 'C': buffer.append("\u212D");
131  0 break;
132  0 case 'E': buffer.append("\u2130");
133  0 break;
134  22 case 'e': buffer.append("\u212F");
135  22 break;
136  6 case 'F': buffer.append("\u2131");
137  6 break;
138  0 case 'G': buffer.append("\u13B6");
139  0 break;
140  4 case 'g': buffer.append("\u210A");
141  4 break;
142  14 case 'L': buffer.append("\u2112");
143  14 break;
144  22 case 'l': buffer.append("\u2113");
145  22 break;
146  304 case 'M': buffer.append("\u2133");
147  304 break;
148  10 case 'o': buffer.append("\u2134");
149  10 break;
150  41 case 'P': buffer.append("\u2118");
151  41 break;
152  56 case 'R': buffer.append("\u211B");
153  56 break;
154  0 case 'S': buffer.append("\u093D");
155  0 break;
156  0 case 's': buffer.append("\u0D1F");
157  0 break;
158  0 case 'T': buffer.append("\u01AC");
159  0 break;
160  75 case 'V': buffer.append("\u01B2");
161  75 break;
162  0 case 'Y': buffer.append("\u01B3");
163  0 break;
164  0 case 'Z': buffer.append("\u2128");
165  0 break;
166  78 default:
167  78 buffer.append(c);
168    }
169    }
170  506 return buffer.toString();
171    }
172   
173    /**
174    * Transform into subscript characters.
175    *
176    * @param content String to transform.
177    * @return Result of transformation.
178    */
 
179  706 toggle public static String transform2Subscript(final String content) {
180  706 final StringBuffer buffer = new StringBuffer();
181  706 boolean supported = true;
182  1128 for (int i = 0; i < content.length(); i++) {
183  706 if (SUBSCRIPT_CHARACTERS.indexOf(content.charAt(i)) < 0) {
184  284 supported = false;
185  284 break;
186    }
187    }
188  706 if (!supported) {
189  284 if (content.length() == 1) {
190  268 buffer.append("_" + content);
191    } else {
192  16 buffer.append("_(" + content + ")");
193    }
194    } else {
195  844 for (int i = 0; i < content.length(); i++) {
196  422 final char c = content.charAt(i);
197  422 switch (c) {
198  2 case '0':
199  368 case '1':
200  32 case '2':
201  8 case '3':
202  4 case '4':
203  8 case '5':
204  0 case '6':
205  0 case '7':
206  0 case '8':
207  0 case '9':
208  422 buffer.append((char) (c - '0' + '\u2080'));
209  422 break;
210  0 case '+':
211  0 buffer.append('\u208A');
212  0 break;
213  0 case '-':
214  0 buffer.append('\u208B');
215  0 break;
216  0 case '=':
217  0 buffer.append('\u208C');
218  0 break;
219  0 case '(':
220  0 buffer.append('\u208D');
221  0 break;
222  0 case ')':
223  0 buffer.append('\u208E');
224  0 break;
225  0 default:
226  0 buffer.append(c);
227    }
228    }
229    }
230  706 return buffer.toString();
231    }
232   
233    /**
234    * Transform into superscript characters.
235    *
236    * @param content String to transform.
237    * @return Result of transformation.
238    */
 
239  80 toggle public static String transform2Superscript(final String content) {
240  80 final StringBuffer buffer = new StringBuffer();
241  80 boolean supported = true;
242  108 for (int i = 0; i < content.length(); i++) {
243  80 if (SUPERSCRIPT_CHARACTERS.indexOf(content.charAt(i)) < 0) {
244  52 supported = false;
245  52 break;
246    }
247    }
248  80 if (!supported) {
249  52 if (content.length() == 1) {
250  48 buffer.append("^" + content);
251    } else {
252  4 buffer.append("^(" + content + ")");
253    }
254    } else {
255  56 for (int i = 0; i < content.length(); i++) {
256  28 final char c = content.charAt(i);
257  28 switch (c) {
258  12 case '0':
259  12 buffer.append((char) (c - '0' + '\u2070'));
260  12 break;
261  0 case '1':
262  0 buffer.append((char) (c - '0' + '\u00B9'));
263  0 break;
264  0 case '2':
265  0 buffer.append((char) (c - '0' + '\u00B2'));
266  0 break;
267  0 case '3':
268  0 buffer.append((char) (c - '0' + '\u00B3'));
269  0 break;
270  0 case '4':
271  0 case '5':
272  0 case '6':
273  0 case '7':
274  0 case '8':
275  0 case '9':
276  0 buffer.append((char) (c - '4' + '\u2074'));
277  0 break;
278  0 case '+':
279  0 buffer.append('\u207A');
280  0 break;
281  0 case '-':
282  0 buffer.append('\u207B');
283  0 break;
284  0 case '=':
285  0 buffer.append('\u207C');
286  0 break;
287  0 case '(':
288  0 buffer.append('\u207D');
289  0 break;
290  0 case ')':
291  0 buffer.append('\u207E');
292  0 break;
293  16 case 'n':
294  16 buffer.append('\u207F');
295  16 break;
296  0 default:
297  0 buffer.append(c);
298    }
299    }
300    }
301  80 return buffer.toString();
302    }
303   
304    /**
305    * Transform into emph characters.
306    *
307    * @param token String to transform.
308    * @return Result of transformation.
309    */
 
310  1336 toggle public static String transform2Emph(final String token) {
311  1336 final StringBuffer buffer = new StringBuffer();
312  7507 for (int i = 0; i < token.length(); i++) {
313    // buffer.append('\u2006');
314  6171 buffer.append(' ');
315  6171 buffer.append(token.charAt(i));
316    }
317  1336 return buffer.toString();
318    }
319    }
 
CloverReport generated by Clover Code Coverage v3.1.10
Fri May 24 2013 13:47:32 UTC.		   Clover: Open Source License registered to qedeq.org .