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, "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, "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, "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, "count", "I", count - (end - start)).await?;
1085 }
1086 Ok(this)
1087 }
1088
1089 async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Self>> {
1090 tracing::debug!("java.lang.StringBuffer::deleteCharAt({this:?}, {index})");
1091
1092 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1093 if index < 0 || index >= count {
1094 return Err(jvm
1095 .exception(
1096 "java/lang/StringIndexOutOfBoundsException",
1097 &alloc::format!("index {index}, length {count}"),
1098 )
1099 .await);
1100 }
1101
1102 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1103 let tail: Vec<JavaChar> = jvm.load_array(&value, (index + 1) as usize, (count - index - 1) as usize).await?;
1104 jvm.store_array(&mut value, index as usize, tail).await?;
1105 jvm.put_field(&mut this, "count", "I", count - 1).await?;
1106 Ok(this)
1107 }
1108
1109 async fn replace(
1110 jvm: &Jvm,
1111 _: &mut RuntimeContext,
1112 mut this: ClassInstanceRef<Self>,
1113 start: i32,
1114 end: i32,
1115 string: ClassInstanceRef<String>,
1116 ) -> Result<ClassInstanceRef<Self>> {
1117 tracing::debug!("java.lang.StringBuffer::replace({this:?}, {start}, {end}, {string:?})");
1118
1119 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1120 let end = end.min(count);
1121 if start < 0 || start > count || start > end {
1122 return Err(jvm
1123 .exception(
1124 "java/lang/StringIndexOutOfBoundsException",
1125 &alloc::format!("start {start}, end {end}, length {count}"),
1126 )
1127 .await);
1128 }
1129 if string.is_null() {
1130 return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1131 }
1132
1133 let replacement = JavaLangString::to_utf16(jvm, &string).await?;
1134 let replacement_length = replacement.len() as i32;
1135 let new_count = count + replacement_length - (end - start);
1136 Self::expand_capacity(jvm, &mut this, new_count).await?;
1137
1138 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1139 let tail: Vec<JavaChar> = jvm.load_array(&value, end as usize, (count - end) as usize).await?;
1140 jvm.store_array(&mut value, (start + replacement_length) as usize, tail).await?;
1141 jvm.store_array(&mut value, start as usize, replacement).await?;
1142 jvm.put_field(&mut this, "count", "I", new_count).await?;
1143 Ok(this)
1144 }
1145
1146 async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, start: i32) -> Result<ClassInstanceRef<String>> {
1147 tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start})");
1148
1149 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1150 jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, count))
1151 .await
1152 }
1153
1154 async fn substring_range(
1155 jvm: &Jvm,
1156 _: &mut RuntimeContext,
1157 this: ClassInstanceRef<Self>,
1158 start: i32,
1159 end: i32,
1160 ) -> Result<ClassInstanceRef<String>> {
1161 tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start}, {end})");
1162
1163 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1164 if start < 0 || end > count || start > end {
1165 return Err(jvm
1166 .exception(
1167 "java/lang/StringIndexOutOfBoundsException",
1168 &alloc::format!("start {start}, end {end}, length {count}"),
1169 )
1170 .await);
1171 }
1172
1173 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1174 Ok(jvm.new_class("java/lang/String", "([CII)V", (value, start, end - start)).await?.into())
1175 }
1176
1177 async fn sub_sequence(
1178 jvm: &Jvm,
1179 _: &mut RuntimeContext,
1180 this: ClassInstanceRef<Self>,
1181 start: i32,
1182 end: i32,
1183 ) -> Result<ClassInstanceRef<CharSequence>> {
1184 tracing::debug!("java.lang.StringBuffer::subSequence({this:?}, {start}, {end})");
1185
1186 jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, end))
1187 .await
1188 }
1189
1190 async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1191 tracing::debug!("java.lang.StringBuffer::reverse({this:?})");
1192
1193 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1194 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1195 let mut chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1196 chars.reverse();
1197 jvm.store_array(&mut value, 0, chars).await?;
1198 Ok(this)
1199 }
1200
1201 async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1202 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "indexOf", "(Ljava/lang/String;)I", (string,))
1203 .await
1204 }
1205
1206 async fn index_of_from(
1207 jvm: &Jvm,
1208 _: &mut RuntimeContext,
1209 this: ClassInstanceRef<Self>,
1210 string: ClassInstanceRef<String>,
1211 from_index: i32,
1212 ) -> Result<i32> {
1213 jvm.invoke_special(
1214 &this,
1215 "java/lang/AbstractStringBuilder",
1216 "indexOf",
1217 "(Ljava/lang/String;I)I",
1218 (string, from_index),
1219 )
1220 .await
1221 }
1222
1223 async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1224 jvm.invoke_special(
1225 &this,
1226 "java/lang/AbstractStringBuilder",
1227 "lastIndexOf",
1228 "(Ljava/lang/String;)I",
1229 (string,),
1230 )
1231 .await
1232 }
1233
1234 async fn last_index_of_from(
1235 jvm: &Jvm,
1236 _: &mut RuntimeContext,
1237 this: ClassInstanceRef<Self>,
1238 string: ClassInstanceRef<String>,
1239 from_index: i32,
1240 ) -> Result<i32> {
1241 jvm.invoke_special(
1242 &this,
1243 "java/lang/AbstractStringBuilder",
1244 "lastIndexOf",
1245 "(Ljava/lang/String;I)I",
1246 (string, from_index),
1247 )
1248 .await
1249 }
1250
1251 async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
1252 tracing::debug!("java.lang.StringBuffer::toString({this:?})");
1253
1254 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1255 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1256
1257 let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1259
1260 Ok(JavaLangString::from_utf16(jvm, chars).await?.into())
1261 }
1262
1263 async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1264 tracing::debug!("java.lang.StringBuffer::capacity({this:?})");
1265
1266 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1267 Ok(jvm.array_length(&value).await? as i32)
1268 }
1269
1270 async fn ensure_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
1271 tracing::debug!("java.lang.StringBuffer::ensureCapacity({this:?}, {minimum_capacity})");
1272
1273 if minimum_capacity > 0 {
1274 Self::expand_capacity(jvm, &mut this, minimum_capacity).await?;
1275 }
1276 Ok(())
1277 }
1278
1279 async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
1280 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "trimToSize", "()V", ())
1281 .await
1282 }
1283
1284 async fn set_length(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_length: i32) -> Result<()> {
1285 tracing::debug!("java.lang.StringBuffer::setLength({this:?}, {new_length})");
1286
1287 if new_length < 0 {
1288 return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &new_length.to_string()).await);
1289 }
1290
1291 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1292 if new_length > count {
1293 Self::expand_capacity(jvm, &mut this, new_length).await?;
1294 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1295 jvm.store_array(&mut value, count as usize, vec![0 as JavaChar; (new_length - count) as usize])
1296 .await?;
1297 }
1298 jvm.put_field(&mut this, "count", "I", new_length).await?;
1299 Ok(())
1300 }
1301
1302 async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1303 tracing::debug!("java.lang.StringBuffer::length({this:?})");
1304
1305 jvm.get_field(&this, "count", "I").await
1306 }
1307
1308 async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<JavaChar> {
1309 tracing::debug!("java.lang.StringBuffer::charAt({this:?}, {index})");
1310
1311 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1312 if index < 0 || index >= count {
1313 return Err(jvm
1314 .exception(
1315 "java/lang/StringIndexOutOfBoundsException",
1316 &alloc::format!("index {index}, length {count}"),
1317 )
1318 .await);
1319 }
1320
1321 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1322 Ok(jvm.load_array(&value, index as usize, 1).await?[0])
1323 }
1324
1325 async fn code_point_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1326 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointAt", "(I)I", (index,))
1327 .await
1328 }
1329
1330 async fn code_point_before(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1331 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointBefore", "(I)I", (index,))
1332 .await
1333 }
1334
1335 async fn code_point_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, begin: i32, end: i32) -> Result<i32> {
1336 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointCount", "(II)I", (begin, end))
1337 .await
1338 }
1339
1340 async fn offset_by_code_points(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, offset: i32) -> Result<i32> {
1341 jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "offsetByCodePoints", "(II)I", (index, offset))
1342 .await
1343 }
1344
1345 async fn set_char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, character: JavaChar) -> Result<()> {
1346 tracing::debug!("java.lang.StringBuffer::setCharAt({this:?}, {index}, {character})");
1347
1348 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1349 if index < 0 || index >= count {
1350 return Err(jvm
1351 .exception(
1352 "java/lang/StringIndexOutOfBoundsException",
1353 &alloc::format!("index {index}, length {count}"),
1354 )
1355 .await);
1356 }
1357
1358 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1359 jvm.store_array(&mut value, index as usize, [character]).await
1360 }
1361
1362 async fn get_chars(
1363 jvm: &Jvm,
1364 _: &mut RuntimeContext,
1365 this: ClassInstanceRef<Self>,
1366 src_begin: i32,
1367 src_end: i32,
1368 mut destination: ClassInstanceRef<Array<JavaChar>>,
1369 dst_begin: i32,
1370 ) -> Result<()> {
1371 tracing::debug!("java.lang.StringBuffer::getChars({this:?}, {src_begin}, {src_end}, {destination:?}, {dst_begin})");
1372
1373 let count: i32 = jvm.get_field(&this, "count", "I").await?;
1374 if src_begin < 0 || src_end > count || src_begin > src_end {
1375 return Err(jvm
1376 .exception(
1377 "java/lang/StringIndexOutOfBoundsException",
1378 &alloc::format!("start {src_begin}, end {src_end}, length {count}"),
1379 )
1380 .await);
1381 }
1382 if destination.is_null() {
1383 return Err(jvm.exception("java/lang/NullPointerException", "dst is null").await);
1384 }
1385
1386 let copy_length = src_end - src_begin;
1387 let destination_length = jvm.array_length(&destination).await? as i32;
1388 if dst_begin < 0 || dst_begin > destination_length - copy_length {
1389 return Err(jvm
1390 .exception(
1391 "java/lang/ArrayIndexOutOfBoundsException",
1392 &alloc::format!("offset {dst_begin}, length {copy_length}, array length {destination_length}"),
1393 )
1394 .await);
1395 }
1396
1397 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
1398 let chars: Vec<JavaChar> = jvm.load_array(&value, src_begin as usize, copy_length as usize).await?;
1399 jvm.store_array(&mut destination, dst_begin as usize, chars).await
1400 }
1401
1402 async fn expand_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
1403 let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "value", "[C").await?;
1404 let old_capacity = jvm.array_length(&value).await? as i32;
1405 if minimum_capacity <= old_capacity {
1406 return Ok(());
1407 }
1408
1409 let new_capacity = minimum_capacity.max(old_capacity.saturating_mul(2).saturating_add(2));
1410 let count: i32 = jvm.get_field(this, "count", "I").await?;
1411 let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1412 let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?;
1413 jvm.store_array(&mut new_value, 0, chars).await?;
1414 jvm.put_field(this, "value", "[C", new_value).await
1415 }
1416
1417 async fn append_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, chars: Vec<JavaChar>) -> Result<()> {
1418 let count: i32 = jvm.get_field(this, "count", "I").await?;
1419 let new_count = count + chars.len() as i32;
1420 Self::expand_capacity(jvm, this, new_count).await?;
1421
1422 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "value", "[C").await?;
1423 jvm.store_array(&mut value, count as usize, chars).await?;
1424 jvm.put_field(this, "count", "I", new_count).await
1425 }
1426
1427 async fn insert_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, offset: i32, chars: Vec<JavaChar>) -> Result<()> {
1428 let count: i32 = jvm.get_field(this, "count", "I").await?;
1429 if offset < 0 || offset > count {
1430 return Err(jvm
1431 .exception(
1432 "java/lang/StringIndexOutOfBoundsException",
1433 &alloc::format!("offset {offset}, length {count}"),
1434 )
1435 .await);
1436 }
1437
1438 let inserted_length = chars.len() as i32;
1439 let new_count = count + inserted_length;
1440 Self::expand_capacity(jvm, this, new_count).await?;
1441 let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "value", "[C").await?;
1442 let tail: Vec<JavaChar> = jvm.load_array(&value, offset as usize, (count - offset) as usize).await?;
1443 jvm.store_array(&mut value, (offset + inserted_length) as usize, tail).await?;
1444 jvm.store_array(&mut value, offset as usize, chars).await?;
1445 jvm.put_field(this, "count", "I", new_count).await
1446 }
1447}