1 Clazz.declarePackage ("java.text");
2 Clazz.load (["java.util.AbstractMap", "$.Map", "java.text.AttributedCharacterIterator"], ["java.text.AttributedString", "$.AttributeEntry"], ["java.lang.IllegalArgumentException", "$.InternalError", "$.NullPointerException", "$.StringBuffer", "$.UnsupportedOperationException", "java.util.HashSet", "$.Hashtable", "$.Vector", "java.text.Annotation"], function () {
3 c$ = Clazz.decorateAsClass (function () {
8 this.runAttributes = null;
9 this.runAttributeValues = null;
10 if (!Clazz.isClassDefined ("java.text.AttributedString.AttributedStringIterator")) {
11 java.text.AttributedString.$AttributedString$AttributedStringIterator$ ();
13 if (!Clazz.isClassDefined ("java.text.AttributedString.AttributeMap")) {
14 java.text.AttributedString.$AttributedString$AttributeMap$ ();
16 Clazz.instantialize (this, arguments);
17 }, java.text, "AttributedString");
18 Clazz.makeConstructor (c$,
19 function (iterators) {
20 if (iterators == null) {
21 throw new NullPointerException ("Iterators must not be null");
22 }if (iterators.length == 0) {
25 var buffer = new StringBuffer ();
26 for (var counter = 0; counter < iterators.length; counter++) {
27 this.appendContents (buffer, iterators[counter]);
29 this.text = buffer.toString ();
30 if (this.text.length > 0) {
33 for (var counter = 0; counter < iterators.length; counter++) {
34 var iterator = iterators[counter];
35 var start = iterator.getBeginIndex ();
36 var end = iterator.getEndIndex ();
39 iterator.setIndex (index);
40 var attrs = iterator.getAttributes ();
41 if (java.text.AttributedString.mapsDiffer (last, attrs)) {
42 this.setAttributes (attrs, index - start + offset);
44 index = iterator.getRunLimit ();
46 offset += (end - start);
49 Clazz.makeConstructor (c$,
52 throw new NullPointerException ();
55 Clazz.makeConstructor (c$,
56 function (text, attributes) {
57 if (text == null || attributes == null) {
58 throw new NullPointerException ();
60 if (text.length == 0) {
61 if (attributes.isEmpty ()) return;
62 throw new IllegalArgumentException ("Can't add attribute to 0-length text");
63 }var attributeCount = attributes.size ();
64 if (attributeCount > 0) {
65 this.createRunAttributeDataVectors ();
66 var newRunAttributes = new java.util.Vector (attributeCount);
67 var newRunAttributeValues = new java.util.Vector (attributeCount);
68 this.runAttributes[0] = newRunAttributes;
69 this.runAttributeValues[0] = newRunAttributeValues;
70 var iterator = attributes.entrySet ().iterator ();
71 while (iterator.hasNext ()) {
72 var entry = iterator.next ();
73 newRunAttributes.addElement (entry.getKey ());
74 newRunAttributeValues.addElement (entry.getValue ());
76 }}, "~S,java.util.Map");
77 Clazz.makeConstructor (c$,
79 this.construct (text, text.getBeginIndex (), text.getEndIndex (), null);
80 }, "java.text.AttributedCharacterIterator");
81 Clazz.makeConstructor (c$,
82 function (text, beginIndex, endIndex) {
83 this.construct (text, beginIndex, endIndex, null);
84 }, "java.text.AttributedCharacterIterator,~N,~N");
85 Clazz.makeConstructor (c$,
86 function (text, beginIndex, endIndex, attributes) {
88 throw new NullPointerException ();
89 }var textBeginIndex = text.getBeginIndex ();
90 var textEndIndex = text.getEndIndex ();
91 if (beginIndex < textBeginIndex || endIndex > textEndIndex || beginIndex > endIndex) throw new IllegalArgumentException ("Invalid substring range");
92 var textBuffer = new StringBuffer ();
93 text.setIndex (beginIndex);
94 for (var c = text.current (); text.getIndex () < endIndex; c = text.next ()) textBuffer.append (c);
96 this.text = textBuffer.toString ();
97 if (beginIndex == endIndex) return;
98 var keys = new java.util.HashSet ();
99 if (attributes == null) {
100 keys.addAll (text.getAllAttributeKeys ());
102 for (var i = 0; i < attributes.length; i++) keys.add (attributes[i]);
104 keys.retainAll (text.getAllAttributeKeys ());
105 }if (keys.isEmpty ()) return;
106 var itr = keys.iterator ();
107 while (itr.hasNext ()) {
108 var attributeKey = itr.next ();
109 text.setIndex (textBeginIndex);
110 while (text.getIndex () < endIndex) {
111 var start = text.getRunStart (attributeKey);
112 var limit = text.getRunLimit (attributeKey);
113 var value = text.getAttribute (attributeKey);
115 if (Clazz.instanceOf (value, java.text.Annotation)) {
116 if (start >= beginIndex && limit <= endIndex) {
117 this.addAttribute (attributeKey, value, start - beginIndex, limit - beginIndex);
119 if (limit > endIndex) break;
121 if (start >= endIndex) break;
122 if (limit > beginIndex) {
123 if (start < beginIndex) start = beginIndex;
124 if (limit > endIndex) limit = endIndex;
125 if (start != limit) {
126 this.addAttribute (attributeKey, value, start - beginIndex, limit - beginIndex);
127 }}}}text.setIndex (limit);
130 }, "java.text.AttributedCharacterIterator,~N,~N,~A");
131 Clazz.defineMethod (c$, "addAttribute",
132 function (attribute, value) {
133 if (attribute == null) {
134 throw new NullPointerException ();
135 }var len = this.length ();
137 throw new IllegalArgumentException ("Can't add attribute to 0-length text");
138 }this.addAttributeImpl (attribute, value, 0, len);
139 }, "java.text.AttributedCharacterIterator.Attribute,~O");
140 Clazz.defineMethod (c$, "addAttribute",
141 function (attribute, value, beginIndex, endIndex) {
142 if (attribute == null) {
143 throw new NullPointerException ();
144 }if (beginIndex < 0 || endIndex > this.length () || beginIndex >= endIndex) {
145 throw new IllegalArgumentException ("Invalid substring range");
146 }this.addAttributeImpl (attribute, value, beginIndex, endIndex);
147 }, "java.text.AttributedCharacterIterator.Attribute,~O,~N,~N");
148 Clazz.defineMethod (c$, "addAttributes",
149 function (attributes, beginIndex, endIndex) {
150 if (attributes == null) {
151 throw new NullPointerException ();
152 }if (beginIndex < 0 || endIndex > this.length () || beginIndex > endIndex) {
153 throw new IllegalArgumentException ("Invalid substring range");
154 }if (beginIndex == endIndex) {
155 if (attributes.isEmpty ()) return;
156 throw new IllegalArgumentException ("Can't add attribute to 0-length text");
157 }if (this.runCount == 0) {
158 this.createRunAttributeDataVectors ();
159 }var beginRunIndex = this.ensureRunBreak (beginIndex);
160 var endRunIndex = this.ensureRunBreak (endIndex);
161 var iterator = attributes.entrySet ().iterator ();
162 while (iterator.hasNext ()) {
163 var entry = iterator.next ();
164 this.addAttributeRunData (entry.getKey (), entry.getValue (), beginRunIndex, endRunIndex);
166 }, "java.util.Map,~N,~N");
167 Clazz.defineMethod (c$, "addAttributeImpl",
168 function (attribute, value, beginIndex, endIndex) {
169 if (this.runCount == 0) {
170 this.createRunAttributeDataVectors ();
171 }var beginRunIndex = this.ensureRunBreak (beginIndex);
172 var endRunIndex = this.ensureRunBreak (endIndex);
173 this.addAttributeRunData (attribute, value, beginRunIndex, endRunIndex);
174 }, "java.text.AttributedCharacterIterator.Attribute,~O,~N,~N");
175 Clazz.defineMethod (c$, "createRunAttributeDataVectors",
177 var newRunStarts = Clazz.newIntArray (10, 0);
178 var newRunAttributes = new Array (10);
179 var newRunAttributeValues = new Array (10);
180 this.runStarts = newRunStarts;
181 this.runAttributes = newRunAttributes;
182 this.runAttributeValues = newRunAttributeValues;
183 this.runArraySize = 10;
186 Clazz.defineMethod (c$, "ensureRunBreak",
188 return this.ensureRunBreak (offset, true);
190 Clazz.defineMethod (c$, "ensureRunBreak",
191 function (offset, copyAttrs) {
192 if (offset == this.length ()) {
193 return this.runCount;
195 while (runIndex < this.runCount && this.runStarts[runIndex] < offset) {
198 if (runIndex < this.runCount && this.runStarts[runIndex] == offset) {
200 }if (this.runCount == this.runArraySize) {
201 var newArraySize = this.runArraySize + 10;
202 var newRunStarts = Clazz.newIntArray (newArraySize, 0);
203 var newRunAttributes = new Array (newArraySize);
204 var newRunAttributeValues = new Array (newArraySize);
205 for (var i = 0; i < this.runArraySize; i++) {
206 newRunStarts[i] = this.runStarts[i];
207 newRunAttributes[i] = this.runAttributes[i];
208 newRunAttributeValues[i] = this.runAttributeValues[i];
210 this.runStarts = newRunStarts;
211 this.runAttributes = newRunAttributes;
212 this.runAttributeValues = newRunAttributeValues;
213 this.runArraySize = newArraySize;
214 }var newRunAttributes = null;
215 var newRunAttributeValues = null;
217 var oldRunAttributes = this.runAttributes[runIndex - 1];
218 var oldRunAttributeValues = this.runAttributeValues[runIndex - 1];
219 if (oldRunAttributes != null) {
220 newRunAttributes = oldRunAttributes.clone ();
221 }if (oldRunAttributeValues != null) {
222 newRunAttributeValues = oldRunAttributeValues.clone ();
224 for (var i = this.runCount - 1; i > runIndex; i--) {
225 this.runStarts[i] = this.runStarts[i - 1];
226 this.runAttributes[i] = this.runAttributes[i - 1];
227 this.runAttributeValues[i] = this.runAttributeValues[i - 1];
229 this.runStarts[runIndex] = offset;
230 this.runAttributes[runIndex] = newRunAttributes;
231 this.runAttributeValues[runIndex] = newRunAttributeValues;
234 Clazz.defineMethod (c$, "addAttributeRunData",
235 function (attribute, value, beginRunIndex, endRunIndex) {
236 for (var i = beginRunIndex; i < endRunIndex; i++) {
237 var keyValueIndex = -1;
238 if (this.runAttributes[i] == null) {
239 var newRunAttributes = new java.util.Vector ();
240 var newRunAttributeValues = new java.util.Vector ();
241 this.runAttributes[i] = newRunAttributes;
242 this.runAttributeValues[i] = newRunAttributeValues;
244 keyValueIndex = this.runAttributes[i].indexOf (attribute);
245 }if (keyValueIndex == -1) {
246 var oldSize = this.runAttributes[i].size ();
247 this.runAttributes[i].addElement (attribute);
249 this.runAttributeValues[i].addElement (value);
251 if (Clazz.exceptionOf (e, Exception)) {
252 this.runAttributes[i].setSize (oldSize);
253 this.runAttributeValues[i].setSize (oldSize);
259 this.runAttributeValues[i].set (keyValueIndex, value);
261 }, "java.text.AttributedCharacterIterator.Attribute,~O,~N,~N");
262 Clazz.defineMethod (c$, "getIterator",
264 return this.getIterator (null, 0, this.length ());
266 Clazz.defineMethod (c$, "getIterator",
267 function (attributes) {
268 return this.getIterator (attributes, 0, this.length ());
270 Clazz.defineMethod (c$, "getIterator",
271 function (attributes, beginIndex, endIndex) {
272 return Clazz.innerTypeInstance (java.text.AttributedString.AttributedStringIterator, this, null, attributes, beginIndex, endIndex);
274 Clazz.defineMethod (c$, "length",
276 return this.text.length;
278 Clazz.defineMethod (c$, "charAt",
280 return this.text.charAt (index);
282 Clazz.defineMethod (c$, "getAttribute",
283 function (attribute, runIndex) {
284 var currentRunAttributes = this.runAttributes[runIndex];
285 var currentRunAttributeValues = this.runAttributeValues[runIndex];
286 if (currentRunAttributes == null) {
288 }var attributeIndex = currentRunAttributes.indexOf (attribute);
289 if (attributeIndex != -1) {
290 return currentRunAttributeValues.elementAt (attributeIndex);
293 }}, "java.text.AttributedCharacterIterator.Attribute,~N");
294 Clazz.defineMethod (c$, "getAttributeCheckRange",
295 function (attribute, runIndex, beginIndex, endIndex) {
296 var value = this.getAttribute (attribute, runIndex);
297 if (Clazz.instanceOf (value, java.text.Annotation)) {
298 if (beginIndex > 0) {
299 var currIndex = runIndex;
300 var runStart = this.runStarts[currIndex];
301 while (runStart >= beginIndex && java.text.AttributedString.valuesMatch (value, this.getAttribute (attribute, currIndex - 1))) {
303 runStart = this.runStarts[currIndex];
305 if (runStart < beginIndex) {
307 }}var textLength = this.length ();
308 if (endIndex < textLength) {
309 var currIndex = runIndex;
310 var runLimit = (currIndex < this.runCount - 1) ? this.runStarts[currIndex + 1] : textLength;
311 while (runLimit <= endIndex && java.text.AttributedString.valuesMatch (value, this.getAttribute (attribute, currIndex + 1))) {
313 runLimit = (currIndex < this.runCount - 1) ? this.runStarts[currIndex + 1] : textLength;
315 if (runLimit > endIndex) {
318 }, "java.text.AttributedCharacterIterator.Attribute,~N,~N,~N");
319 Clazz.defineMethod (c$, "attributeValuesMatch",
320 function (attributes, runIndex1, runIndex2) {
321 var iterator = attributes.iterator ();
322 while (iterator.hasNext ()) {
323 var key = iterator.next ();
324 if (!java.text.AttributedString.valuesMatch (this.getAttribute (key, runIndex1), this.getAttribute (key, runIndex2))) {
328 }, "java.util.Set,~N,~N");
329 c$.valuesMatch = Clazz.defineMethod (c$, "valuesMatch",
330 function (value1, value2) {
331 if (value1 == null) {
332 return value2 == null;
334 return value1.equals (value2);
336 Clazz.defineMethod (c$, "appendContents",
337 function (buf, iterator) {
338 var index = iterator.getBeginIndex ();
339 var end = iterator.getEndIndex ();
340 while (index < end) {
341 iterator.setIndex (index++);
342 buf.append (iterator.current ());
344 }, "StringBuffer,java.text.CharacterIterator");
345 Clazz.defineMethod (c$, "setAttributes",
346 function (attrs, offset) {
347 if (this.runCount == 0) {
348 this.createRunAttributeDataVectors ();
349 }var index = this.ensureRunBreak (offset, false);
351 if (attrs != null && (size = attrs.size ()) > 0) {
352 var runAttrs = new java.util.Vector (size);
353 var runValues = new java.util.Vector (size);
354 var iterator = attrs.entrySet ().iterator ();
355 while (iterator.hasNext ()) {
356 var entry = iterator.next ();
357 runAttrs.add (entry.getKey ());
358 runValues.add (entry.getValue ());
360 this.runAttributes[index] = runAttrs;
361 this.runAttributeValues[index] = runValues;
362 }}, "java.util.Map,~N");
363 c$.mapsDiffer = Clazz.defineMethod (c$, "mapsDiffer",
364 function (last, attrs) {
366 return (attrs != null && attrs.size () > 0);
367 }return (!last.equals (attrs));
368 }, "java.util.Map,java.util.Map");
369 c$.$AttributedString$AttributedStringIterator$ = function () {
371 c$ = Clazz.decorateAsClass (function () {
372 Clazz.prepareCallback (this, arguments);
375 this.currentIndex = 0;
376 this.currentRunIndex = 0;
377 this.currentRunStart = 0;
378 this.currentRunLimit = 0;
379 Clazz.instantialize (this, arguments);
380 }, java.text.AttributedString, "AttributedStringIterator", null, java.text.AttributedCharacterIterator);
381 Clazz.makeConstructor (c$,
383 if (b < 0 || b > c || c > this.b$["java.text.AttributedString"].length ()) {
384 throw new IllegalArgumentException ("Invalid substring range");
385 }this.beginIndex = b;
387 this.currentIndex = b;
388 this.updateRunInfo ();
390 Clazz.overrideMethod (c$, "equals",
394 }if (!(Clazz.instanceOf (a, java.text.AttributedString.AttributedStringIterator))) {
397 if (this.b$["java.text.AttributedString"] !== b.getString ()) return false;
398 if (this.currentIndex != b.currentIndex || this.beginIndex != b.beginIndex || this.endIndex != b.endIndex) return false;
401 Clazz.overrideMethod (c$, "hashCode",
403 return this.b$["java.text.AttributedString"].text.hashCode () ^ this.currentIndex ^ this.beginIndex ^ this.endIndex;
405 Clazz.overrideMethod (c$, "clone",
408 var a = Clazz.superCall (this, java.text.AttributedString.AttributedStringIterator, "clone", []);
411 if (Clazz.exceptionOf (e, CloneNotSupportedException)) {
412 throw new InternalError ();
418 Clazz.overrideMethod (c$, "first",
420 return this.internalSetIndex (this.beginIndex);
422 Clazz.overrideMethod (c$, "last",
424 if (this.endIndex == this.beginIndex) {
425 return this.internalSetIndex (this.endIndex);
427 return this.internalSetIndex (this.endIndex - 1);
429 Clazz.overrideMethod (c$, "current",
431 if (this.currentIndex == this.endIndex) {
434 return this.b$["java.text.AttributedString"].charAt (this.currentIndex);
436 Clazz.overrideMethod (c$, "next",
438 if (this.currentIndex < this.endIndex) {
439 return this.internalSetIndex (this.currentIndex + 1);
443 Clazz.overrideMethod (c$, "previous",
445 if (this.currentIndex > this.beginIndex) {
446 return this.internalSetIndex (this.currentIndex - 1);
450 Clazz.overrideMethod (c$, "setIndex",
452 if (a < this.beginIndex || a > this.endIndex) throw new IllegalArgumentException ("Invalid index");
453 return this.internalSetIndex (a);
455 Clazz.overrideMethod (c$, "getBeginIndex",
457 return this.beginIndex;
459 Clazz.overrideMethod (c$, "getEndIndex",
461 return this.endIndex;
463 Clazz.overrideMethod (c$, "getIndex",
465 return this.currentIndex;
467 Clazz.defineMethod (c$, "getRunStart",
469 return this.currentRunStart;
471 Clazz.defineMethod (c$, "getRunStart",
473 if (this.currentRunStart == this.beginIndex || this.currentRunIndex == -1) {
474 return this.currentRunStart;
476 var b = this.getAttribute (a);
477 var c = this.currentRunStart;
478 var d = this.currentRunIndex;
479 while (c > this.beginIndex && java.text.AttributedString.valuesMatch (b, this.b$["java.text.AttributedString"].getAttribute (a, d - 1))) {
481 c = this.b$["java.text.AttributedString"].runStarts[d];
483 if (c < this.beginIndex) {
486 }}, "java.text.AttributedCharacterIterator.Attribute");
487 Clazz.defineMethod (c$, "getRunStart",
489 if (this.currentRunStart == this.beginIndex || this.currentRunIndex == -1) {
490 return this.currentRunStart;
492 var b = this.currentRunStart;
493 var c = this.currentRunIndex;
494 while (b > this.beginIndex && this.b$["java.text.AttributedString"].attributeValuesMatch (a, this.currentRunIndex, c - 1)) {
496 b = this.b$["java.text.AttributedString"].runStarts[c];
498 if (b < this.beginIndex) {
501 }}, "java.util.Set");
502 Clazz.defineMethod (c$, "getRunLimit",
504 return this.currentRunLimit;
506 Clazz.defineMethod (c$, "getRunLimit",
508 if (this.currentRunLimit == this.endIndex || this.currentRunIndex == -1) {
509 return this.currentRunLimit;
511 var b = this.getAttribute (a);
512 var c = this.currentRunLimit;
513 var d = this.currentRunIndex;
514 while (c < this.endIndex && java.text.AttributedString.valuesMatch (b, this.b$["java.text.AttributedString"].getAttribute (a, d + 1))) {
516 c = d < this.b$["java.text.AttributedString"].runCount - 1 ? this.b$["java.text.AttributedString"].runStarts[d + 1] : this.endIndex;
518 if (c > this.endIndex) {
521 }}, "java.text.AttributedCharacterIterator.Attribute");
522 Clazz.defineMethod (c$, "getRunLimit",
524 if (this.currentRunLimit == this.endIndex || this.currentRunIndex == -1) {
525 return this.currentRunLimit;
527 var b = this.currentRunLimit;
528 var c = this.currentRunIndex;
529 while (b < this.endIndex && this.b$["java.text.AttributedString"].attributeValuesMatch (a, this.currentRunIndex, c + 1)) {
531 b = c < this.b$["java.text.AttributedString"].runCount - 1 ? this.b$["java.text.AttributedString"].runStarts[c + 1] : this.endIndex;
533 if (b > this.endIndex) {
536 }}, "java.util.Set");
537 Clazz.overrideMethod (c$, "getAttributes",
539 if (this.b$["java.text.AttributedString"].runAttributes == null || this.currentRunIndex == -1 || this.b$["java.text.AttributedString"].runAttributes[this.currentRunIndex] == null) {
540 return new java.util.Hashtable ();
541 }return Clazz.innerTypeInstance (java.text.AttributedString.AttributeMap, this, null, this.currentRunIndex, this.beginIndex, this.endIndex);
543 Clazz.overrideMethod (c$, "getAllAttributeKeys",
545 if (this.b$["java.text.AttributedString"].runAttributes == null) {
546 return new java.util.HashSet ();
548 var a = new java.util.HashSet ();
550 while (b < this.b$["java.text.AttributedString"].runCount) {
551 if (this.b$["java.text.AttributedString"].runStarts[b] < this.endIndex && (b == this.b$["java.text.AttributedString"].runCount - 1 || this.b$["java.text.AttributedString"].runStarts[b + 1] > this.beginIndex)) {
552 var c = this.b$["java.text.AttributedString"].runAttributes[b];
562 Clazz.overrideMethod (c$, "getAttribute",
564 var b = this.currentRunIndex;
567 }return this.b$["java.text.AttributedString"].getAttributeCheckRange (a, b, this.beginIndex, this.endIndex);
568 }, "java.text.AttributedCharacterIterator.Attribute");
569 Clazz.defineMethod (c$, "getString",
571 return this.b$["java.text.AttributedString"];
573 Clazz.defineMethod (c$, "internalSetIndex",
575 this.currentIndex = a;
576 if (a < this.currentRunStart || a >= this.currentRunLimit) {
577 this.updateRunInfo ();
578 }if (this.currentIndex == this.endIndex) {
581 return this.b$["java.text.AttributedString"].charAt (a);
583 Clazz.defineMethod (c$, "updateRunInfo",
585 if (this.currentIndex == this.endIndex) {
586 this.currentRunStart = this.currentRunLimit = this.endIndex;
587 this.currentRunIndex = -1;
591 while (a < this.b$["java.text.AttributedString"].runCount - 1 && this.b$["java.text.AttributedString"].runStarts[a + 1] <= this.currentIndex) a++;
593 this.currentRunIndex = a;
595 this.currentRunStart = this.b$["java.text.AttributedString"].runStarts[a];
596 if (this.currentRunStart < this.beginIndex) this.currentRunStart = this.beginIndex;
598 this.currentRunStart = this.beginIndex;
599 }if (a < this.b$["java.text.AttributedString"].runCount - 1) {
600 this.currentRunLimit = this.b$["java.text.AttributedString"].runStarts[a + 1];
601 if (this.currentRunLimit > this.endIndex) this.currentRunLimit = this.endIndex;
603 this.currentRunLimit = this.endIndex;
607 c$.$AttributedString$AttributeMap$ = function () {
609 c$ = Clazz.decorateAsClass (function () {
610 Clazz.prepareCallback (this, arguments);
614 Clazz.instantialize (this, arguments);
615 }, java.text.AttributedString, "AttributeMap", java.util.AbstractMap);
616 Clazz.makeConstructor (c$,
618 Clazz.superConstructor (this, java.text.AttributedString.AttributeMap, []);
623 Clazz.overrideMethod (c$, "entrySet",
625 var a = new java.util.HashSet ();
627 var b = this.b$["java.text.AttributedString"].runAttributes[this.runIndex].size ();
628 for (var c = 0; c < b; c++) {
629 var d = this.b$["java.text.AttributedString"].runAttributes[this.runIndex].get (c);
630 var e = this.b$["java.text.AttributedString"].runAttributeValues[this.runIndex].get (c);
631 if (Clazz.instanceOf (e, java.text.Annotation)) {
632 e = this.b$["java.text.AttributedString"].getAttributeCheckRange (d, this.runIndex, this.beginIndex, this.endIndex);
635 }}var f = new java.text.AttributeEntry (d, e);
640 Clazz.overrideMethod (c$, "get",
642 return this.b$["java.text.AttributedString"].getAttributeCheckRange (a, this.runIndex, this.beginIndex, this.endIndex);
646 Clazz.defineStatics (c$,
647 "ARRAY_SIZE_INCREMENT", 10);
648 c$ = Clazz.decorateAsClass (function () {
651 Clazz.instantialize (this, arguments);
652 }, java.text, "AttributeEntry", null, java.util.Map.Entry);
653 Clazz.makeConstructor (c$,
654 function (key, value) {
657 }, "java.text.AttributedCharacterIterator.Attribute,~O");
658 Clazz.overrideMethod (c$, "equals",
660 if (!(Clazz.instanceOf (o, java.text.AttributeEntry))) {
663 return other.key.equals (this.key) && (this.value == null ? other.value == null : other.value.equals (this.value));
665 Clazz.overrideMethod (c$, "getKey",
669 Clazz.overrideMethod (c$, "getValue",
673 Clazz.overrideMethod (c$, "setValue",
674 function (newValue) {
675 throw new UnsupportedOperationException ();
677 Clazz.overrideMethod (c$, "hashCode",
679 return this.key.hashCode () ^ (this.value == null ? 0 : this.value.hashCode ());
681 Clazz.defineMethod (c$, "toString",
683 return this.key.toString () + "=" + this.value.toString ();