1use alloc::{string::ToString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::lang::{AbstractStringBuilder, CharSequence, Object, String},
10};
11
12pub struct StringBuffer;
14
15impl StringBuffer {
16 pub fn as_proto() -> RuntimeClassProto {
17 RuntimeClassProto {
18 name: "java/lang/StringBuffer",
19 parent_class: Some("java/lang/AbstractStringBuilder"),
20 interfaces: vec!["java/io/Serializable", "java/lang/CharSequence"],
21 methods: vec![
22 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
23 JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, MethodAccessFlags::PUBLIC),
24 JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_string, MethodAccessFlags::PUBLIC),
25 JavaMethodProto::new(
26 "<init>",
27 "(Ljava/lang/CharSequence;)V",
28 Self::init_with_char_sequence,
29 MethodAccessFlags::PUBLIC,
30 ),
31 JavaMethodProto::new(
32 "append",
33 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
34 Self::append_string,
35 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
36 ),
37 JavaMethodProto::new(
38 "append",
39 "(Ljava/lang/Object;)Ljava/lang/StringBuffer;",
40 Self::append_object,
41 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
42 ),
43 JavaMethodProto::new(
44 "append",
45 "(Ljava/lang/StringBuffer;)Ljava/lang/StringBuffer;",
46 Self::append_string_buffer,
47 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
48 ),
49 JavaMethodProto::new(
50 "append",
51 "(Ljava/lang/CharSequence;)Ljava/lang/StringBuffer;",
52 Self::append_char_sequence,
53 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
54 ),
55 JavaMethodProto::new(
56 "append",
57 "(Ljava/lang/CharSequence;II)Ljava/lang/StringBuffer;",
58 Self::append_char_sequence_range,
59 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
60 ),
61 JavaMethodProto::new(
62 "append",
63 "(Z)Ljava/lang/StringBuffer;",
64 Self::append_boolean,
65 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
66 ),
67 JavaMethodProto::new(
68 "append",
69 "(C)Ljava/lang/StringBuffer;",
70 Self::append_character,
71 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
72 ),
73 JavaMethodProto::new(
74 "append",
75 "(I)Ljava/lang/StringBuffer;",
76 Self::append_integer,
77 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
78 ),
79 JavaMethodProto::new(
80 "appendCodePoint",
81 "(I)Ljava/lang/StringBuffer;",
82 Self::append_code_point,
83 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
84 ),
85 JavaMethodProto::new(
86 "append",
87 "(J)Ljava/lang/StringBuffer;",
88 Self::append_long,
89 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
90 ),
91 JavaMethodProto::new(
92 "append",
93 "(F)Ljava/lang/StringBuffer;",
94 Self::append_float,
95 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
96 ),
97 JavaMethodProto::new(
98 "append",
99 "(D)Ljava/lang/StringBuffer;",
100 Self::append_double,
101 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
102 ),
103 JavaMethodProto::new(
104 "append",
105 "([C)Ljava/lang/StringBuffer;",
106 Self::append_char_array_all,
107 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
108 ),
109 JavaMethodProto::new(
110 "append",
111 "([CII)Ljava/lang/StringBuffer;",
112 Self::append_char_array,
113 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
114 ),
115 JavaMethodProto::new(
116 "insert",
117 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
118 Self::insert_string,
119 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
120 ),
121 JavaMethodProto::new(
122 "insert",
123 "(ILjava/lang/Object;)Ljava/lang/StringBuffer;",
124 Self::insert_object,
125 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
126 ),
127 JavaMethodProto::new("insert", "(IZ)Ljava/lang/StringBuffer;", Self::insert_boolean, MethodAccessFlags::PUBLIC),
128 JavaMethodProto::new(
129 "insert",
130 "(IC)Ljava/lang/StringBuffer;",
131 Self::insert_character,
132 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
133 ),
134 JavaMethodProto::new("insert", "(II)Ljava/lang/StringBuffer;", Self::insert_integer, MethodAccessFlags::PUBLIC),
135 JavaMethodProto::new("insert", "(IJ)Ljava/lang/StringBuffer;", Self::insert_long, MethodAccessFlags::PUBLIC),
136 JavaMethodProto::new("insert", "(IF)Ljava/lang/StringBuffer;", Self::insert_float, MethodAccessFlags::PUBLIC),
137 JavaMethodProto::new("insert", "(ID)Ljava/lang/StringBuffer;", Self::insert_double, MethodAccessFlags::PUBLIC),
138 JavaMethodProto::new(
139 "insert",
140 "(I[C)Ljava/lang/StringBuffer;",
141 Self::insert_char_array,
142 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
143 ),
144 JavaMethodProto::new(
145 "insert",
146 "(I[CII)Ljava/lang/StringBuffer;",
147 Self::insert_char_array_range,
148 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
149 ),
150 JavaMethodProto::new(
151 "insert",
152 "(ILjava/lang/CharSequence;)Ljava/lang/StringBuffer;",
153 Self::insert_char_sequence,
154 MethodAccessFlags::PUBLIC,
155 ),
156 JavaMethodProto::new(
157 "insert",
158 "(ILjava/lang/CharSequence;II)Ljava/lang/StringBuffer;",
159 Self::insert_char_sequence_range,
160 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
161 ),
162 JavaMethodProto::new(
163 "delete",
164 "(II)Ljava/lang/StringBuffer;",
165 Self::delete,
166 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
167 ),
168 JavaMethodProto::new(
169 "deleteCharAt",
170 "(I)Ljava/lang/StringBuffer;",
171 Self::delete_char_at,
172 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
173 ),
174 JavaMethodProto::new(
175 "replace",
176 "(IILjava/lang/String;)Ljava/lang/StringBuffer;",
177 Self::replace,
178 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
179 ),
180 JavaMethodProto::new(
181 "substring",
182 "(I)Ljava/lang/String;",
183 Self::substring,
184 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
185 ),
186 JavaMethodProto::new(
187 "substring",
188 "(II)Ljava/lang/String;",
189 Self::substring_range,
190 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
191 ),
192 JavaMethodProto::new(
193 "subSequence",
194 "(II)Ljava/lang/CharSequence;",
195 Self::sub_sequence,
196 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
197 ),
198 JavaMethodProto::new(
199 "reverse",
200 "()Ljava/lang/StringBuffer;",
201 Self::reverse,
202 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
203 ),
204 JavaMethodProto::new("indexOf", "(Ljava/lang/String;)I", Self::index_of, MethodAccessFlags::PUBLIC),
205 JavaMethodProto::new(
206 "indexOf",
207 "(Ljava/lang/String;I)I",
208 Self::index_of_from,
209 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
210 ),
211 JavaMethodProto::new("lastIndexOf", "(Ljava/lang/String;)I", Self::last_index_of, MethodAccessFlags::PUBLIC),
212 JavaMethodProto::new(
213 "lastIndexOf",
214 "(Ljava/lang/String;I)I",
215 Self::last_index_of_from,
216 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
217 ),
218 JavaMethodProto::new(
219 "toString",
220 "()Ljava/lang/String;",
221 Self::to_string,
222 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
223 ),
224 JavaMethodProto::new(
225 "capacity",
226 "()I",
227 Self::capacity,
228 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
229 ),
230 JavaMethodProto::new(
231 "ensureCapacity",
232 "(I)V",
233 Self::ensure_capacity,
234 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
235 ),
236 JavaMethodProto::new(
237 "trimToSize",
238 "()V",
239 Self::trim_to_size,
240 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
241 ),
242 JavaMethodProto::new(
243 "setLength",
244 "(I)V",
245 Self::set_length,
246 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
247 ),
248 JavaMethodProto::new("length", "()I", Self::length, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
249 JavaMethodProto::new(
250 "charAt",
251 "(I)C",
252 Self::char_at,
253 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
254 ),
255 JavaMethodProto::new(
256 "codePointAt",
257 "(I)I",
258 Self::code_point_at,
259 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
260 ),
261 JavaMethodProto::new(
262 "codePointBefore",
263 "(I)I",
264 Self::code_point_before,
265 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
266 ),
267 JavaMethodProto::new(
268 "codePointCount",
269 "(II)I",
270 Self::code_point_count,
271 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
272 ),
273 JavaMethodProto::new(
274 "offsetByCodePoints",
275 "(II)I",
276 Self::offset_by_code_points,
277 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
278 ),
279 JavaMethodProto::new(
280 "setCharAt",
281 "(IC)V",
282 Self::set_char_at,
283 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
284 ),
285 JavaMethodProto::new(
286 "getChars",
287 "(II[CI)V",
288 Self::get_chars,
289 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
290 ),
291 JavaMethodProto::new(
292 "append",
293 "(Ljava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
294 Self::append_object,
295 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
296 ),
297 JavaMethodProto::new(
298 "append",
299 "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
300 Self::append_string,
301 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
302 ),
303 JavaMethodProto::new(
304 "append",
305 "(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;",
306 Self::append_string_buffer,
307 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
308 ),
309 JavaMethodProto::new(
310 "append",
311 "(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
312 Self::append_char_sequence,
313 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
314 ),
315 JavaMethodProto::new(
316 "append",
317 "(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
318 Self::append_char_sequence_range,
319 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
320 ),
321 JavaMethodProto::new(
322 "append",
323 "([C)Ljava/lang/AbstractStringBuilder;",
324 Self::append_char_array_all,
325 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
326 ),
327 JavaMethodProto::new(
328 "append",
329 "([CII)Ljava/lang/AbstractStringBuilder;",
330 Self::append_char_array,
331 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
332 ),
333 JavaMethodProto::new(
334 "append",
335 "(Z)Ljava/lang/AbstractStringBuilder;",
336 Self::append_boolean,
337 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
338 ),
339 JavaMethodProto::new(
340 "append",
341 "(C)Ljava/lang/AbstractStringBuilder;",
342 Self::append_character,
343 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
344 ),
345 JavaMethodProto::new(
346 "append",
347 "(I)Ljava/lang/AbstractStringBuilder;",
348 Self::append_integer,
349 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
350 ),
351 JavaMethodProto::new(
352 "append",
353 "(J)Ljava/lang/AbstractStringBuilder;",
354 Self::append_long,
355 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
356 ),
357 JavaMethodProto::new(
358 "append",
359 "(F)Ljava/lang/AbstractStringBuilder;",
360 Self::append_float,
361 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
362 ),
363 JavaMethodProto::new(
364 "append",
365 "(D)Ljava/lang/AbstractStringBuilder;",
366 Self::append_double,
367 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
368 ),
369 JavaMethodProto::new(
370 "appendCodePoint",
371 "(I)Ljava/lang/AbstractStringBuilder;",
372 Self::append_code_point,
373 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
374 ),
375 JavaMethodProto::new(
376 "delete",
377 "(II)Ljava/lang/AbstractStringBuilder;",
378 Self::delete,
379 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
380 ),
381 JavaMethodProto::new(
382 "deleteCharAt",
383 "(I)Ljava/lang/AbstractStringBuilder;",
384 Self::delete_char_at,
385 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
386 ),
387 JavaMethodProto::new(
388 "replace",
389 "(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
390 Self::replace,
391 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
392 ),
393 JavaMethodProto::new(
394 "insert",
395 "(I[CII)Ljava/lang/AbstractStringBuilder;",
396 Self::insert_char_array_range,
397 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
398 ),
399 JavaMethodProto::new(
400 "insert",
401 "(ILjava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
402 Self::insert_object,
403 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
404 ),
405 JavaMethodProto::new(
406 "insert",
407 "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
408 Self::insert_string,
409 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
410 ),
411 JavaMethodProto::new(
412 "insert",
413 "(I[C)Ljava/lang/AbstractStringBuilder;",
414 Self::insert_char_array,
415 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
416 ),
417 JavaMethodProto::new(
418 "insert",
419 "(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
420 Self::insert_char_sequence,
421 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
422 ),
423 JavaMethodProto::new(
424 "insert",
425 "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
426 Self::insert_char_sequence_range,
427 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
428 ),
429 JavaMethodProto::new(
430 "insert",
431 "(IZ)Ljava/lang/AbstractStringBuilder;",
432 Self::insert_boolean,
433 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
434 ),
435 JavaMethodProto::new(
436 "insert",
437 "(IC)Ljava/lang/AbstractStringBuilder;",
438 Self::insert_character,
439 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
440 ),
441 JavaMethodProto::new(
442 "insert",
443 "(II)Ljava/lang/AbstractStringBuilder;",
444 Self::insert_integer,
445 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
446 ),
447 JavaMethodProto::new(
448 "insert",
449 "(IJ)Ljava/lang/AbstractStringBuilder;",
450 Self::insert_long,
451 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
452 ),
453 JavaMethodProto::new(
454 "insert",
455 "(IF)Ljava/lang/AbstractStringBuilder;",
456 Self::insert_float,
457 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
458 ),
459 JavaMethodProto::new(
460 "insert",
461 "(ID)Ljava/lang/AbstractStringBuilder;",
462 Self::insert_double,
463 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
464 ),
465 JavaMethodProto::new(
466 "reverse",
467 "()Ljava/lang/AbstractStringBuilder;",
468 Self::reverse,
469 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
470 ),
471 JavaMethodProto::new(
472 "append",
473 "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
474 Self::append_char_sequence,
475 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
476 ),
477 JavaMethodProto::new(
478 "append",
479 "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
480 Self::append_char_sequence_range,
481 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
482 ),
483 JavaMethodProto::new(
484 "append",
485 "(C)Ljava/lang/Appendable;",
486 Self::append_character,
487 MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
488 ),
489 ],
490 fields: vec![],
491 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
492 }
493 }
494
495 async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
496 tracing::debug!("java.lang.StringBuffer::<init>({this:?})");
497
498 jvm.invoke_special(&this, "java/lang/StringBuffer", "<init>", "(I)V", (16,)).await
499 }
500
501 async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
502 tracing::debug!("java.lang.StringBuffer::<init>({this:?}, {capacity})");
503
504 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", (capacity,))
505 .await
506 }
507
508 async fn init_with_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
509 tracing::debug!("java.lang.StringBuffer::<init>({this:?}, {string:?})");
510
511 if string.is_null() {
512 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
513 }
514
515 let chars = JavaLangString::to_utf16(jvm, &string).await?;
516 let _: () = jvm
517 .invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", ((chars.len() + 16) as i32,))
518 .await?;
519 let _: ClassInstanceRef<Self> = jvm
520 .invoke_virtual(
521 &this,
522 "java/lang/StringBuffer",
523 "append",
524 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
525 (string,),
526 )
527 .await?;
528 Ok(())
529 }
530
531 async fn init_with_char_sequence(
532 jvm: &Jvm,
533 _: &mut RuntimeContext,
534 this: ClassInstanceRef<Self>,
535 sequence: ClassInstanceRef<CharSequence>,
536 ) -> Result<()> {
537 if sequence.is_null() {
538 return Err(jvm.exception("java/lang/NullPointerException", "seq is null").await);
539 }
540 let length: i32 = jvm
541 .invoke_virtual(&sequence, &sequence.class_definition().name(), "length", "()I", ())
542 .await?;
543 let _: () = jvm
544 .invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", (length + 16,))
545 .await?;
546 let _: ClassInstanceRef<Self> = jvm
547 .invoke_virtual(
548 &this,
549 "java/lang/StringBuffer",
550 "append",
551 "(Ljava/lang/CharSequence;)Ljava/lang/StringBuffer;",
552 (sequence,),
553 )
554 .await?;
555 Ok(())
556 }
557
558 async fn append_string(
559 jvm: &Jvm,
560 _: &mut RuntimeContext,
561 mut this: ClassInstanceRef<Self>,
562 string: ClassInstanceRef<String>,
563 ) -> Result<ClassInstanceRef<Self>> {
564 tracing::debug!("java.lang.StringBuffer::append({this:?}, {string:?})");
565
566 let chars = if string.is_null() {
567 "null".encode_utf16().collect()
568 } else {
569 JavaLangString::to_utf16(jvm, &string).await?
570 };
571 Self::append_utf16(jvm, &mut this, chars).await?;
572 Ok(this)
573 }
574
575 async fn append_object(
576 jvm: &Jvm,
577 _: &mut RuntimeContext,
578 this: ClassInstanceRef<Self>,
579 object: ClassInstanceRef<Object>,
580 ) -> Result<ClassInstanceRef<Self>> {
581 tracing::debug!("java.lang.StringBuffer::append({this:?}, {object:?})");
582
583 let string: ClassInstanceRef<String> = if object.is_null() {
584 JavaLangString::from_rust_string(jvm, "null").await?.into()
585 } else {
586 jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
587 .await?
588 };
589 jvm.invoke_virtual(
590 &this,
591 "java/lang/StringBuffer",
592 "append",
593 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
594 (string,),
595 )
596 .await
597 }
598
599 async fn append_string_buffer(
600 jvm: &Jvm,
601 _: &mut RuntimeContext,
602 this: ClassInstanceRef<Self>,
603 buffer: ClassInstanceRef<Self>,
604 ) -> Result<ClassInstanceRef<Self>> {
605 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
606 .invoke_special(
607 &this,
608 "java/lang/AbstractStringBuilder",
609 "append",
610 "(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;",
611 (buffer,),
612 )
613 .await?;
614 Ok(this)
615 }
616
617 async fn append_char_sequence(
618 jvm: &Jvm,
619 _: &mut RuntimeContext,
620 this: ClassInstanceRef<Self>,
621 sequence: ClassInstanceRef<CharSequence>,
622 ) -> Result<ClassInstanceRef<Self>> {
623 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
624 .invoke_special(
625 &this,
626 "java/lang/AbstractStringBuilder",
627 "append",
628 "(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
629 (sequence,),
630 )
631 .await?;
632 Ok(this)
633 }
634
635 async fn append_char_sequence_range(
636 jvm: &Jvm,
637 _: &mut RuntimeContext,
638 this: ClassInstanceRef<Self>,
639 sequence: ClassInstanceRef<CharSequence>,
640 start: i32,
641 end: i32,
642 ) -> Result<ClassInstanceRef<Self>> {
643 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
644 .invoke_special(
645 &this,
646 "java/lang/AbstractStringBuilder",
647 "append",
648 "(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
649 (sequence, start, end),
650 )
651 .await?;
652 Ok(this)
653 }
654
655 async fn append_boolean(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<ClassInstanceRef<Self>> {
656 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
657
658 Self::append_utf16(jvm, &mut this, (if value { "true" } else { "false" }).encode_utf16().collect()).await?;
659 Ok(this)
660 }
661
662 async fn append_character(
663 jvm: &Jvm,
664 _: &mut RuntimeContext,
665 mut this: ClassInstanceRef<Self>,
666 value: JavaChar,
667 ) -> Result<ClassInstanceRef<Self>> {
668 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
669
670 Self::append_utf16(jvm, &mut this, vec![value]).await?;
671 Ok(this)
672 }
673
674 async fn append_integer(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<ClassInstanceRef<Self>> {
675 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
676
677 Self::append_utf16(jvm, &mut this, value.to_string().encode_utf16().collect()).await?;
678 Ok(this)
679 }
680
681 async fn append_code_point(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, code_point: i32) -> Result<ClassInstanceRef<Self>> {
682 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
683 .invoke_special(
684 &this,
685 "java/lang/AbstractStringBuilder",
686 "appendCodePoint",
687 "(I)Ljava/lang/AbstractStringBuilder;",
688 (code_point,),
689 )
690 .await?;
691 Ok(this)
692 }
693
694 async fn append_long(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<Self>> {
695 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
696
697 Self::append_utf16(jvm, &mut this, value.to_string().encode_utf16().collect()).await?;
698 Ok(this)
699 }
700
701 async fn append_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<ClassInstanceRef<Self>> {
702 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
703
704 let string: ClassInstanceRef<String> = jvm
705 .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
706 .await?;
707 jvm.invoke_virtual(
708 &this,
709 "java/lang/StringBuffer",
710 "append",
711 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
712 (string,),
713 )
714 .await
715 }
716
717 async fn append_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<Self>> {
718 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
719
720 let string: ClassInstanceRef<String> = jvm
721 .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
722 .await?;
723 jvm.invoke_virtual(
724 &this,
725 "java/lang/StringBuffer",
726 "append",
727 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
728 (string,),
729 )
730 .await
731 }
732
733 async fn append_char_array_all(
734 jvm: &Jvm,
735 _: &mut RuntimeContext,
736 mut this: ClassInstanceRef<Self>,
737 array: ClassInstanceRef<Array<JavaChar>>,
738 ) -> Result<ClassInstanceRef<Self>> {
739 tracing::debug!("java.lang.StringBuffer::append({this:?}, {array:?})");
740
741 if array.is_null() {
742 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
743 }
744 let length = jvm.array_length(&array).await?;
745 let chars = jvm.load_array(&array, 0, length).await?;
746 Self::append_utf16(jvm, &mut this, chars).await?;
747 Ok(this)
748 }
749
750 async fn append_char_array(
751 jvm: &Jvm,
752 _: &mut RuntimeContext,
753 mut this: ClassInstanceRef<Self>,
754 array: ClassInstanceRef<Array<JavaChar>>,
755 offset: i32,
756 length: i32,
757 ) -> Result<ClassInstanceRef<Self>> {
758 tracing::debug!("java.lang.StringBuffer::append({this:?}, {array:?}, {offset}, {length})");
759
760 if array.is_null() {
761 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
762 }
763 let array_length = jvm.array_length(&array).await? as i32;
764 if offset < 0 || length < 0 || offset > array_length - length {
765 return Err(jvm
766 .exception(
767 "java/lang/IndexOutOfBoundsException",
768 &alloc::format!("offset {offset}, length {length}, array length {array_length}"),
769 )
770 .await);
771 }
772 let chars = jvm.load_array(&array, offset as usize, length as usize).await?;
773 Self::append_utf16(jvm, &mut this, chars).await?;
774 Ok(this)
775 }
776
777 async fn insert_string(
778 jvm: &Jvm,
779 _: &mut RuntimeContext,
780 mut this: ClassInstanceRef<Self>,
781 offset: i32,
782 string: ClassInstanceRef<String>,
783 ) -> Result<ClassInstanceRef<Self>> {
784 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {string:?})");
785
786 let chars = if string.is_null() {
787 "null".encode_utf16().collect()
788 } else {
789 JavaLangString::to_utf16(jvm, &string).await?
790 };
791 Self::insert_utf16(jvm, &mut this, offset, chars).await?;
792 Ok(this)
793 }
794
795 async fn insert_object(
796 jvm: &Jvm,
797 _: &mut RuntimeContext,
798 this: ClassInstanceRef<Self>,
799 offset: i32,
800 object: ClassInstanceRef<Object>,
801 ) -> Result<ClassInstanceRef<Self>> {
802 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {object:?})");
803
804 let string: ClassInstanceRef<String> = if object.is_null() {
805 JavaLangString::from_rust_string(jvm, "null").await?.into()
806 } else {
807 jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
808 .await?
809 };
810 jvm.invoke_virtual(
811 &this,
812 "java/lang/StringBuffer",
813 "insert",
814 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
815 (offset, string),
816 )
817 .await
818 }
819
820 async fn insert_boolean(
821 jvm: &Jvm,
822 _: &mut RuntimeContext,
823 this: ClassInstanceRef<Self>,
824 offset: i32,
825 value: bool,
826 ) -> Result<ClassInstanceRef<Self>> {
827 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
828
829 let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
830 jvm.invoke_virtual(
831 &this,
832 "java/lang/StringBuffer",
833 "insert",
834 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
835 (offset, string),
836 )
837 .await
838 }
839
840 async fn insert_character(
841 jvm: &Jvm,
842 _: &mut RuntimeContext,
843 mut this: ClassInstanceRef<Self>,
844 offset: i32,
845 value: JavaChar,
846 ) -> Result<ClassInstanceRef<Self>> {
847 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
848
849 Self::insert_utf16(jvm, &mut this, offset, vec![value]).await?;
850 Ok(this)
851 }
852
853 async fn insert_integer(
854 jvm: &Jvm,
855 _: &mut RuntimeContext,
856 this: ClassInstanceRef<Self>,
857 offset: i32,
858 value: i32,
859 ) -> Result<ClassInstanceRef<Self>> {
860 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
861
862 let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
863 jvm.invoke_virtual(
864 &this,
865 "java/lang/StringBuffer",
866 "insert",
867 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
868 (offset, string),
869 )
870 .await
871 }
872
873 async fn insert_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i64) -> Result<ClassInstanceRef<Self>> {
874 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
875
876 let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
877 jvm.invoke_virtual(
878 &this,
879 "java/lang/StringBuffer",
880 "insert",
881 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
882 (offset, string),
883 )
884 .await
885 }
886
887 async fn insert_float(
888 jvm: &Jvm,
889 _: &mut RuntimeContext,
890 this: ClassInstanceRef<Self>,
891 offset: i32,
892 value: f32,
893 ) -> Result<ClassInstanceRef<Self>> {
894 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
895
896 let string: ClassInstanceRef<String> = jvm
897 .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
898 .await?;
899 jvm.invoke_virtual(
900 &this,
901 "java/lang/StringBuffer",
902 "insert",
903 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
904 (offset, string),
905 )
906 .await
907 }
908
909 async fn insert_double(
910 jvm: &Jvm,
911 _: &mut RuntimeContext,
912 this: ClassInstanceRef<Self>,
913 offset: i32,
914 value: f64,
915 ) -> Result<ClassInstanceRef<Self>> {
916 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
917
918 let string: ClassInstanceRef<String> = jvm
919 .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
920 .await?;
921 jvm.invoke_virtual(
922 &this,
923 "java/lang/StringBuffer",
924 "insert",
925 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
926 (offset, string),
927 )
928 .await
929 }
930
931 async fn insert_char_array(
932 jvm: &Jvm,
933 _: &mut RuntimeContext,
934 mut this: ClassInstanceRef<Self>,
935 offset: i32,
936 array: ClassInstanceRef<Array<JavaChar>>,
937 ) -> Result<ClassInstanceRef<Self>> {
938 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {array:?})");
939
940 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
941 if offset < 0 || offset > count {
942 return Err(jvm
943 .exception(
944 "java/lang/StringIndexOutOfBoundsException",
945 &alloc::format!("offset {offset}, length {count}"),
946 )
947 .await);
948 }
949 if array.is_null() {
950 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
951 }
952 let chars = jvm.load_array(&array, 0, jvm.array_length(&array).await?).await?;
953 Self::insert_utf16(jvm, &mut this, offset, chars).await?;
954 Ok(this)
955 }
956
957 async fn insert_char_array_range(
958 jvm: &Jvm,
959 _: &mut RuntimeContext,
960 this: ClassInstanceRef<Self>,
961 index: i32,
962 array: ClassInstanceRef<Array<JavaChar>>,
963 offset: i32,
964 length: i32,
965 ) -> Result<ClassInstanceRef<Self>> {
966 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
967 .invoke_special(
968 &this,
969 "java/lang/AbstractStringBuilder",
970 "insert",
971 "(I[CII)Ljava/lang/AbstractStringBuilder;",
972 (index, array, offset, length),
973 )
974 .await?;
975 Ok(this)
976 }
977
978 async fn insert_char_sequence(
979 jvm: &Jvm,
980 _: &mut RuntimeContext,
981 this: ClassInstanceRef<Self>,
982 offset: i32,
983 sequence: ClassInstanceRef<CharSequence>,
984 ) -> Result<ClassInstanceRef<Self>> {
985 if sequence.is_null() {
986 let sequence = JavaLangString::from_rust_string(jvm, "null").await?;
987 let _: ClassInstanceRef<Self> = jvm
988 .invoke_virtual(
989 &this,
990 "java/lang/StringBuffer",
991 "insert",
992 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
993 (offset, sequence),
994 )
995 .await?;
996 } else if jvm.is_instance(&**sequence, "java/lang/String") {
997 let sequence: ClassInstanceRef<String> = ClassInstanceRef::new(sequence.instance);
998 let _: ClassInstanceRef<Self> = jvm
999 .invoke_virtual(
1000 &this,
1001 "java/lang/StringBuffer",
1002 "insert",
1003 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
1004 (offset, sequence),
1005 )
1006 .await?;
1007 } else {
1008 let length: i32 = jvm
1009 .invoke_virtual(&sequence, &sequence.class_definition().name(), "length", "()I", ())
1010 .await?;
1011 let _: ClassInstanceRef<Self> = jvm
1012 .invoke_virtual(
1013 &this,
1014 "java/lang/StringBuffer",
1015 "insert",
1016 "(ILjava/lang/CharSequence;II)Ljava/lang/StringBuffer;",
1017 (offset, sequence, 0, length),
1018 )
1019 .await?;
1020 }
1021 Ok(this)
1022 }
1023
1024 async fn insert_char_sequence_range(
1025 jvm: &Jvm,
1026 _: &mut RuntimeContext,
1027 this: ClassInstanceRef<Self>,
1028 offset: i32,
1029 sequence: ClassInstanceRef<CharSequence>,
1030 start: i32,
1031 end: i32,
1032 ) -> Result<ClassInstanceRef<Self>> {
1033 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
1034 .invoke_special(
1035 &this,
1036 "java/lang/AbstractStringBuilder",
1037 "insert",
1038 "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
1039 (offset, sequence, start, end),
1040 )
1041 .await?;
1042 Ok(this)
1043 }
1044
1045 async fn delete(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, start: i32, end: i32) -> Result<ClassInstanceRef<Self>> {
1046 tracing::debug!("java.lang.StringBuffer::delete({this:?}, {start}, {end})");
1047
1048 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1049 let end = end.min(count);
1050 if start < 0 || start > end {
1051 return Err(jvm
1052 .exception(
1053 "java/lang/StringIndexOutOfBoundsException",
1054 &alloc::format!("start {start}, end {end}, length {count}"),
1055 )
1056 .await);
1057 }
1058
1059 if start != end {
1060 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1061 let tail: Vec<JavaChar> = jvm.load_array(&value, end as usize, (count - end) as usize).await?;
1062 jvm.store_array(&mut value, start as usize, tail).await?;
1063 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - (end - start))
1064 .await?;
1065 }
1066 Ok(this)
1067 }
1068
1069 async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Self>> {
1070 tracing::debug!("java.lang.StringBuffer::deleteCharAt({this:?}, {index})");
1071
1072 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1073 if index < 0 || index >= count {
1074 return Err(jvm
1075 .exception(
1076 "java/lang/StringIndexOutOfBoundsException",
1077 &alloc::format!("index {index}, length {count}"),
1078 )
1079 .await);
1080 }
1081
1082 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1083 let tail: Vec<JavaChar> = jvm.load_array(&value, (index + 1) as usize, (count - index - 1) as usize).await?;
1084 jvm.store_array(&mut value, index as usize, tail).await?;
1085 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - 1).await?;
1086 Ok(this)
1087 }
1088
1089 async fn replace(
1090 jvm: &Jvm,
1091 _: &mut RuntimeContext,
1092 mut this: ClassInstanceRef<Self>,
1093 start: i32,
1094 end: i32,
1095 string: ClassInstanceRef<String>,
1096 ) -> Result<ClassInstanceRef<Self>> {
1097 tracing::debug!("java.lang.StringBuffer::replace({this:?}, {start}, {end}, {string:?})");
1098
1099 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1100 let end = end.min(count);
1101 if start < 0 || start > count || start > end {
1102 return Err(jvm
1103 .exception(
1104 "java/lang/StringIndexOutOfBoundsException",
1105 &alloc::format!("start {start}, end {end}, length {count}"),
1106 )
1107 .await);
1108 }
1109 if string.is_null() {
1110 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1111 }
1112
1113 let replacement = JavaLangString::to_utf16(jvm, &string).await?;
1114 let replacement_length = replacement.len() as i32;
1115 let new_count = count + replacement_length - (end - start);
1116 let mut value = Self::expand_capacity(jvm, &mut this, new_count).await?;
1117 let tail: Vec<JavaChar> = jvm.load_array(&value, end as usize, (count - end) as usize).await?;
1118 jvm.store_array(&mut value, (start + replacement_length) as usize, tail).await?;
1119 jvm.store_array(&mut value, start as usize, replacement).await?;
1120 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_count).await?;
1121 Ok(this)
1122 }
1123
1124 async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, start: i32) -> Result<ClassInstanceRef<String>> {
1125 tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start})");
1126
1127 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1128 jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, count))
1129 .await
1130 }
1131
1132 async fn substring_range(
1133 jvm: &Jvm,
1134 _: &mut RuntimeContext,
1135 this: ClassInstanceRef<Self>,
1136 start: i32,
1137 end: i32,
1138 ) -> Result<ClassInstanceRef<String>> {
1139 tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start}, {end})");
1140
1141 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1142 if start < 0 || end > count || start > end {
1143 return Err(jvm
1144 .exception(
1145 "java/lang/StringIndexOutOfBoundsException",
1146 &alloc::format!("start {start}, end {end}, length {count}"),
1147 )
1148 .await);
1149 }
1150
1151 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1152 Ok(jvm.new_class("java/lang/String", "([CII)V", (value, start, end - start)).await?.into())
1153 }
1154
1155 async fn sub_sequence(
1156 jvm: &Jvm,
1157 _: &mut RuntimeContext,
1158 this: ClassInstanceRef<Self>,
1159 start: i32,
1160 end: i32,
1161 ) -> Result<ClassInstanceRef<CharSequence>> {
1162 tracing::debug!("java.lang.StringBuffer::subSequence({this:?}, {start}, {end})");
1163
1164 jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, end))
1165 .await
1166 }
1167
1168 async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1169 tracing::debug!("java.lang.StringBuffer::reverse({this:?})");
1170
1171 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1172 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1173 let mut chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1174 chars.reverse();
1175 jvm.store_array(&mut value, 0, chars).await?;
1176 Ok(this)
1177 }
1178
1179 async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1180 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "indexOf", "(Ljava/lang/String;)I", (string,))
1181 .await
1182 }
1183
1184 async fn index_of_from(
1185 jvm: &Jvm,
1186 _: &mut RuntimeContext,
1187 this: ClassInstanceRef<Self>,
1188 string: ClassInstanceRef<String>,
1189 from_index: i32,
1190 ) -> Result<i32> {
1191 jvm.invoke_special(
1192 &this,
1193 "java/lang/AbstractStringBuilder",
1194 "indexOf",
1195 "(Ljava/lang/String;I)I",
1196 (string, from_index),
1197 )
1198 .await
1199 }
1200
1201 async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1202 jvm.invoke_special(
1203 &this,
1204 "java/lang/AbstractStringBuilder",
1205 "lastIndexOf",
1206 "(Ljava/lang/String;)I",
1207 (string,),
1208 )
1209 .await
1210 }
1211
1212 async fn last_index_of_from(
1213 jvm: &Jvm,
1214 _: &mut RuntimeContext,
1215 this: ClassInstanceRef<Self>,
1216 string: ClassInstanceRef<String>,
1217 from_index: i32,
1218 ) -> Result<i32> {
1219 jvm.invoke_special(
1220 &this,
1221 "java/lang/AbstractStringBuilder",
1222 "lastIndexOf",
1223 "(Ljava/lang/String;I)I",
1224 (string, from_index),
1225 )
1226 .await
1227 }
1228
1229 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
1230 tracing::debug!("java.lang.StringBuffer::toString({this:?})");
1231
1232 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1233 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1234
1235 let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1237
1238 Ok(JavaLangString::from_utf16(jvm, chars).await?.into())
1239 }
1240
1241 async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1242 tracing::debug!("java.lang.StringBuffer::capacity({this:?})");
1243
1244 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1245 Ok(jvm.array_length(&value).await? as i32)
1246 }
1247
1248 async fn ensure_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
1249 tracing::debug!("java.lang.StringBuffer::ensureCapacity({this:?}, {minimum_capacity})");
1250
1251 if minimum_capacity > 0 {
1252 Self::expand_capacity(jvm, &mut this, minimum_capacity).await?;
1253 }
1254 Ok(())
1255 }
1256
1257 async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
1258 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "trimToSize", "()V", ())
1259 .await
1260 }
1261
1262 async fn set_length(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_length: i32) -> Result<()> {
1263 tracing::debug!("java.lang.StringBuffer::setLength({this:?}, {new_length})");
1264
1265 if new_length < 0 {
1266 return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &new_length.to_string()).await);
1267 }
1268
1269 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1270 if new_length > count {
1271 let mut value = Self::expand_capacity(jvm, &mut this, new_length).await?;
1272 jvm.store_array(&mut value, count as usize, vec![0 as JavaChar; (new_length - count) as usize])
1273 .await?;
1274 }
1275 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_length).await?;
1276 Ok(())
1277 }
1278
1279 async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1280 tracing::debug!("java.lang.StringBuffer::length({this:?})");
1281
1282 jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await
1283 }
1284
1285 async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<JavaChar> {
1286 tracing::debug!("java.lang.StringBuffer::charAt({this:?}, {index})");
1287
1288 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1289 if index < 0 || index >= count {
1290 return Err(jvm
1291 .exception(
1292 "java/lang/StringIndexOutOfBoundsException",
1293 &alloc::format!("index {index}, length {count}"),
1294 )
1295 .await);
1296 }
1297
1298 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1299 Ok(jvm.load_array(&value, index as usize, 1).await?[0])
1300 }
1301
1302 async fn code_point_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1303 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointAt", "(I)I", (index,))
1304 .await
1305 }
1306
1307 async fn code_point_before(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1308 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointBefore", "(I)I", (index,))
1309 .await
1310 }
1311
1312 async fn code_point_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, begin: i32, end: i32) -> Result<i32> {
1313 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointCount", "(II)I", (begin, end))
1314 .await
1315 }
1316
1317 async fn offset_by_code_points(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, offset: i32) -> Result<i32> {
1318 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "offsetByCodePoints", "(II)I", (index, offset))
1319 .await
1320 }
1321
1322 async fn set_char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, character: JavaChar) -> Result<()> {
1323 tracing::debug!("java.lang.StringBuffer::setCharAt({this:?}, {index}, {character})");
1324
1325 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1326 if index < 0 || index >= count {
1327 return Err(jvm
1328 .exception(
1329 "java/lang/StringIndexOutOfBoundsException",
1330 &alloc::format!("index {index}, length {count}"),
1331 )
1332 .await);
1333 }
1334
1335 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1336 jvm.store_array(&mut value, index as usize, [character]).await
1337 }
1338
1339 async fn get_chars(
1340 jvm: &Jvm,
1341 _: &mut RuntimeContext,
1342 this: ClassInstanceRef<Self>,
1343 src_begin: i32,
1344 src_end: i32,
1345 mut destination: ClassInstanceRef<Array<JavaChar>>,
1346 dst_begin: i32,
1347 ) -> Result<()> {
1348 tracing::debug!("java.lang.StringBuffer::getChars({this:?}, {src_begin}, {src_end}, {destination:?}, {dst_begin})");
1349
1350 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1351 if src_begin < 0 || src_end > count || src_begin > src_end {
1352 return Err(jvm
1353 .exception(
1354 "java/lang/StringIndexOutOfBoundsException",
1355 &alloc::format!("start {src_begin}, end {src_end}, length {count}"),
1356 )
1357 .await);
1358 }
1359 if destination.is_null() {
1360 return Err(jvm.exception("java/lang/NullPointerException", "dst is null").await);
1361 }
1362
1363 let copy_length = src_end - src_begin;
1364 let destination_length = jvm.array_length(&destination).await? as i32;
1365 if dst_begin < 0 || dst_begin > destination_length - copy_length {
1366 return Err(jvm
1367 .exception(
1368 "java/lang/ArrayIndexOutOfBoundsException",
1369 &alloc::format!("offset {dst_begin}, length {copy_length}, array length {destination_length}"),
1370 )
1371 .await);
1372 }
1373
1374 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1375 let chars: Vec<JavaChar> = jvm.load_array(&value, src_begin as usize, copy_length as usize).await?;
1376 jvm.store_array(&mut destination, dst_begin as usize, chars).await
1377 }
1378
1379 async fn expand_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<ClassInstanceRef<Array<JavaChar>>> {
1380 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?;
1381 let old_capacity = jvm.array_length(&value).await? as i32;
1382 if minimum_capacity <= old_capacity {
1383 return Ok(value);
1384 }
1385
1386 let new_capacity = minimum_capacity.max(old_capacity.saturating_mul(2).saturating_add(2));
1387 let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1388 let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1389 let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?;
1390 jvm.store_array(&mut new_value, 0, chars).await?;
1391 jvm.put_field(this, "java/lang/StringBuffer", "value", "[C", new_value.clone()).await?;
1392 Ok(new_value.into())
1393 }
1394
1395 async fn append_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, chars: Vec<JavaChar>) -> Result<()> {
1396 let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1397 let new_count = count + chars.len() as i32;
1398 let mut value = Self::expand_capacity(jvm, this, new_count).await?;
1399 jvm.store_array(&mut value, count as usize, chars).await?;
1400 jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await
1401 }
1402
1403 async fn insert_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, offset: i32, chars: Vec<JavaChar>) -> Result<()> {
1404 let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1405 if offset < 0 || offset > count {
1406 return Err(jvm
1407 .exception(
1408 "java/lang/StringIndexOutOfBoundsException",
1409 &alloc::format!("offset {offset}, length {count}"),
1410 )
1411 .await);
1412 }
1413
1414 let inserted_length = chars.len() as i32;
1415 let new_count = count + inserted_length;
1416 let mut value = Self::expand_capacity(jvm, this, new_count).await?;
1417 let tail: Vec<JavaChar> = jvm.load_array(&value, offset as usize, (count - offset) as usize).await?;
1418 jvm.store_array(&mut value, (offset + inserted_length) as usize, tail).await?;
1419 jvm.store_array(&mut value, offset as usize, chars).await?;
1420 jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await
1421 }
1422}