Skip to main content

rustjava_runtime/classes/java/lang/
string_buffer.rs

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
12// public final class java.lang.StringBuffer
13pub 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        // the buffer stays mutable, so snapshot it instead of handing it to the sharing constructor
1259        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}