1 Clazz.load (["java.lang.CharSequence", "$.Comparable", "java.io.Serializable", "java.util.Comparator"], "java.lang.String", null, function () {
\r
2 if (String.prototype.$replace == null) { // not defined yet! ClazzLoader may try to load this twice!
\r
3 java.lang.String = String;
\r
4 if (Clazz.supportsNativeObject) {
\r
5 for (var i = 0; i < Clazz.extendedObjectMethods.length; i++) {
\r
6 var p = Clazz.extendedObjectMethods[i];
\r
7 if ("to$tring" == p || "toString" == p || "equals" == p || "hashCode" == p) {
\r
10 String.prototype[p] = Clazz._O.prototype[p];
\r
13 //Clazz.decorateAsType (String, "String", null, [java.io.Serializable, CharSequence, Comparable]);
\r
14 Clazz.implementOf (String, [java.io.Serializable, CharSequence, Comparable]);
\r
15 //Number.equals = Clazz.innerFunctions.equals;
\r
16 String.getName = Clazz.innerFunctions.getName;
\r
18 String.serialVersionUID = String.prototype.serialVersionUID = -6849794470754667710;
\r
20 String.prototype.$replace = function (c1, c2) {
\r
22 var sp = "\\$.*+{}?^()[]";
\r
23 if (sp.indexOf (c1) != -1) {
\r
27 c1 = c1.replace (/([\\\/\$\.\*\+\{\}\?\^\(\)\[\]])/g, function ($0, $1) {
\r
30 var regExp = new RegExp (c1, "gm");
\r
31 return this.replace (regExp, c2);
\r
33 String.prototype.$generateExpFunction = function (str) {
\r
39 for (; i < str.length; i++) {
\r
40 var ch = str.charAt (i);
\r
41 if (i != str.length - 1 && ch == '\\') {
\r
43 var c = str.charAt (i);
\r
48 } else if (i != str.length - 1 && ch == '$') {
\r
50 orders[idx] = parseInt (str.charAt (i));
\r
53 } else if (ch == '\r') {
\r
55 } else if (ch == '\n') {
\r
57 } else if (ch == '\t') {
\r
59 } else if (ch == '\"') {
\r
65 var funStr = "f = function (";
\r
66 var max = Math.max.apply({},orders);
\r
67 for (i = 0; i <= max; i++) {
\r
73 funStr += ") { return ";
\r
74 for (i = 0; i < arr.length - 1; i++) {
\r
75 funStr += "\"" + arr[i] + "\" + $" + orders[i] + " + ";
\r
77 funStr += "\"" + arr[i] + "\"; }";
\r
83 String.prototype.replaceAll = function (exp, str) {
\r
84 var regExp = new RegExp (exp, "gm");
\r
85 return this.replace (regExp, this.$generateExpFunction (str));
\r
87 String.prototype.replaceFirst = function (exp, str) {
\r
88 var regExp = new RegExp (exp, "m");
\r
89 return this.replace (regExp, this.$generateExpFunction (str));
\r
91 String.prototype.matches = function (exp) {
\r
93 exp = "^(" + exp + ")$";
\r
95 var regExp = new RegExp (exp, "gm");
\r
96 var m = this.match (regExp);
\r
97 return m != null && m.length != 0;
\r
99 String.prototype.regionMatches = function (ignoreCase, toffset,
\r
100 other, ooffset, len) {
\r
102 * Support different method signatures
\r
104 if (typeof ignoreCase == "number"
\r
105 || (ignoreCase != true && ignoreCase != false)) {
\r
109 toffset = ignoreCase;
\r
110 ignoreCase = false;
\r
114 // Note: toffset, ooffset, or len might be near -1>>>1.
\r
115 if ((ooffset < 0) || (toffset < 0) || (toffset > this.length - len) ||
\r
116 (ooffset > other.length - len)) {
\r
119 var s1 = this.substring (toffset, toffset + len);
\r
120 var s2 = other.substring (ooffset, ooffset + len);
\r
122 s1 = s1.toLowerCase ();
\r
123 s2 = s2.toLowerCase ();
\r
127 String.prototype.$plit = function (regex, limit) {
\r
129 * Support different method signatures
\r
131 if (limit != null && limit > 0) {
\r
135 var regExp = new RegExp ("(" + regex + ")", "gm");
\r
137 var s = this.replace (regExp, function ($0, $1) {
\r
139 if (count == limit) {
\r
141 } else if (count > limit) {
\r
147 regExp = new RegExp (regex, "gm");
\r
148 var arr = this.split (regExp);
\r
149 if (arr.length > limit) {
\r
150 arr[limit - 1] = s.substring (s.indexOf ("@@_@@") + 5);
\r
151 arr.length = limit;
\r
155 var regExp = new RegExp (regex, "gm");
\r
156 return this.split (regExp);
\r
160 String.prototype.trim = function () {
\r
161 var len = this.length;
\r
164 while ((st < len) && (this.charAt (st) <= ' ')) {
\r
167 while ((st < len) && (this.charAt (len - 1) <= ' ')) {
\r
170 return ((st > 0) || (len < len)) ? this.substring (st, len) : this;
\r
173 String.prototype.trim = function () {
\r
174 return this.replace (/^\s+/g, '').replace (/\s+$/g, '');
\r
178 String.prototype.startsWith_string_number = function (prefix, toffset) {
\r
181 var pc = prefix.length;
\r
182 // Note: toffset might be near -1>>>1.
\r
183 if ((toffset < 0) || (toffset > this.length - pc)) {
\r
186 while (--pc >= 0) {
\r
187 if (this.charAt (to++) != prefix.charAt (po++)) {
\r
194 String.prototype.startsWith = function (prefix) { /* prefix, toffset */
\r
195 if (arguments.length == 1) {
\r
196 return this.startsWith_string_number (arguments[0], 0);
\r
197 } else if (arguments.length == 2) {
\r
198 return this.startsWith_string_number (arguments[0], arguments[1]);
\r
204 String.prototype.endsWith = function (suffix) {
\r
205 return this.startsWith (suffix, this.length - suffix.length);
\r
208 String.prototype.equals = function (anObject) {
\r
209 return this.valueOf () == anObject;
\r
212 String.prototype.equalsIgnoreCase = function (anotherString) {
\r
213 return (anotherString == null) ? false : (this == anotherString
\r
214 || this.toLowerCase () == anotherString.toLowerCase ());
\r
218 String.prototype.hash = 0;
\r
220 String.prototype.hashCode = function () {
\r
224 var len = this.length;
\r
225 for (var i = 0; i < len; i++) {
\r
226 h = 31*h + this.charCodeAt (off++);
\r
234 String.prototype.getBytes = function () {
\r
235 if (arguments.length == 4) {
\r
236 return this.getChars (arguments[0], arguments[1], arguments[2], arguments[3]);
\r
239 if (arguments.length == 1) {
\r
240 var cs = arguments[0].toString().toLowerCase ();
\r
242 "utf-8", "UTF8", "us-ascii", "iso-8859-1", "8859_1", "gb2312", "gb18030", "gbk"
\r
244 var existed = false;
\r
245 for (var i = 0; i < charset.length; i++) {
\r
246 if (charset[i] == cs) {
\r
252 throw new java.io.UnsupportedEncodingException ();
\r
254 if (cs == "utf-8" || cs == "utf8") {
\r
255 s = Encoding.convert2UTF8 (this);
\r
258 var arrs = new Array (s.length);
\r
260 for (var i = 0; i < s.length; i++) {
\r
261 c = s.charCodeAt (i);
\r
264 arrs[ii + 1] = c & 0xff;
\r
265 arrs[ii + 2] = (c & 0xff00) >> 8;
\r
275 String.prototype.compareTo = function (anotherString) {
\r
276 if (anotherString == null) {
\r
277 throw new java.lang.NullPointerException ();
\r
279 var len1 = this.length;
\r
280 var len2 = anotherString.length;
\r
281 var n = Math.min (len1, len2);
\r
284 var c1 = this.charCodeAt (k);
\r
285 var c2 = anotherString.charCodeAt (k);
\r
291 return len1 - len2;
\r
294 String.prototype.toCharArray = function () {
\r
295 var result = new Array (this.length);
\r
296 for (var i = 0; i < this.length; i++) {
\r
297 result[i] = this.charAt (i);
\r
301 String.value0f = String.valueOf;
\r
302 String.valueOf = function (o) {
\r
303 if (o == "undefined") {
\r
304 return String.value0f ();
\r
306 if (o instanceof Array) {
\r
307 if (arguments.length == 1) {
\r
308 return o.join ('');
\r
310 var off = arguments[1];
\r
311 var len = arguments[2];
\r
312 var oo = new Array (len);
\r
313 for (var i = 0; i < len; i++) {
\r
314 oo[i] = o[off + i];
\r
316 return oo.join ('');
\r
322 String.prototype.subSequence = function (beginIndex, endIndex) {
\r
323 return this.substring(beginIndex, endIndex);
\r
326 String.prototype.compareToIgnoreCase = function (str) {
\r
328 throw new NullPointerException ();
\r
330 var s1 = this.toUpperCase ();
\r
331 var s2 = str.toUpperCase ();
\r
335 var s1 = this.toLowerCase ();
\r
336 var s2 = str.toLowerCase ();
\r
339 } else if (s1 > s2) {
\r
347 String.prototype.contentEquals = function (sb) {
\r
348 if (this.length != sb.length ()) {
\r
351 var v = sb.getValue ();
\r
354 var n = this.length;
\r
356 if (this.charCodeAt (i++) != v[j++]) {
\r
363 String.prototype.getChars = function (srcBegin, srcEnd, dst, dstBegin) {
\r
364 if (srcBegin < 0) {
\r
365 throw new StringIndexOutOfBoundsException(srcBegin);
\r
367 if (srcEnd > this.length) {
\r
368 throw new StringIndexOutOfBoundsException(srcEnd);
\r
370 if (srcBegin > srcEnd) {
\r
371 throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
\r
374 throw new NullPointerException ();
\r
376 for (var i = 0; i < srcEnd - srcBegin; i++) {
\r
377 dst[dstBegin + i] = this.charAt (srcBegin + i);
\r
380 String.prototype.$concat = String.prototype.concat;
\r
381 String.prototype.concat = function (s) {
\r
383 throw new NullPointerException ();
\r
385 return this.$concat (s);
\r
388 String.prototype.$lastIndexOf = String.prototype.lastIndexOf;
\r
389 String.prototype.lastIndexOf = function (s, last) {
\r
390 if (last != null && last + this.length <= 0) {
\r
393 if (last != null) {
\r
394 return this.$lastIndexOf (s, last);
\r
396 return this.$lastIndexOf (s);
\r
400 String.prototype.intern = function () {
\r
401 return this.valueOf ();
\r
403 String.copyValueOf = String.prototype.copyValueOf = function () {
\r
404 if (arguments.length == 1) {
\r
405 return String.instantialize (arguments[0]);
\r
407 return String.instantialize (arguments[0], arguments[1], arguments[2]);
\r
410 String.indexOf = function (source, sourceOffset, sourceCount,
\r
411 target, targetOffset, targetCount, fromIndex) {
\r
412 if (fromIndex >= sourceCount) {
\r
413 return (targetCount == 0 ? sourceCount : -1);
\r
415 if (fromIndex < 0) {
\r
418 if (targetCount == 0) {
\r
422 var first = target[targetOffset];
\r
423 var i = sourceOffset + fromIndex;
\r
424 var max = sourceOffset + (sourceCount - targetCount);
\r
426 startSearchForFirstChar:
\r
428 /* Look for first character. */
\r
429 while (i <= max && source[i] != first) {
\r
436 /* Found first character, now look at the rest of v2 */
\r
438 var end = j + targetCount - 1;
\r
439 var k = targetOffset + 1;
\r
441 if (source[j++] != target[k++]) {
\r
443 /* Look for str's first char again. */
\r
444 continue startSearchForFirstChar;
\r
447 return i - sourceOffset; /* Found whole string. */
\r
451 String.instantialize = function () {
\r
452 if (arguments.length == 0) {
\r
453 return new String ();
\r
454 } else if (arguments.length == 1) {
\r
455 var x = arguments[0];
\r
456 if (typeof x == "string" || x instanceof String) {
\r
457 return new String (x);
\r
458 } else if (x instanceof Array || x instanceof Int32Array) {
\r
459 if (x.length > 0 && typeof x[0] == "number") {
\r
460 var arr = new Array (x.length);
\r
461 for (var i = 0; i < x.length; i++) {
\r
462 arr[i] = String.fromCharCode (x[i] & 0xff);
\r
464 return Encoding.readUTF8 (arr.join (''));
\r
466 return x.join ('');
\r
467 } else if (x.__CLASS_NAME__ == "StringBuffer"
\r
468 || x.__CLASS_NAME__ == "java.lang.StringBuffer") {
\r
469 var value = x.shareValue();
\r
470 var length = x.length ();
\r
471 var valueCopy = new Array (length);
\r
472 for (var i = 0; i < length; i++) {
\r
473 valueCopy[i] = value[i];
\r
475 return valueCopy.join ('')
\r
476 //return x.value.join ('');
\r
480 } else if (arguments.length == 2) {
\r
481 var x = arguments[0];
\r
482 var hibyte=arguments[1];
\r
483 if (typeof hibyte == "string") {
\r
484 return String.instantialize(x,0,x.length, hibyte);
\r
486 return String.instantialize(x,hibyte,0,x.length);
\r
488 } else if (arguments.length == 3) {
\r
489 var bytes = arguments[0];
\r
490 var offset = arguments[1];
\r
491 var length = arguments[2];
\r
492 if (arguments[2] instanceof Array) {
\r
493 bytes = arguments[2];
\r
494 offset = arguments[0];
\r
495 length = arguments[1];
\r
497 var arr = new Array (length);
\r
498 if (offset < 0 || length + offset > bytes.length) {
\r
499 throw new IndexOutOfBoundsException ();
\r
502 var isChar = (bytes[offset].length != null);
\r
504 for (var i = 0; i < length; i++) {
\r
505 arr[i] = bytes[offset + i];
\r
508 for (var i = 0; i < length; i++) {
\r
509 arr[i]=String.fromCharCode (bytes[offset+i]);
\r
513 return arr.join ('');
\r
514 } else if (arguments.length == 4) {
\r
515 var bytes = arguments[0];
\r
516 var y = arguments[3];
\r
517 if (typeof y == "string" || y instanceof String) {
\r
518 var offset = arguments[1];
\r
519 var length = arguments[2];
\r
520 var arr = new Array (length);
\r
521 for (var i = 0; i < length; i++) {
\r
522 arr[i] = bytes[offset + i];
\r
523 if (typeof arr[i] == "number") {
\r
524 arr[i] = String.fromCharCode (arr[i] & 0xff);
\r
527 var cs = y.toLowerCase ();
\r
528 if (cs == "utf-8" || cs == "utf8") {
\r
529 return Encoding.readUTF8 (arr.join (''));
\r
531 return arr.join ('');
\r
534 var count = arguments[3];
\r
535 var offset = arguments[2];
\r
536 var hibyte = arguments[1];
\r
537 var value = new Array (count);
\r
539 for (var i = count ; i-- > 0 ;) {
\r
540 value[i] = String.fromCharCode (bytes[i + offset] & 0xff);
\r
544 for (var i = count ; i-- > 0 ;) {
\r
545 value[i] = String.fromCharCode (hibyte | (bytes[i + offset] & 0xff));
\r
548 return value.join ('');
\r
552 for (var i = 0; i < arguments.length; i++) {
\r
559 if (navigator.userAgent.toLowerCase ().indexOf ("chrome") != -1) { // Google Chrome's bug
\r
560 String.prototype.toString = function () {
\r
565 } // end of String.prototype.$replace
\r