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, "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        // the buffer stays mutable, so snapshot it instead of handing it to the sharing constructor
1258        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}