1 Clazz.declarePackage ("JU");
\r
2 Clazz.load (null, "JU.PT", ["java.lang.Boolean", "$.Double", "$.Float", "$.Number", "java.util.Map", "javajs.api.JSONEncodable", "JU.AU", "$.DF", "$.Lst", "$.M34", "$.M4", "$.SB"], function () {
\r
3 c$ = Clazz.declareType (JU, "PT");
\r
4 c$.parseInt = Clazz.defineMethod (c$, "parseInt",
\r
6 return JU.PT.parseIntNext (str, Clazz.newIntArray (-1, [0]));
\r
8 c$.parseIntNext = Clazz.defineMethod (c$, "parseIntNext",
\r
9 function (str, next) {
\r
10 var cch = str.length;
\r
11 if (next[0] < 0 || next[0] >= cch) return -2147483648;
\r
12 return JU.PT.parseIntChecked (str, cch, next);
\r
14 c$.parseIntChecked = Clazz.defineMethod (c$, "parseIntChecked",
\r
15 function (str, ichMax, next) {
\r
16 var digitSeen = false;
\r
19 if (ich < 0) return -2147483648;
\r
21 while (ich < ichMax && JU.PT.isWhiteSpace (str, ich)) ++ich;
\r
23 var negative = false;
\r
24 if (ich < ichMax && str.charCodeAt (ich) == 45) {
\r
27 }while (ich < ichMax && (ch = str.charCodeAt (ich)) >= 48 && ch <= 57) {
\r
28 value = value * 10 + (ch - 48);
\r
32 if (!digitSeen) value = -2147483648;
\r
33 else if (negative) value = -value;
\r
37 c$.isWhiteSpace = Clazz.defineMethod (c$, "isWhiteSpace",
\r
38 function (str, ich) {
\r
40 return (ich >= 0 && ((ch = str.charAt (ich)) == ' ' || ch == '\t' || ch == '\n'));
\r
42 c$.parseFloatChecked = Clazz.defineMethod (c$, "parseFloatChecked",
\r
43 function (str, ichMax, next, isStrict) {
\r
44 var digitSeen = false;
\r
46 if (isStrict && str.indexOf ('\n') != str.lastIndexOf ('\n')) return NaN;
\r
47 while (ich < ichMax && JU.PT.isWhiteSpace (str, ich)) ++ich;
\r
49 var negative = false;
\r
50 if (ich < ichMax && str.charAt (ich) == '-') {
\r
56 while (ich < ichMax && (ch = str.charCodeAt (ich)) >= 48 && ch <= 57) {
\r
57 ival = (ival * 10) + (ch - 48) * 1;
\r
61 var isDecimal = false;
\r
63 var nzero = (ival == 0 ? -1 : 0);
\r
66 while (++ich < ichMax && (ch = str.charCodeAt (ich)) >= 48 && ch <= 57) {
\r
73 }if (iscale < JU.PT.decimalScale.length) {
\r
74 ival2 = (ival2 * 10) + (ch - 48) * 1;
\r
80 } else if (ival2 > 0) {
\r
81 value = ival2 * JU.PT.decimalScale[iscale - 1];
\r
83 if (nzero - 2 < JU.PT.decimalScale.length) {
\r
84 value *= JU.PT.decimalScale[nzero - 2];
\r
86 value *= Math.pow (10, 1 - nzero);
\r
91 }var isExponent = false;
\r
92 if (ich < ichMax && (ch == 69 || ch == 101 || ch == 68)) {
\r
94 if (++ich >= ichMax) return NaN;
\r
95 ch = str.charCodeAt (ich);
\r
96 if ((ch == 43) && (++ich >= ichMax)) return NaN;
\r
98 var exponent = JU.PT.parseIntChecked (str, ichMax, next);
\r
99 if (exponent == -2147483648) return NaN;
\r
100 if (exponent > 0 && exponent <= JU.PT.tensScale.length) value *= JU.PT.tensScale[exponent - 1];
\r
101 else if (exponent < 0 && -exponent <= JU.PT.decimalScale.length) value *= JU.PT.decimalScale[-exponent - 1];
\r
102 else if (exponent != 0) value *= Math.pow (10, exponent);
\r
105 }if (negative) value = -value;
\r
106 if (value == Infinity) value = 3.4028235E38;
\r
107 return (!isStrict || (!isExponent || isDecimal) && JU.PT.checkTrailingText (str, next[0], ichMax) ? value : NaN);
\r
109 c$.checkTrailingText = Clazz.defineMethod (c$, "checkTrailingText",
\r
110 function (str, ich, ichMax) {
\r
112 while (ich < ichMax && (JU.PT.isWhitespace (ch = str.charAt (ich)) || ch == ';')) ++ich;
\r
114 return (ich == ichMax);
\r
116 c$.parseFloatArray = Clazz.defineMethod (c$, "parseFloatArray",
\r
118 return JU.PT.parseFloatArrayNext (str, Clazz.newIntArray (1, 0), null, null, null);
\r
120 c$.parseFloatArrayInfested = Clazz.defineMethod (c$, "parseFloatArrayInfested",
\r
121 function (tokens, data) {
\r
122 var len = data.length;
\r
123 var nTokens = tokens.length;
\r
126 for (var i = 0; i >= 0 && i < len && n < nTokens; i++) {
\r
128 while (Float.isNaN (f = JU.PT.parseFloat (tokens[n++])) && n < nTokens) {
\r
130 if (!Float.isNaN (f)) data[(max = i)] = f;
\r
131 if (n == nTokens) break;
\r
135 c$.parseFloatArrayNext = Clazz.defineMethod (c$, "parseFloatArrayNext",
\r
136 function (str, next, f, strStart, strEnd) {
\r
140 if (strStart != null) {
\r
141 var p = str.indexOf (strStart, pt);
\r
142 if (p >= 0) next[0] = p + strStart.length;
\r
143 }str = str.substring (next[0]);
\r
144 pt = (strEnd == null ? -1 : str.indexOf (strEnd));
\r
145 if (pt < 0) pt = str.length;
\r
146 else str = str.substring (0, pt);
\r
148 var tokens = JU.PT.getTokens (str);
\r
149 if (f == null) f = Clazz.newFloatArray (tokens.length, 0);
\r
150 n = JU.PT.parseFloatArrayInfested (tokens, f);
\r
151 }if (f == null) return Clazz.newFloatArray (0, 0);
\r
152 for (var i = n; i < f.length; i++) f[i] = NaN;
\r
155 }, "~S,~A,~A,~S,~S");
\r
156 c$.parseFloatRange = Clazz.defineMethod (c$, "parseFloatRange",
\r
157 function (str, ichMax, next) {
\r
158 var cch = str.length;
\r
159 if (ichMax > cch) ichMax = cch;
\r
160 if (next[0] < 0 || next[0] >= ichMax) return NaN;
\r
161 return JU.PT.parseFloatChecked (str, ichMax, next, false);
\r
163 c$.parseFloatNext = Clazz.defineMethod (c$, "parseFloatNext",
\r
164 function (str, next) {
\r
165 var cch = (str == null ? -1 : str.length);
\r
166 return (next[0] < 0 || next[0] >= cch ? NaN : JU.PT.parseFloatChecked (str, cch, next, false));
\r
168 c$.parseFloatStrict = Clazz.defineMethod (c$, "parseFloatStrict",
\r
170 var cch = str.length;
\r
171 if (cch == 0) return NaN;
\r
172 return JU.PT.parseFloatChecked (str, cch, Clazz.newIntArray (-1, [0]), true);
\r
174 c$.parseFloat = Clazz.defineMethod (c$, "parseFloat",
\r
176 return JU.PT.parseFloatNext (str, Clazz.newIntArray (-1, [0]));
\r
178 c$.parseIntRadix = Clazz.defineMethod (c$, "parseIntRadix",
\r
181 return Integer.parseIntRadix(s, i);
\r
183 c$.getTokens = Clazz.defineMethod (c$, "getTokens",
\r
185 return JU.PT.getTokensAt (line, 0);
\r
187 c$.parseToken = Clazz.defineMethod (c$, "parseToken",
\r
189 return JU.PT.parseTokenNext (str, Clazz.newIntArray (-1, [0]));
\r
191 c$.parseTrimmed = Clazz.defineMethod (c$, "parseTrimmed",
\r
193 return JU.PT.parseTrimmedRange (str, 0, str.length);
\r
195 c$.parseTrimmedAt = Clazz.defineMethod (c$, "parseTrimmedAt",
\r
196 function (str, ichStart) {
\r
197 return JU.PT.parseTrimmedRange (str, ichStart, str.length);
\r
199 c$.parseTrimmedRange = Clazz.defineMethod (c$, "parseTrimmedRange",
\r
200 function (str, ichStart, ichMax) {
\r
201 var cch = str.length;
\r
202 if (ichMax < cch) cch = ichMax;
\r
203 if (cch < ichStart) return "";
\r
204 return JU.PT.parseTrimmedChecked (str, ichStart, cch);
\r
206 c$.getTokensAt = Clazz.defineMethod (c$, "getTokensAt",
\r
207 function (line, ich) {
\r
208 if (line == null) return null;
\r
209 var cchLine = line.length;
\r
210 if (ich < 0 || ich > cchLine) return null;
\r
211 var tokenCount = JU.PT.countTokens (line, ich);
\r
212 var tokens = new Array (tokenCount);
\r
213 var next = Clazz.newIntArray (1, 0);
\r
215 for (var i = 0; i < tokenCount; ++i) tokens[i] = JU.PT.parseTokenChecked (line, cchLine, next);
\r
219 c$.countTokens = Clazz.defineMethod (c$, "countTokens",
\r
220 function (line, ich) {
\r
221 var tokenCount = 0;
\r
222 if (line != null) {
\r
223 var ichMax = line.length;
\r
225 while (ich < ichMax && JU.PT.isWhiteSpace (line, ich)) ++ich;
\r
227 if (ich == ichMax) break;
\r
231 } while (ich < ichMax && !JU.PT.isWhiteSpace (line, ich));
\r
233 }return tokenCount;
\r
235 c$.parseTokenNext = Clazz.defineMethod (c$, "parseTokenNext",
\r
236 function (str, next) {
\r
237 var cch = str.length;
\r
238 return (next[0] < 0 || next[0] >= cch ? null : JU.PT.parseTokenChecked (str, cch, next));
\r
240 c$.parseTokenRange = Clazz.defineMethod (c$, "parseTokenRange",
\r
241 function (str, ichMax, next) {
\r
242 var cch = str.length;
\r
243 if (ichMax > cch) ichMax = cch;
\r
244 return (next[0] < 0 || next[0] >= ichMax ? null : JU.PT.parseTokenChecked (str, ichMax, next));
\r
246 c$.parseTokenChecked = Clazz.defineMethod (c$, "parseTokenChecked",
\r
247 function (str, ichMax, next) {
\r
249 while (ich < ichMax && JU.PT.isWhiteSpace (str, ich)) ++ich;
\r
251 var ichNonWhite = ich;
\r
252 while (ich < ichMax && !JU.PT.isWhiteSpace (str, ich)) ++ich;
\r
255 return (ichNonWhite == ich ? null : str.substring (ichNonWhite, ich));
\r
257 c$.parseTrimmedChecked = Clazz.defineMethod (c$, "parseTrimmedChecked",
\r
258 function (str, ich, ichMax) {
\r
259 while (ich < ichMax && JU.PT.isWhiteSpace (str, ich)) ++ich;
\r
261 var ichLast = ichMax - 1;
\r
262 while (ichLast >= ich && JU.PT.isWhiteSpace (str, ichLast)) --ichLast;
\r
264 return (ichLast < ich ? "" : str.substring (ich, ichLast + 1));
\r
266 c$.dVal = Clazz.defineMethod (c$, "dVal",
\r
270 throw new NumberFormatException("null");
\r
271 var d=parseFloat(s);
\r
273 throw new NumberFormatException("Not a Number : "+s);
\r
276 c$.fVal = Clazz.defineMethod (c$, "fVal",
\r
279 return this.dVal(s);
\r
281 c$.parseIntRange = Clazz.defineMethod (c$, "parseIntRange",
\r
282 function (str, ichMax, next) {
\r
283 var cch = str.length;
\r
284 if (ichMax > cch) ichMax = cch;
\r
285 return (next[0] < 0 || next[0] >= ichMax ? -2147483648 : JU.PT.parseIntChecked (str, ichMax, next));
\r
287 c$.parseFloatArrayData = Clazz.defineMethod (c$, "parseFloatArrayData",
\r
288 function (tokens, data) {
\r
289 JU.PT.parseFloatArrayDataN (tokens, data, data.length);
\r
291 c$.parseFloatArrayDataN = Clazz.defineMethod (c$, "parseFloatArrayDataN",
\r
292 function (tokens, data, nData) {
\r
293 for (var i = nData; --i >= 0; ) data[i] = (i >= tokens.length ? NaN : JU.PT.parseFloat (tokens[i]));
\r
296 c$.split = Clazz.defineMethod (c$, "split",
\r
297 function (text, run) {
\r
298 if (text.length == 0) return new Array (0);
\r
300 var i = text.indexOf (run);
\r
302 var runLen = run.length;
\r
303 if (i < 0 || runLen == 0) {
\r
304 lines = new Array (1);
\r
307 }var len = text.length - runLen;
\r
308 for (; i >= 0 && i < len; n++) i = text.indexOf (run, i + runLen);
\r
310 lines = new Array (n);
\r
314 for (; (ipt = text.indexOf (run, i)) >= 0 && pt + 1 < n; ) {
\r
315 lines[pt++] = text.substring (i, ipt);
\r
318 if (text.indexOf (run, len) != len) len += runLen;
\r
319 lines[pt] = text.substring (i, len);
\r
322 c$.getQuotedStringAt = Clazz.defineMethod (c$, "getQuotedStringAt",
\r
323 function (line, ipt0) {
\r
324 var next = Clazz.newIntArray (-1, [ipt0]);
\r
325 return JU.PT.getQuotedStringNext (line, next);
\r
327 c$.getQuotedStringNext = Clazz.defineMethod (c$, "getQuotedStringNext",
\r
328 function (line, next) {
\r
330 if (i < 0 || (i = line.indexOf ("\"", i)) < 0) return "";
\r
332 var len = line.length;
\r
333 while (++i < len && line.charAt (i) != '"') if (line.charAt (i) == '\\') i++;
\r
336 return line.substring (pt, i);
\r
338 c$.getCSVString = Clazz.defineMethod (c$, "getCSVString",
\r
339 function (line, next) {
\r
341 if (i < 0 || (i = line.indexOf ("\"", i)) < 0) return null;
\r
342 var pt = next[0] = i;
\r
343 var len = line.length;
\r
344 var escaped = false;
\r
345 var haveEscape = false;
\r
346 while (++i < len && (line.charAt (i) != '"' || (escaped = (i + 1 < len && line.charAt (i + 1) == '"')))) if (escaped) {
\r
355 var s = line.substring (pt + 1, i);
\r
356 return (haveEscape ? JU.PT.rep (JU.PT.rep (s, "\"\"", "\0"), "\0", "\"") : s);
\r
358 c$.isOneOf = Clazz.defineMethod (c$, "isOneOf",
\r
359 function (key, semiList) {
\r
360 if (semiList.length == 0) return false;
\r
361 if (semiList.charAt (0) != ';') semiList = ";" + semiList + ";";
\r
362 return key.indexOf (";") < 0 && semiList.indexOf (';' + key + ';') >= 0;
\r
364 c$.getQuotedAttribute = Clazz.defineMethod (c$, "getQuotedAttribute",
\r
365 function (info, name) {
\r
366 var i = info.indexOf (name + "=");
\r
367 return (i < 0 ? null : JU.PT.getQuotedStringAt (info, i));
\r
369 c$.approx = Clazz.defineMethod (c$, "approx",
\r
371 return Math.round (f * n) / n;
\r
373 c$.rep = Clazz.defineMethod (c$, "rep",
\r
374 function (str, strFrom, strTo) {
\r
375 if (str == null || strFrom.length == 0 || str.indexOf (strFrom) < 0) return str;
\r
376 var isOnce = (strTo.indexOf (strFrom) >= 0);
\r
378 str = str.$replace (strFrom, strTo);
\r
379 } while (!isOnce && str.indexOf (strFrom) >= 0);
\r
382 c$.formatF = Clazz.defineMethod (c$, "formatF",
\r
383 function (value, width, precision, alignLeft, zeroPad) {
\r
384 return JU.PT.formatS (JU.DF.formatDecimal (value, precision), width, 0, alignLeft, zeroPad);
\r
385 }, "~N,~N,~N,~B,~B");
\r
386 c$.formatD = Clazz.defineMethod (c$, "formatD",
\r
387 function (value, width, precision, alignLeft, zeroPad, allowOverflow) {
\r
388 return JU.PT.formatS (JU.DF.formatDecimal (value, -1 - precision), width, 0, alignLeft, zeroPad);
\r
389 }, "~N,~N,~N,~B,~B,~B");
\r
390 c$.formatS = Clazz.defineMethod (c$, "formatS",
\r
391 function (value, width, precision, alignLeft, zeroPad) {
\r
392 if (value == null) return "";
\r
393 var len = value.length;
\r
394 if (precision != 2147483647 && precision > 0 && precision < len) value = value.substring (0, precision);
\r
395 else if (precision < 0 && len + precision >= 0) value = value.substring (len + precision + 1);
\r
396 var padLength = width - value.length;
\r
397 if (padLength <= 0) return value;
\r
398 var isNeg = (zeroPad && !alignLeft && value.charAt (0) == '-');
\r
399 var padChar = (zeroPad ? '0' : ' ');
\r
400 var padChar0 = (isNeg ? '-' : padChar);
\r
401 var sb = new JU.SB ();
\r
402 if (alignLeft) sb.append (value);
\r
403 sb.appendC (padChar0);
\r
404 for (var i = padLength; --i > 0; ) sb.appendC (padChar);
\r
406 if (!alignLeft) sb.append (isNeg ? padChar + value.substring (1) : value);
\r
407 return sb.toString ();
\r
408 }, "~S,~N,~N,~B,~B");
\r
409 c$.replaceWithCharacter = Clazz.defineMethod (c$, "replaceWithCharacter",
\r
410 function (str, strFrom, chTo) {
\r
411 if (str == null) return null;
\r
412 for (var i = strFrom.length; --i >= 0; ) str = str.$replace (strFrom.charAt (i), chTo);
\r
416 c$.replaceAllCharacters = Clazz.defineMethod (c$, "replaceAllCharacters",
\r
417 function (str, strFrom, strTo) {
\r
418 for (var i = strFrom.length; --i >= 0; ) {
\r
419 var chFrom = strFrom.substring (i, i + 1);
\r
420 str = JU.PT.rep (str, chFrom, strTo);
\r
424 c$.trim = Clazz.defineMethod (c$, "trim",
\r
425 function (str, chars) {
\r
426 if (chars.length == 0) return str.trim ();
\r
427 var len = str.length;
\r
429 while (k < len && chars.indexOf (str.charAt (k)) >= 0) k++;
\r
431 var m = str.length - 1;
\r
432 while (m > k && chars.indexOf (str.charAt (m)) >= 0) m--;
\r
434 return str.substring (k, m + 1);
\r
436 c$.trimQuotes = Clazz.defineMethod (c$, "trimQuotes",
\r
438 return (value != null && value.length > 1 && value.startsWith ("\"") && value.endsWith ("\"") ? value.substring (1, value.length - 1) : value);
\r
440 c$.isNonStringPrimitive = Clazz.defineMethod (c$, "isNonStringPrimitive",
\r
442 return Clazz.instanceOf (info, Number) || Clazz.instanceOf (info, Boolean);
\r
444 c$.arrayGet = Clazz.defineMethod (c$, "arrayGet",
\r
445 function (info, i) {
\r
449 c$.toJSON = Clazz.defineMethod (c$, "toJSON",
\r
450 function (infoType, info) {
\r
451 if (info == null) return JU.PT.packageJSON (infoType, null);
\r
452 if (JU.PT.isNonStringPrimitive (info)) return JU.PT.packageJSON (infoType, info.toString ());
\r
456 if (Clazz.instanceOf (info, String)) {
\r
459 if (typeof s == "undefined") s = "null"
\r
460 }if (s.indexOf ("{\"") != 0) {
\r
461 s = JU.PT.rep (s, "\"", "\\\"");
\r
462 s = JU.PT.rep (s, "\n", "\\n");
\r
463 s = "\"" + s + "\"";
\r
465 }if (Clazz.instanceOf (info, javajs.api.JSONEncodable)) {
\r
466 if ((s = (info).toJSON ()) == null) s = "null";
\r
468 }sb = new JU.SB ();
\r
469 if (Clazz.instanceOf (info, java.util.Map)) {
\r
472 for (var key, $key = (info).keySet ().iterator (); $key.hasNext () && ((key = $key.next ()) || true);) {
\r
473 sb.append (sep).append (JU.PT.packageJSON (key, JU.PT.toJSON (null, (info).get (key))));
\r
478 }if (Clazz.instanceOf (info, JU.Lst)) {
\r
480 var n = (info).size ();
\r
481 for (var i = 0; i < n; i++) {
\r
482 if (i > 0) sb.appendC (',');
\r
483 sb.append (JU.PT.toJSON (null, (info).get (i)));
\r
487 }if (Clazz.instanceOf (info, JU.M34)) {
\r
488 var len = (Clazz.instanceOf (info, JU.M4) ? 4 : 3);
\r
489 var x = Clazz.newFloatArray (len, 0);
\r
492 for (var i = 0; i < len; i++) {
\r
493 if (i > 0) sb.appendC (',');
\r
495 sb.append (JU.PT.toJSON (null, x));
\r
499 }s = JU.PT.nonArrayString (info);
\r
502 var n = JU.AU.getLength (info);
\r
503 for (var i = 0; i < n; i++) {
\r
504 if (i > 0) sb.appendC (',');
\r
505 sb.append (JU.PT.toJSON (null, JU.PT.arrayGet (info, i)));
\r
509 }info = info.toString ();
\r
511 return JU.PT.packageJSON (infoType, (s == null ? sb.toString () : s));
\r
513 c$.nonArrayString = Clazz.defineMethod (c$, "nonArrayString",
\r
516 var s = x.toString(); return (s.startsWith("[object") &&
\r
517 s.endsWith("Array]") ? null : s);
\r
519 c$.byteArrayToJSON = Clazz.defineMethod (c$, "byteArrayToJSON",
\r
521 var sb = new JU.SB ();
\r
523 var n = data.length;
\r
524 for (var i = 0; i < n; i++) {
\r
525 if (i > 0) sb.appendC (',');
\r
526 sb.appendI (data[i] & 0xFF);
\r
529 return sb.toString ();
\r
531 c$.packageJSON = Clazz.defineMethod (c$, "packageJSON",
\r
532 function (infoType, info) {
\r
533 return (infoType == null ? info : "\"" + infoType + "\": " + info);
\r
535 c$.isAS = Clazz.defineMethod (c$, "isAS",
\r
538 return Clazz.isAS(x);
\r
540 c$.isASS = Clazz.defineMethod (c$, "isASS",
\r
543 return Clazz.isASS(x);
\r
545 c$.isAP = Clazz.defineMethod (c$, "isAP",
\r
548 return Clazz.isAP(x);
\r
550 c$.isAF = Clazz.defineMethod (c$, "isAF",
\r
553 return Clazz.isAF(x);
\r
555 c$.isAFloat = Clazz.defineMethod (c$, "isAFloat",
\r
558 return Clazz.isAFloat(x);
\r
560 c$.isAD = Clazz.defineMethod (c$, "isAD",
\r
563 return Clazz.isAF(x);
\r
565 c$.isADD = Clazz.defineMethod (c$, "isADD",
\r
568 return Clazz.isAFF(x);
\r
570 c$.isAB = Clazz.defineMethod (c$, "isAB",
\r
573 return Clazz.isAI(x);
\r
575 c$.isAI = Clazz.defineMethod (c$, "isAI",
\r
578 return Clazz.isAI(x);
\r
580 c$.isAII = Clazz.defineMethod (c$, "isAII",
\r
583 return Clazz.isAII(x);
\r
585 c$.isAFF = Clazz.defineMethod (c$, "isAFF",
\r
588 return Clazz.isAFF(x);
\r
590 c$.isAFFF = Clazz.defineMethod (c$, "isAFFF",
\r
593 return Clazz.isAFFF(x);
\r
595 c$.escapeUrl = Clazz.defineMethod (c$, "escapeUrl",
\r
597 url = JU.PT.rep (url, "\n", "");
\r
598 url = JU.PT.rep (url, "%", "%25");
\r
599 url = JU.PT.rep (url, "#", "%23");
\r
600 url = JU.PT.rep (url, "[", "%5B");
\r
601 url = JU.PT.rep (url, "]", "%5D");
\r
602 url = JU.PT.rep (url, " ", "%20");
\r
605 c$.esc = Clazz.defineMethod (c$, "esc",
\r
607 if (str == null || str.length == 0) return "\"\"";
\r
608 var haveEscape = false;
\r
610 for (; i < "\\\\\tt\rr\nn\"\"".length; i += 2) if (str.indexOf ("\\\\\tt\rr\nn\"\"".charAt (i)) >= 0) {
\r
614 if (haveEscape) while (i < "\\\\\tt\rr\nn\"\"".length) {
\r
616 var ch = "\\\\\tt\rr\nn\"\"".charAt (i++);
\r
617 var ch2 = "\\\\\tt\rr\nn\"\"".charAt (i++);
\r
618 var sb = new JU.SB ();
\r
620 while ((pt = str.indexOf (ch, pt + 1)) >= 0) {
\r
621 sb.append (str.substring (pt0, pt)).appendC ('\\').appendC (ch2);
\r
624 sb.append (str.substring (pt0, str.length));
\r
625 str = sb.toString ();
\r
627 return "\"" + JU.PT.escUnicode (str) + "\"";
\r
629 c$.escUnicode = Clazz.defineMethod (c$, "escUnicode",
\r
631 for (var i = str.length; --i >= 0; ) if (str.charCodeAt (i) > 0x7F) {
\r
632 var s = "0000" + Integer.toHexString (str.charCodeAt (i));
\r
633 str = str.substring (0, i) + "\\u" + s.substring (s.length - 4) + str.substring (i + 1);
\r
637 c$.escF = Clazz.defineMethod (c$, "escF",
\r
641 if (sf.indexOf(".") < 0 && sf.indexOf("e") < 0)
\r
645 c$.join = Clazz.defineMethod (c$, "join",
\r
646 function (s, c, i0) {
\r
647 if (s.length < i0) return null;
\r
648 var sb = new JU.SB ();
\r
649 sb.append (s[i0++]);
\r
650 for (var i = i0; i < s.length; i++) sb.appendC (c).append (s[i]);
\r
652 return sb.toString ();
\r
654 c$.isLike = Clazz.defineMethod (c$, "isLike",
\r
656 var areEqual = a.equals (b);
\r
657 if (areEqual) return true;
\r
658 var isStart = b.startsWith ("*");
\r
659 var isEnd = b.endsWith ("*");
\r
660 return (!isStart && !isEnd) ? areEqual : isStart && isEnd ? b.length == 1 || a.contains (b.substring (1, b.length - 1)) : isStart ? a.endsWith (b.substring (1)) : a.startsWith (b.substring (0, b.length - 1));
\r
662 c$.getMapValueNoCase = Clazz.defineMethod (c$, "getMapValueNoCase",
\r
663 function (h, key) {
\r
664 if ("this".equals (key)) return h;
\r
665 var val = h.get (key);
\r
666 if (val == null) for (var e, $e = h.entrySet ().iterator (); $e.hasNext () && ((e = $e.next ()) || true);) if (e.getKey ().equalsIgnoreCase (key)) return e.getValue ();
\r
669 }, "java.util.Map,~S");
\r
670 c$.getMapSubset = Clazz.defineMethod (c$, "getMapSubset",
\r
671 function (h, key, h2) {
\r
672 var val = h.get (key);
\r
676 }for (var e, $e = h.entrySet ().iterator (); $e.hasNext () && ((e = $e.next ()) || true);) {
\r
677 var k = e.getKey ();
\r
678 if (JU.PT.isLike (k, key)) h2.put (k, e.getValue ());
\r
680 }, "java.util.Map,~S,java.util.Map");
\r
681 c$.clean = Clazz.defineMethod (c$, "clean",
\r
683 return JU.PT.rep (JU.PT.replaceAllCharacters (s, " \t\n\r", " "), " ", " ").trim ();
\r
685 c$.fdup = Clazz.defineMethod (c$, "fdup",
\r
686 function (f, pt, n) {
\r
689 for (var i = pt; --i >= 1; ) {
\r
690 if (JU.PT.isDigit (ch = f.charAt (i))) continue;
\r
693 if (count++ != 0) return f;
\r
696 if (i != 1 && f.charAt (i - 1) != '.') return f;
\r
702 var s = f.substring (0, pt + 1);
\r
703 var sb = new JU.SB ();
\r
704 for (var i = 0; i < n; i++) sb.append (s);
\r
706 sb.append (f.substring (pt + 1));
\r
707 return sb.toString ();
\r
709 c$.formatString = Clazz.defineMethod (c$, "formatString",
\r
710 function (strFormat, key, strT, floatT, doubleT, doOne) {
\r
711 if (strFormat == null) return null;
\r
712 if ("".equals (strFormat)) return "";
\r
713 var len = key.length;
\r
714 if (strFormat.indexOf ("%") < 0 || len == 0 || strFormat.indexOf (key) < 0) return strFormat;
\r
719 for (ich = 0; (ichPercent = strFormat.indexOf ('%', ich)) >= 0 && (ichKey = strFormat.indexOf (key, ichPercent + 1)) >= 0; ) {
\r
720 if (ich != ichPercent) strLabel += strFormat.substring (ich, ichPercent);
\r
721 ich = ichPercent + 1;
\r
722 if (ichKey > ichPercent + 6) {
\r
726 var alignLeft = false;
\r
727 if (strFormat.charAt (ich) == '-') {
\r
730 }var zeroPad = false;
\r
731 if (strFormat.charAt (ich) == '0') {
\r
736 while ((ch = strFormat.charAt (ich)) >= '0' && (ch <= '9')) {
\r
737 width = (10 * width) + (ch.charCodeAt (0) - 48);
\r
740 var precision = 2147483647;
\r
741 var isExponential = false;
\r
742 if (strFormat.charAt (ich) == '.') {
\r
744 if ((ch = strFormat.charAt (ich)) == '-') {
\r
745 isExponential = true;
\r
747 }if ((ch = strFormat.charAt (ich)) >= '0' && ch <= '9') {
\r
748 precision = ch.charCodeAt (0) - 48;
\r
750 }if (isExponential) precision = -precision - (strT == null ? 1 : 0);
\r
751 }var st = strFormat.substring (ich, ich + len);
\r
752 if (!st.equals (key)) {
\r
753 ich = ichPercent + 1;
\r
757 if (!Float.isNaN (floatT)) strLabel += JU.PT.formatF (floatT, width, precision, alignLeft, zeroPad);
\r
758 else if (strT != null) strLabel += JU.PT.formatS (strT, width, precision, alignLeft, zeroPad);
\r
759 else if (!Double.isNaN (doubleT)) strLabel += JU.PT.formatD (doubleT, width, precision, alignLeft, zeroPad, true);
\r
762 if (Clazz.exceptionOf (ioobe, IndexOutOfBoundsException)) {
\r
770 strLabel += strFormat.substring (ich);
\r
772 }, "~S,~S,~S,~N,~N,~B");
\r
773 c$.formatStringS = Clazz.defineMethod (c$, "formatStringS",
\r
774 function (strFormat, key, strT) {
\r
775 return JU.PT.formatString (strFormat, key, strT, NaN, NaN, false);
\r
777 c$.formatStringF = Clazz.defineMethod (c$, "formatStringF",
\r
778 function (strFormat, key, floatT) {
\r
779 return JU.PT.formatString (strFormat, key, null, floatT, NaN, false);
\r
781 c$.formatStringI = Clazz.defineMethod (c$, "formatStringI",
\r
782 function (strFormat, key, intT) {
\r
783 return JU.PT.formatString (strFormat, key, "" + intT, NaN, NaN, false);
\r
785 c$.sprintf = Clazz.defineMethod (c$, "sprintf",
\r
786 function (strFormat, list, values) {
\r
787 if (values == null) return strFormat;
\r
788 var n = list.length;
\r
789 if (n == values.length) try {
\r
790 for (var o = 0; o < n; o++) {
\r
791 if (values[o] == null) continue;
\r
792 switch (list.charAt (o)) {
\r
794 strFormat = JU.PT.formatString (strFormat, "s", values[o], NaN, NaN, true);
\r
797 strFormat = JU.PT.formatString (strFormat, "f", null, (values[o]).floatValue (), NaN, true);
\r
800 strFormat = JU.PT.formatString (strFormat, "d", "" + values[o], NaN, NaN, true);
\r
801 strFormat = JU.PT.formatString (strFormat, "i", "" + values[o], NaN, NaN, true);
\r
804 strFormat = JU.PT.formatString (strFormat, "e", null, NaN, (values[o]).doubleValue (), true);
\r
807 var pVal = values[o];
\r
808 strFormat = JU.PT.formatString (strFormat, "p", null, pVal.x, NaN, true);
\r
809 strFormat = JU.PT.formatString (strFormat, "p", null, pVal.y, NaN, true);
\r
810 strFormat = JU.PT.formatString (strFormat, "p", null, pVal.z, NaN, true);
\r
813 var qVal = values[o];
\r
814 strFormat = JU.PT.formatString (strFormat, "q", null, qVal.x, NaN, true);
\r
815 strFormat = JU.PT.formatString (strFormat, "q", null, qVal.y, NaN, true);
\r
816 strFormat = JU.PT.formatString (strFormat, "q", null, qVal.z, NaN, true);
\r
817 strFormat = JU.PT.formatString (strFormat, "q", null, qVal.w, NaN, true);
\r
820 var sVal = values[o];
\r
821 for (var i = 0; i < sVal.length; i++) strFormat = JU.PT.formatString (strFormat, "s", sVal[i], NaN, NaN, true);
\r
825 var fVal = values[o];
\r
826 for (var i = 0; i < fVal.length; i++) strFormat = JU.PT.formatString (strFormat, "f", null, fVal[i], NaN, true);
\r
830 var iVal = values[o];
\r
831 for (var i = 0; i < iVal.length; i++) strFormat = JU.PT.formatString (strFormat, "d", "" + iVal[i], NaN, NaN, true);
\r
833 for (var i = 0; i < iVal.length; i++) strFormat = JU.PT.formatString (strFormat, "i", "" + iVal[i], NaN, NaN, true);
\r
837 var dVal = values[o];
\r
838 for (var i = 0; i < dVal.length; i++) strFormat = JU.PT.formatString (strFormat, "e", null, NaN, dVal[i], true);
\r
842 return JU.PT.rep (strFormat, "%%", "%");
\r
844 if (Clazz.exceptionOf (e, Exception)) {
\r
849 System.out.println ("TextFormat.sprintf error " + list + " " + strFormat);
\r
850 return JU.PT.rep (strFormat, "%", "?");
\r
852 c$.formatCheck = Clazz.defineMethod (c$, "formatCheck",
\r
853 function (strFormat) {
\r
854 if (strFormat == null || strFormat.indexOf ('p') < 0 && strFormat.indexOf ('q') < 0) return strFormat;
\r
855 strFormat = JU.PT.rep (strFormat, "%%", "\1");
\r
856 strFormat = JU.PT.rep (strFormat, "%p", "%6.2p");
\r
857 strFormat = JU.PT.rep (strFormat, "%q", "%6.2q");
\r
858 var format = JU.PT.split (strFormat, "%");
\r
859 var sb = new JU.SB ();
\r
860 sb.append (format[0]);
\r
861 for (var i = 1; i < format.length; i++) {
\r
862 var f = "%" + format[i];
\r
864 if (f.length >= 3) {
\r
865 if ((pt = f.indexOf ('p')) >= 0) f = JU.PT.fdup (f, pt, 3);
\r
866 if ((pt = f.indexOf ('q')) >= 0) f = JU.PT.fdup (f, pt, 4);
\r
869 return sb.toString ().$replace ('\1', '%');
\r
871 c$.leftJustify = Clazz.defineMethod (c$, "leftJustify",
\r
872 function (s, s1, s2) {
\r
874 var n = s1.length - s2.length;
\r
875 if (n > 0) s.append (s1.substring (0, n));
\r
877 c$.rightJustify = Clazz.defineMethod (c$, "rightJustify",
\r
878 function (s, s1, s2) {
\r
879 var n = s1.length - s2.length;
\r
880 if (n > 0) s.append (s1.substring (0, n));
\r
883 c$.safeTruncate = Clazz.defineMethod (c$, "safeTruncate",
\r
885 if (f > -0.001 && f < 0.001) f = 0;
\r
886 return (f + " ").substring (0, n);
\r
888 c$.isWild = Clazz.defineMethod (c$, "isWild",
\r
890 return s != null && (s.indexOf ("*") >= 0 || s.indexOf ("?") >= 0);
\r
892 c$.isMatch = Clazz.defineMethod (c$, "isMatch",
\r
893 function (search, match, checkStar, allowInitialStar) {
\r
894 if (search.equals (match)) return true;
\r
895 var mLen = match.length;
\r
896 if (mLen == 0) return false;
\r
897 var isStar0 = (checkStar && allowInitialStar ? match.charAt (0) == '*' : false);
\r
898 if (mLen == 1 && isStar0) return true;
\r
899 var isStar1 = (checkStar && match.endsWith ("*"));
\r
900 var haveQ = (match.indexOf ('?') >= 0);
\r
902 if (isStar0) return (isStar1 ? (mLen < 3 || search.indexOf (match.substring (1, mLen - 1)) >= 0) : search.endsWith (match.substring (1)));
\r
903 else if (isStar1) return search.startsWith (match.substring (0, mLen - 1));
\r
904 }var sLen = search.length;
\r
907 while (nq < sLen) {
\r
913 match = qqqq + match.substring (1);
\r
916 match = match.substring (0, mLen - 1) + qqqq;
\r
918 }}if (mLen < sLen) return false;
\r
920 while (mLen > sLen) {
\r
921 if (allowInitialStar && match.charAt (ich) == '?') {
\r
923 } else if (match.charAt (ich + mLen - 1) != '?') {
\r
927 for (var i = sLen; --i >= 0; ) {
\r
928 var chm = match.charAt (ich + i);
\r
929 if (chm == '?') continue;
\r
930 var chs = search.charAt (i);
\r
931 if (chm != chs && (chm != '\1' || chs != '?')) return false;
\r
935 c$.replaceQuotedStrings = Clazz.defineMethod (c$, "replaceQuotedStrings",
\r
936 function (s, list, newList) {
\r
937 var n = list.size ();
\r
938 for (var i = 0; i < n; i++) {
\r
939 var name = list.get (i);
\r
940 var newName = newList.get (i);
\r
941 if (!newName.equals (name)) s = JU.PT.rep (s, "\"" + name + "\"", "\"" + newName + "\"");
\r
944 }, "~S,JU.Lst,JU.Lst");
\r
945 c$.replaceStrings = Clazz.defineMethod (c$, "replaceStrings",
\r
946 function (s, list, newList) {
\r
947 var n = list.size ();
\r
948 for (var i = 0; i < n; i++) {
\r
949 var name = list.get (i);
\r
950 var newName = newList.get (i);
\r
951 if (!newName.equals (name)) s = JU.PT.rep (s, name, newName);
\r
954 }, "~S,JU.Lst,JU.Lst");
\r
955 c$.isDigit = Clazz.defineMethod (c$, "isDigit",
\r
957 var c = (ch).charCodeAt (0);
\r
958 return (48 <= c && c <= 57);
\r
960 c$.isUpperCase = Clazz.defineMethod (c$, "isUpperCase",
\r
962 var c = (ch).charCodeAt (0);
\r
963 return (65 <= c && c <= 90);
\r
965 c$.isLowerCase = Clazz.defineMethod (c$, "isLowerCase",
\r
967 var c = (ch).charCodeAt (0);
\r
968 return (97 <= c && c <= 122);
\r
970 c$.isLetter = Clazz.defineMethod (c$, "isLetter",
\r
972 var c = (ch).charCodeAt (0);
\r
973 return (65 <= c && c <= 90 || 97 <= c && c <= 122);
\r
975 c$.isLetterOrDigit = Clazz.defineMethod (c$, "isLetterOrDigit",
\r
977 var c = (ch).charCodeAt (0);
\r
978 return (65 <= c && c <= 90 || 97 <= c && c <= 122 || 48 <= c && c <= 57);
\r
980 c$.isWhitespace = Clazz.defineMethod (c$, "isWhitespace",
\r
982 var c = (ch).charCodeAt (0);
\r
983 return (c >= 0x1c && c <= 0x20 || c >= 0x9 && c <= 0xd);
\r
985 c$.fixPtFloats = Clazz.defineMethod (c$, "fixPtFloats",
\r
987 pt.x = Math.round (pt.x * f) / f;
\r
988 pt.y = Math.round (pt.y * f) / f;
\r
989 pt.z = Math.round (pt.z * f) / f;
\r
991 c$.fixDouble = Clazz.defineMethod (c$, "fixDouble",
\r
993 return Math.round (d * f) / f;
\r
995 c$.parseFloatFraction = Clazz.defineMethod (c$, "parseFloatFraction",
\r
997 var pt = s.indexOf ("/");
\r
998 return (pt < 0 ? JU.PT.parseFloat (s) : JU.PT.parseFloat (s.substring (0, pt)) / JU.PT.parseFloat (s.substring (pt + 1)));
\r
1000 Clazz.defineStatics (c$,
\r
1001 "tensScale", Clazz.newFloatArray (-1, [10, 100, 1000, 10000, 100000, 1000000]),
\r
1002 "decimalScale", Clazz.newFloatArray (-1, [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001, 0.00000001, 0.000000001]),
\r
1003 "FLOAT_MIN_SAFE", 2E-45,
\r
1004 "escapable", "\\\\\tt\rr\nn\"\"",
\r
1005 "FRACTIONAL_PRECISION", 100000,
\r
1006 "CARTESIAN_PRECISION", 10000);
\r