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::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::BRIDGE | MethodAccessFlags::SYNTHETIC,
350 ),
351 JavaMethodProto::new(
352 "append",
353 "(J)Ljava/lang/AbstractStringBuilder;",
354 Self::append_long,
355 MethodAccessFlags::PUBLIC | 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, this: ClassInstanceRef<Self>, value: bool) -> Result<ClassInstanceRef<Self>> {
656 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
657
658 let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
659 jvm.invoke_virtual(
660 &this,
661 "java/lang/StringBuffer",
662 "append",
663 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
664 (string,),
665 )
666 .await
667 }
668
669 async fn append_character(
670 jvm: &Jvm,
671 _: &mut RuntimeContext,
672 mut this: ClassInstanceRef<Self>,
673 value: JavaChar,
674 ) -> Result<ClassInstanceRef<Self>> {
675 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
676
677 Self::append_utf16(jvm, &mut this, vec![value]).await?;
678 Ok(this)
679 }
680
681 async fn append_integer(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<ClassInstanceRef<Self>> {
682 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
683
684 let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
685 jvm.invoke_virtual(
686 &this,
687 "java/lang/StringBuffer",
688 "append",
689 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
690 (string,),
691 )
692 .await
693 }
694
695 async fn append_code_point(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, code_point: i32) -> Result<ClassInstanceRef<Self>> {
696 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
697 .invoke_special(
698 &this,
699 "java/lang/AbstractStringBuilder",
700 "appendCodePoint",
701 "(I)Ljava/lang/AbstractStringBuilder;",
702 (code_point,),
703 )
704 .await?;
705 Ok(this)
706 }
707
708 async fn append_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<Self>> {
709 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
710
711 let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
712 jvm.invoke_virtual(
713 &this,
714 "java/lang/StringBuffer",
715 "append",
716 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
717 (string,),
718 )
719 .await
720 }
721
722 async fn append_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<ClassInstanceRef<Self>> {
723 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
724
725 let string: ClassInstanceRef<String> = jvm
726 .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
727 .await?;
728 jvm.invoke_virtual(
729 &this,
730 "java/lang/StringBuffer",
731 "append",
732 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
733 (string,),
734 )
735 .await
736 }
737
738 async fn append_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<Self>> {
739 tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
740
741 let string: ClassInstanceRef<String> = jvm
742 .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
743 .await?;
744 jvm.invoke_virtual(
745 &this,
746 "java/lang/StringBuffer",
747 "append",
748 "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
749 (string,),
750 )
751 .await
752 }
753
754 async fn append_char_array_all(
755 jvm: &Jvm,
756 _: &mut RuntimeContext,
757 mut this: ClassInstanceRef<Self>,
758 array: ClassInstanceRef<Array<JavaChar>>,
759 ) -> Result<ClassInstanceRef<Self>> {
760 tracing::debug!("java.lang.StringBuffer::append({this:?}, {array:?})");
761
762 if array.is_null() {
763 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
764 }
765 let length = jvm.array_length(&array).await?;
766 let chars = jvm.load_array(&array, 0, length).await?;
767 Self::append_utf16(jvm, &mut this, chars).await?;
768 Ok(this)
769 }
770
771 async fn append_char_array(
772 jvm: &Jvm,
773 _: &mut RuntimeContext,
774 mut this: ClassInstanceRef<Self>,
775 array: ClassInstanceRef<Array<JavaChar>>,
776 offset: i32,
777 length: i32,
778 ) -> Result<ClassInstanceRef<Self>> {
779 tracing::debug!("java.lang.StringBuffer::append({this:?}, {array:?}, {offset}, {length})");
780
781 if array.is_null() {
782 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
783 }
784 let array_length = jvm.array_length(&array).await? as i32;
785 if offset < 0 || length < 0 || offset > array_length - length {
786 return Err(jvm
787 .exception(
788 "java/lang/IndexOutOfBoundsException",
789 &alloc::format!("offset {offset}, length {length}, array length {array_length}"),
790 )
791 .await);
792 }
793 let chars = jvm.load_array(&array, offset as usize, length as usize).await?;
794 Self::append_utf16(jvm, &mut this, chars).await?;
795 Ok(this)
796 }
797
798 async fn insert_string(
799 jvm: &Jvm,
800 _: &mut RuntimeContext,
801 mut this: ClassInstanceRef<Self>,
802 offset: i32,
803 string: ClassInstanceRef<String>,
804 ) -> Result<ClassInstanceRef<Self>> {
805 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {string:?})");
806
807 let chars = if string.is_null() {
808 "null".encode_utf16().collect()
809 } else {
810 JavaLangString::to_utf16(jvm, &string).await?
811 };
812 Self::insert_utf16(jvm, &mut this, offset, chars).await?;
813 Ok(this)
814 }
815
816 async fn insert_object(
817 jvm: &Jvm,
818 _: &mut RuntimeContext,
819 this: ClassInstanceRef<Self>,
820 offset: i32,
821 object: ClassInstanceRef<Object>,
822 ) -> Result<ClassInstanceRef<Self>> {
823 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {object:?})");
824
825 let string: ClassInstanceRef<String> = if object.is_null() {
826 JavaLangString::from_rust_string(jvm, "null").await?.into()
827 } else {
828 jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
829 .await?
830 };
831 jvm.invoke_virtual(
832 &this,
833 "java/lang/StringBuffer",
834 "insert",
835 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
836 (offset, string),
837 )
838 .await
839 }
840
841 async fn insert_boolean(
842 jvm: &Jvm,
843 _: &mut RuntimeContext,
844 this: ClassInstanceRef<Self>,
845 offset: i32,
846 value: bool,
847 ) -> Result<ClassInstanceRef<Self>> {
848 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
849
850 let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
851 jvm.invoke_virtual(
852 &this,
853 "java/lang/StringBuffer",
854 "insert",
855 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
856 (offset, string),
857 )
858 .await
859 }
860
861 async fn insert_character(
862 jvm: &Jvm,
863 _: &mut RuntimeContext,
864 mut this: ClassInstanceRef<Self>,
865 offset: i32,
866 value: JavaChar,
867 ) -> Result<ClassInstanceRef<Self>> {
868 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
869
870 Self::insert_utf16(jvm, &mut this, offset, vec![value]).await?;
871 Ok(this)
872 }
873
874 async fn insert_integer(
875 jvm: &Jvm,
876 _: &mut RuntimeContext,
877 this: ClassInstanceRef<Self>,
878 offset: i32,
879 value: i32,
880 ) -> Result<ClassInstanceRef<Self>> {
881 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
882
883 let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
884 jvm.invoke_virtual(
885 &this,
886 "java/lang/StringBuffer",
887 "insert",
888 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
889 (offset, string),
890 )
891 .await
892 }
893
894 async fn insert_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i64) -> Result<ClassInstanceRef<Self>> {
895 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
896
897 let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
898 jvm.invoke_virtual(
899 &this,
900 "java/lang/StringBuffer",
901 "insert",
902 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
903 (offset, string),
904 )
905 .await
906 }
907
908 async fn insert_float(
909 jvm: &Jvm,
910 _: &mut RuntimeContext,
911 this: ClassInstanceRef<Self>,
912 offset: i32,
913 value: f32,
914 ) -> Result<ClassInstanceRef<Self>> {
915 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
916
917 let string: ClassInstanceRef<String> = jvm
918 .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
919 .await?;
920 jvm.invoke_virtual(
921 &this,
922 "java/lang/StringBuffer",
923 "insert",
924 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
925 (offset, string),
926 )
927 .await
928 }
929
930 async fn insert_double(
931 jvm: &Jvm,
932 _: &mut RuntimeContext,
933 this: ClassInstanceRef<Self>,
934 offset: i32,
935 value: f64,
936 ) -> Result<ClassInstanceRef<Self>> {
937 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
938
939 let string: ClassInstanceRef<String> = jvm
940 .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
941 .await?;
942 jvm.invoke_virtual(
943 &this,
944 "java/lang/StringBuffer",
945 "insert",
946 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
947 (offset, string),
948 )
949 .await
950 }
951
952 async fn insert_char_array(
953 jvm: &Jvm,
954 _: &mut RuntimeContext,
955 mut this: ClassInstanceRef<Self>,
956 offset: i32,
957 array: ClassInstanceRef<Array<JavaChar>>,
958 ) -> Result<ClassInstanceRef<Self>> {
959 tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {array:?})");
960
961 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
962 if offset < 0 || offset > count {
963 return Err(jvm
964 .exception(
965 "java/lang/StringIndexOutOfBoundsException",
966 &alloc::format!("offset {offset}, length {count}"),
967 )
968 .await);
969 }
970 if array.is_null() {
971 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
972 }
973 let chars = jvm.load_array(&array, 0, jvm.array_length(&array).await?).await?;
974 Self::insert_utf16(jvm, &mut this, offset, chars).await?;
975 Ok(this)
976 }
977
978 async fn insert_char_array_range(
979 jvm: &Jvm,
980 _: &mut RuntimeContext,
981 this: ClassInstanceRef<Self>,
982 index: i32,
983 array: ClassInstanceRef<Array<JavaChar>>,
984 offset: i32,
985 length: i32,
986 ) -> Result<ClassInstanceRef<Self>> {
987 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
988 .invoke_special(
989 &this,
990 "java/lang/AbstractStringBuilder",
991 "insert",
992 "(I[CII)Ljava/lang/AbstractStringBuilder;",
993 (index, array, offset, length),
994 )
995 .await?;
996 Ok(this)
997 }
998
999 async fn insert_char_sequence(
1000 jvm: &Jvm,
1001 _: &mut RuntimeContext,
1002 this: ClassInstanceRef<Self>,
1003 offset: i32,
1004 sequence: ClassInstanceRef<CharSequence>,
1005 ) -> Result<ClassInstanceRef<Self>> {
1006 if sequence.is_null() {
1007 let sequence = JavaLangString::from_rust_string(jvm, "null").await?;
1008 let _: ClassInstanceRef<Self> = jvm
1009 .invoke_virtual(
1010 &this,
1011 "java/lang/StringBuffer",
1012 "insert",
1013 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
1014 (offset, sequence),
1015 )
1016 .await?;
1017 } else if jvm.is_instance(&**sequence, "java/lang/String") {
1018 let sequence: ClassInstanceRef<String> = ClassInstanceRef::new(sequence.instance);
1019 let _: ClassInstanceRef<Self> = jvm
1020 .invoke_virtual(
1021 &this,
1022 "java/lang/StringBuffer",
1023 "insert",
1024 "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
1025 (offset, sequence),
1026 )
1027 .await?;
1028 } else {
1029 let length: i32 = jvm
1030 .invoke_virtual(&sequence, &sequence.class_definition().name(), "length", "()I", ())
1031 .await?;
1032 let _: ClassInstanceRef<Self> = jvm
1033 .invoke_virtual(
1034 &this,
1035 "java/lang/StringBuffer",
1036 "insert",
1037 "(ILjava/lang/CharSequence;II)Ljava/lang/StringBuffer;",
1038 (offset, sequence, 0, length),
1039 )
1040 .await?;
1041 }
1042 Ok(this)
1043 }
1044
1045 async fn insert_char_sequence_range(
1046 jvm: &Jvm,
1047 _: &mut RuntimeContext,
1048 this: ClassInstanceRef<Self>,
1049 offset: i32,
1050 sequence: ClassInstanceRef<CharSequence>,
1051 start: i32,
1052 end: i32,
1053 ) -> Result<ClassInstanceRef<Self>> {
1054 let _: ClassInstanceRef<AbstractStringBuilder> = jvm
1055 .invoke_special(
1056 &this,
1057 "java/lang/AbstractStringBuilder",
1058 "insert",
1059 "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
1060 (offset, sequence, start, end),
1061 )
1062 .await?;
1063 Ok(this)
1064 }
1065
1066 async fn delete(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, start: i32, end: i32) -> Result<ClassInstanceRef<Self>> {
1067 tracing::debug!("java.lang.StringBuffer::delete({this:?}, {start}, {end})");
1068
1069 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1070 let end = end.min(count);
1071 if start < 0 || start > end {
1072 return Err(jvm
1073 .exception(
1074 "java/lang/StringIndexOutOfBoundsException",
1075 &alloc::format!("start {start}, end {end}, length {count}"),
1076 )
1077 .await);
1078 }
1079
1080 if start != end {
1081 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1082 let tail: Vec<JavaChar> = jvm.load_array(&value, end as usize, (count - end) as usize).await?;
1083 jvm.store_array(&mut value, start as usize, tail).await?;
1084 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - (end - start))
1085 .await?;
1086 }
1087 Ok(this)
1088 }
1089
1090 async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Self>> {
1091 tracing::debug!("java.lang.StringBuffer::deleteCharAt({this:?}, {index})");
1092
1093 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1094 if index < 0 || index >= count {
1095 return Err(jvm
1096 .exception(
1097 "java/lang/StringIndexOutOfBoundsException",
1098 &alloc::format!("index {index}, length {count}"),
1099 )
1100 .await);
1101 }
1102
1103 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1104 let tail: Vec<JavaChar> = jvm.load_array(&value, (index + 1) as usize, (count - index - 1) as usize).await?;
1105 jvm.store_array(&mut value, index as usize, tail).await?;
1106 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - 1).await?;
1107 Ok(this)
1108 }
1109
1110 async fn replace(
1111 jvm: &Jvm,
1112 _: &mut RuntimeContext,
1113 mut this: ClassInstanceRef<Self>,
1114 start: i32,
1115 end: i32,
1116 string: ClassInstanceRef<String>,
1117 ) -> Result<ClassInstanceRef<Self>> {
1118 tracing::debug!("java.lang.StringBuffer::replace({this:?}, {start}, {end}, {string:?})");
1119
1120 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1121 let end = end.min(count);
1122 if start < 0 || start > count || start > end {
1123 return Err(jvm
1124 .exception(
1125 "java/lang/StringIndexOutOfBoundsException",
1126 &alloc::format!("start {start}, end {end}, length {count}"),
1127 )
1128 .await);
1129 }
1130 if string.is_null() {
1131 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1132 }
1133
1134 let replacement = JavaLangString::to_utf16(jvm, &string).await?;
1135 let replacement_length = replacement.len() as i32;
1136 let new_count = count + replacement_length - (end - start);
1137 Self::expand_capacity(jvm, &mut this, new_count).await?;
1138
1139 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1140 let tail: Vec<JavaChar> = jvm.load_array(&value, end as usize, (count - end) as usize).await?;
1141 jvm.store_array(&mut value, (start + replacement_length) as usize, tail).await?;
1142 jvm.store_array(&mut value, start as usize, replacement).await?;
1143 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_count).await?;
1144 Ok(this)
1145 }
1146
1147 async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, start: i32) -> Result<ClassInstanceRef<String>> {
1148 tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start})");
1149
1150 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1151 jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, count))
1152 .await
1153 }
1154
1155 async fn substring_range(
1156 jvm: &Jvm,
1157 _: &mut RuntimeContext,
1158 this: ClassInstanceRef<Self>,
1159 start: i32,
1160 end: i32,
1161 ) -> Result<ClassInstanceRef<String>> {
1162 tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start}, {end})");
1163
1164 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1165 if start < 0 || end > count || start > end {
1166 return Err(jvm
1167 .exception(
1168 "java/lang/StringIndexOutOfBoundsException",
1169 &alloc::format!("start {start}, end {end}, length {count}"),
1170 )
1171 .await);
1172 }
1173
1174 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1175 Ok(jvm.new_class("java/lang/String", "([CII)V", (value, start, end - start)).await?.into())
1176 }
1177
1178 async fn sub_sequence(
1179 jvm: &Jvm,
1180 _: &mut RuntimeContext,
1181 this: ClassInstanceRef<Self>,
1182 start: i32,
1183 end: i32,
1184 ) -> Result<ClassInstanceRef<CharSequence>> {
1185 tracing::debug!("java.lang.StringBuffer::subSequence({this:?}, {start}, {end})");
1186
1187 jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, end))
1188 .await
1189 }
1190
1191 async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1192 tracing::debug!("java.lang.StringBuffer::reverse({this:?})");
1193
1194 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1195 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1196 let mut chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1197 chars.reverse();
1198 jvm.store_array(&mut value, 0, chars).await?;
1199 Ok(this)
1200 }
1201
1202 async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1203 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "indexOf", "(Ljava/lang/String;)I", (string,))
1204 .await
1205 }
1206
1207 async fn index_of_from(
1208 jvm: &Jvm,
1209 _: &mut RuntimeContext,
1210 this: ClassInstanceRef<Self>,
1211 string: ClassInstanceRef<String>,
1212 from_index: i32,
1213 ) -> Result<i32> {
1214 jvm.invoke_special(
1215 &this,
1216 "java/lang/AbstractStringBuilder",
1217 "indexOf",
1218 "(Ljava/lang/String;I)I",
1219 (string, from_index),
1220 )
1221 .await
1222 }
1223
1224 async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1225 jvm.invoke_special(
1226 &this,
1227 "java/lang/AbstractStringBuilder",
1228 "lastIndexOf",
1229 "(Ljava/lang/String;)I",
1230 (string,),
1231 )
1232 .await
1233 }
1234
1235 async fn last_index_of_from(
1236 jvm: &Jvm,
1237 _: &mut RuntimeContext,
1238 this: ClassInstanceRef<Self>,
1239 string: ClassInstanceRef<String>,
1240 from_index: i32,
1241 ) -> Result<i32> {
1242 jvm.invoke_special(
1243 &this,
1244 "java/lang/AbstractStringBuilder",
1245 "lastIndexOf",
1246 "(Ljava/lang/String;I)I",
1247 (string, from_index),
1248 )
1249 .await
1250 }
1251
1252 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
1253 tracing::debug!("java.lang.StringBuffer::toString({this:?})");
1254
1255 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1256 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1257
1258 let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1260
1261 Ok(JavaLangString::from_utf16(jvm, chars).await?.into())
1262 }
1263
1264 async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1265 tracing::debug!("java.lang.StringBuffer::capacity({this:?})");
1266
1267 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1268 Ok(jvm.array_length(&value).await? as i32)
1269 }
1270
1271 async fn ensure_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
1272 tracing::debug!("java.lang.StringBuffer::ensureCapacity({this:?}, {minimum_capacity})");
1273
1274 if minimum_capacity > 0 {
1275 Self::expand_capacity(jvm, &mut this, minimum_capacity).await?;
1276 }
1277 Ok(())
1278 }
1279
1280 async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
1281 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "trimToSize", "()V", ())
1282 .await
1283 }
1284
1285 async fn set_length(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_length: i32) -> Result<()> {
1286 tracing::debug!("java.lang.StringBuffer::setLength({this:?}, {new_length})");
1287
1288 if new_length < 0 {
1289 return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &new_length.to_string()).await);
1290 }
1291
1292 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1293 if new_length > count {
1294 Self::expand_capacity(jvm, &mut this, new_length).await?;
1295 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1296 jvm.store_array(&mut value, count as usize, vec![0 as JavaChar; (new_length - count) as usize])
1297 .await?;
1298 }
1299 jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_length).await?;
1300 Ok(())
1301 }
1302
1303 async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1304 tracing::debug!("java.lang.StringBuffer::length({this:?})");
1305
1306 jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await
1307 }
1308
1309 async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<JavaChar> {
1310 tracing::debug!("java.lang.StringBuffer::charAt({this:?}, {index})");
1311
1312 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1313 if index < 0 || index >= count {
1314 return Err(jvm
1315 .exception(
1316 "java/lang/StringIndexOutOfBoundsException",
1317 &alloc::format!("index {index}, length {count}"),
1318 )
1319 .await);
1320 }
1321
1322 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1323 Ok(jvm.load_array(&value, index as usize, 1).await?[0])
1324 }
1325
1326 async fn code_point_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1327 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointAt", "(I)I", (index,))
1328 .await
1329 }
1330
1331 async fn code_point_before(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1332 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointBefore", "(I)I", (index,))
1333 .await
1334 }
1335
1336 async fn code_point_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, begin: i32, end: i32) -> Result<i32> {
1337 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointCount", "(II)I", (begin, end))
1338 .await
1339 }
1340
1341 async fn offset_by_code_points(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, offset: i32) -> Result<i32> {
1342 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "offsetByCodePoints", "(II)I", (index, offset))
1343 .await
1344 }
1345
1346 async fn set_char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, character: JavaChar) -> Result<()> {
1347 tracing::debug!("java.lang.StringBuffer::setCharAt({this:?}, {index}, {character})");
1348
1349 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1350 if index < 0 || index >= count {
1351 return Err(jvm
1352 .exception(
1353 "java/lang/StringIndexOutOfBoundsException",
1354 &alloc::format!("index {index}, length {count}"),
1355 )
1356 .await);
1357 }
1358
1359 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1360 jvm.store_array(&mut value, index as usize, [character]).await
1361 }
1362
1363 async fn get_chars(
1364 jvm: &Jvm,
1365 _: &mut RuntimeContext,
1366 this: ClassInstanceRef<Self>,
1367 src_begin: i32,
1368 src_end: i32,
1369 mut destination: ClassInstanceRef<Array<JavaChar>>,
1370 dst_begin: i32,
1371 ) -> Result<()> {
1372 tracing::debug!("java.lang.StringBuffer::getChars({this:?}, {src_begin}, {src_end}, {destination:?}, {dst_begin})");
1373
1374 let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1375 if src_begin < 0 || src_end > count || src_begin > src_end {
1376 return Err(jvm
1377 .exception(
1378 "java/lang/StringIndexOutOfBoundsException",
1379 &alloc::format!("start {src_begin}, end {src_end}, length {count}"),
1380 )
1381 .await);
1382 }
1383 if destination.is_null() {
1384 return Err(jvm.exception("java/lang/NullPointerException", "dst is null").await);
1385 }
1386
1387 let copy_length = src_end - src_begin;
1388 let destination_length = jvm.array_length(&destination).await? as i32;
1389 if dst_begin < 0 || dst_begin > destination_length - copy_length {
1390 return Err(jvm
1391 .exception(
1392 "java/lang/ArrayIndexOutOfBoundsException",
1393 &alloc::format!("offset {dst_begin}, length {copy_length}, array length {destination_length}"),
1394 )
1395 .await);
1396 }
1397
1398 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1399 let chars: Vec<JavaChar> = jvm.load_array(&value, src_begin as usize, copy_length as usize).await?;
1400 jvm.store_array(&mut destination, dst_begin as usize, chars).await
1401 }
1402
1403 async fn expand_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
1404 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?;
1405 let old_capacity = jvm.array_length(&value).await? as i32;
1406 if minimum_capacity <= old_capacity {
1407 return Ok(());
1408 }
1409
1410 let new_capacity = minimum_capacity.max(old_capacity.saturating_mul(2).saturating_add(2));
1411 let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1412 let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1413 let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?;
1414 jvm.store_array(&mut new_value, 0, chars).await?;
1415 jvm.put_field(this, "java/lang/StringBuffer", "value", "[C", new_value).await
1416 }
1417
1418 async fn append_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, chars: Vec<JavaChar>) -> Result<()> {
1419 let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1420 let new_count = count + chars.len() as i32;
1421 Self::expand_capacity(jvm, this, new_count).await?;
1422
1423 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?;
1424 jvm.store_array(&mut value, count as usize, chars).await?;
1425 jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await
1426 }
1427
1428 async fn insert_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, offset: i32, chars: Vec<JavaChar>) -> Result<()> {
1429 let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1430 if offset < 0 || offset > count {
1431 return Err(jvm
1432 .exception(
1433 "java/lang/StringIndexOutOfBoundsException",
1434 &alloc::format!("offset {offset}, length {count}"),
1435 )
1436 .await);
1437 }
1438
1439 let inserted_length = chars.len() as i32;
1440 let new_count = count + inserted_length;
1441 Self::expand_capacity(jvm, this, new_count).await?;
1442 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?;
1443 let tail: Vec<JavaChar> = jvm.load_array(&value, offset as usize, (count - offset) as usize).await?;
1444 jvm.store_array(&mut value, (offset + inserted_length) as usize, tail).await?;
1445 jvm.store_array(&mut value, offset as usize, chars).await?;
1446 jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await
1447 }
1448}