EMMA Coverage Report (generated Fri Feb 14 08:28:31 UTC 2014)
[all classes][org.qedeq.kernel.bo.service.unicode]

COVERAGE SUMMARY FOR SOURCE FILE [Latex2UnicodeSpecials.java]

nameclass, %method, %block, %line, %
Latex2UnicodeSpecials.java100% (1/1)83%  (5/6)67%  (310/466)58%  (75/129)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class Latex2UnicodeSpecials100% (1/1)83%  (5/6)67%  (310/466)58%  (75/129)
Latex2UnicodeSpecials (): void 0%   (0/1)0%   (0/3)0%   (0/2)
transform2Superscript (String): String 100% (1/1)56%  (87/156)49%  (18/37)
transform2Mathfrak (String): String 100% (1/1)58%  (75/130)54%  (26/48)
transform2Subscript (String): String 100% (1/1)74%  (82/111)59%  (16/27)
transform2Bold (String): String 100% (1/1)100% (41/41)100% (10/10)
transform2Emph (String): String 100% (1/1)100% (25/25)100% (5/5)

1/* This file is part of the project "Hilbert II" - http://www.qedeq.org
2 *
3 * Copyright 2000-2014,  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 
16package org.qedeq.kernel.bo.service.unicode;
17 
18 
19/**
20 * Special LaTeX into UTF-8 transformations.
21 *
22 * @author  Michael Meyling
23 */
24public 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    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    public static String transform2Bold(final String token) {
46        final StringBuffer buffer = new StringBuffer();
47        for (int i = 0; i < token.length(); i++) {
48            final char c = token.charAt(i);
49            switch (c) {
50            case 'A':
51            case 'B':
52            case 'C':
53            case 'D':
54            case 'E':
55            case 'F':
56            case 'G':
57            case 'H':
58            case 'I':
59            case 'J':
60            case 'K':
61            case 'L':
62            case 'M':
63            case 'N':
64            case 'O':
65            case 'P':
66            case 'Q':
67            case 'R':
68            case 'S':
69            case 'T':
70            case 'U':
71            case 'V':
72            case 'W':
73            case 'X':
74            case 'Y':
75            case 'Z':
76                buffer.append((char) ('\uFF21' - 'A' + c));
77                break;
78            case 'a':
79            case 'b':
80            case 'c':
81            case 'd':
82            case 'e':
83            case 'f':
84            case 'g':
85            case 'h':
86            case 'i':
87            case 'j':
88            case 'k':
89            case 'l':
90            case 'm':
91            case 'n':
92            case 'o':
93            case 'p':
94            case 'q':
95            case 'r':
96            case 's':
97            case 't':
98            case 'u':
99            case 'v':
100            case 'w':
101            case 'x':
102            case 'y':
103            case 'z':
104                buffer.append((char) ('\uFF41' - 'a' + c));
105                break;
106            default:
107                buffer.append(c);
108            }
109        }
110        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    public static String transform2Mathfrak(final String token) {
120        final StringBuffer buffer = new StringBuffer();
121        for (int i = 0; i < token.length(); i++) {
122            final char c = token.charAt(i);
123            switch (c) {
124            case 'A': buffer.append("\u13AF");
125                break;
126            case 'B': buffer.append("\u212C");
127                break;
128            case 'b': buffer.append("\u13B2");
129                break;
130            case 'C': buffer.append("\u212D");
131                break;
132            case 'E': buffer.append("\u2130");
133                break;
134            case 'e': buffer.append("\u212F");
135                break;
136            case 'F': buffer.append("\u2131");
137                break;
138            case 'G': buffer.append("\u13B6");
139                break;
140            case 'g': buffer.append("\u210A");
141                break;
142            case 'L': buffer.append("\u2112");
143                break;
144            case 'l': buffer.append("\u2113");
145                break;
146            case 'M': buffer.append("\u2133");
147                break;
148            case 'o': buffer.append("\u2134");
149                break;
150            case 'P': buffer.append("\u2118");
151                break;
152            case 'R': buffer.append("\u211B");
153                break;
154            case 'S': buffer.append("\u093D");
155                break;
156            case 's': buffer.append("\u0D1F");
157                break;
158            case 'T': buffer.append("\u01AC");
159                break;
160            case 'V': buffer.append("\u01B2");
161                break;
162            case 'Y': buffer.append("\u01B3");
163            break;
164            case 'Z': buffer.append("\u2128");
165                break;
166            default:
167                buffer.append(c);
168            }
169        }
170        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    public static String transform2Subscript(final String content) {
180        final StringBuffer buffer = new StringBuffer();
181        boolean supported = true;
182        for (int i = 0; i < content.length(); i++) {
183            if (SUBSCRIPT_CHARACTERS.indexOf(content.charAt(i)) < 0) {
184                supported = false;
185                break;
186            }
187        }
188        if (!supported) {
189            if (content.length() == 1) {
190                buffer.append("_" + content);
191            } else {
192                buffer.append("_(" + content + ")");
193            }
194        } else {
195            for (int i = 0; i < content.length(); i++) {
196                final char c = content.charAt(i);
197                switch (c) {
198                case '0':
199                case '1':
200                case '2':
201                case '3':
202                case '4':
203                case '5':
204                case '6':
205                case '7':
206                case '8':
207                case '9':
208                    buffer.append((char) (c - '0' + '\u2080'));
209                    break;
210                case '+':
211                    buffer.append('\u208A');
212                    break;
213                case '-':
214                    buffer.append('\u208B');
215                    break;
216                case '=':
217                    buffer.append('\u208C');
218                    break;
219                case '(':
220                    buffer.append('\u208D');
221                    break;
222                case ')':
223                    buffer.append('\u208E');
224                    break;
225                default:
226                    buffer.append(c);
227                }
228            }
229        }
230        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    public static String transform2Superscript(final String content) {
240        final StringBuffer buffer = new StringBuffer();
241        boolean supported = true;
242        for (int i = 0; i < content.length(); i++) {
243            if (SUPERSCRIPT_CHARACTERS.indexOf(content.charAt(i)) < 0) {
244                supported = false;
245                break;
246            }
247        }
248        if (!supported) {
249            if (content.length() == 1) {
250                buffer.append("^" + content);
251            } else {
252                buffer.append("^(" + content + ")");
253            }
254        } else {
255            for (int i = 0; i < content.length(); i++) {
256                final char c = content.charAt(i);
257                switch (c) {
258                case '0':
259                    buffer.append((char) (c - '0' + '\u2070'));
260                    break;
261                case '1':
262                    buffer.append((char) (c - '0' + '\u00B9'));
263                    break;
264                case '2':
265                    buffer.append((char) (c - '0' + '\u00B2'));
266                    break;
267                case '3':
268                    buffer.append((char) (c - '0' + '\u00B3'));
269                    break;
270                case '4':
271                case '5':
272                case '6':
273                case '7':
274                case '8':
275                case '9':
276                    buffer.append((char) (c - '4' + '\u2074'));
277                    break;
278                case '+':
279                    buffer.append('\u207A');
280                    break;
281                case '-':
282                    buffer.append('\u207B');
283                    break;
284                case '=':
285                    buffer.append('\u207C');
286                    break;
287                case '(':
288                    buffer.append('\u207D');
289                    break;
290                case ')':
291                    buffer.append('\u207E');
292                    break;
293                case 'n':
294                    buffer.append('\u207F');
295                    break;
296                default:
297                    buffer.append(c);
298                }
299            }
300        }
301        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    public static String transform2Emph(final String token) {
311        final StringBuffer buffer = new StringBuffer();
312        for (int i = 0; i < token.length(); i++) {
313//            buffer.append('\u2006');
314            buffer.append(' ');
315            buffer.append(token.charAt(i));
316        }
317        return buffer.toString();
318    }
319}

[all classes][org.qedeq.kernel.bo.service.unicode]
EMMA 2.1.5320 (stable) (C) Vladimir Roubtsov