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::SYNCHRONIZED | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
338                ),
339                JavaMethodProto::new(
340                    "append",
341                    "(C)Ljava/lang/AbstractStringBuilder;",
342                    Self::append_character,
343                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
344                ),
345                JavaMethodProto::new(
346                    "append",
347                    "(I)Ljava/lang/AbstractStringBuilder;",
348                    Self::append_integer,
349                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
350                ),
351                JavaMethodProto::new(
352                    "append",
353                    "(J)Ljava/lang/AbstractStringBuilder;",
354                    Self::append_long,
355                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
356                ),
357                JavaMethodProto::new(
358                    "append",
359                    "(F)Ljava/lang/AbstractStringBuilder;",
360                    Self::append_float,
361                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
362                ),
363                JavaMethodProto::new(
364                    "append",
365                    "(D)Ljava/lang/AbstractStringBuilder;",
366                    Self::append_double,
367                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
368                ),
369                JavaMethodProto::new(
370                    "appendCodePoint",
371                    "(I)Ljava/lang/AbstractStringBuilder;",
372                    Self::append_code_point,
373                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
374                ),
375                JavaMethodProto::new(
376                    "delete",
377                    "(II)Ljava/lang/AbstractStringBuilder;",
378                    Self::delete,
379                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
380                ),
381                JavaMethodProto::new(
382                    "deleteCharAt",
383                    "(I)Ljava/lang/AbstractStringBuilder;",
384                    Self::delete_char_at,
385                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
386                ),
387                JavaMethodProto::new(
388                    "replace",
389                    "(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
390                    Self::replace,
391                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
392                ),
393                JavaMethodProto::new(
394                    "insert",
395                    "(I[CII)Ljava/lang/AbstractStringBuilder;",
396                    Self::insert_char_array_range,
397                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
398                ),
399                JavaMethodProto::new(
400                    "insert",
401                    "(ILjava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
402                    Self::insert_object,
403                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
404                ),
405                JavaMethodProto::new(
406                    "insert",
407                    "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
408                    Self::insert_string,
409                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
410                ),
411                JavaMethodProto::new(
412                    "insert",
413                    "(I[C)Ljava/lang/AbstractStringBuilder;",
414                    Self::insert_char_array,
415                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
416                ),
417                JavaMethodProto::new(
418                    "insert",
419                    "(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
420                    Self::insert_char_sequence,
421                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
422                ),
423                JavaMethodProto::new(
424                    "insert",
425                    "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
426                    Self::insert_char_sequence_range,
427                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
428                ),
429                JavaMethodProto::new(
430                    "insert",
431                    "(IZ)Ljava/lang/AbstractStringBuilder;",
432                    Self::insert_boolean,
433                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
434                ),
435                JavaMethodProto::new(
436                    "insert",
437                    "(IC)Ljava/lang/AbstractStringBuilder;",
438                    Self::insert_character,
439                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
440                ),
441                JavaMethodProto::new(
442                    "insert",
443                    "(II)Ljava/lang/AbstractStringBuilder;",
444                    Self::insert_integer,
445                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
446                ),
447                JavaMethodProto::new(
448                    "insert",
449                    "(IJ)Ljava/lang/AbstractStringBuilder;",
450                    Self::insert_long,
451                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
452                ),
453                JavaMethodProto::new(
454                    "insert",
455                    "(IF)Ljava/lang/AbstractStringBuilder;",
456                    Self::insert_float,
457                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
458                ),
459                JavaMethodProto::new(
460                    "insert",
461                    "(ID)Ljava/lang/AbstractStringBuilder;",
462                    Self::insert_double,
463                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
464                ),
465                JavaMethodProto::new(
466                    "reverse",
467                    "()Ljava/lang/AbstractStringBuilder;",
468                    Self::reverse,
469                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
470                ),
471                JavaMethodProto::new(
472                    "append",
473                    "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
474                    Self::append_char_sequence,
475                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
476                ),
477                JavaMethodProto::new(
478                    "append",
479                    "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
480                    Self::append_char_sequence_range,
481                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
482                ),
483                JavaMethodProto::new(
484                    "append",
485                    "(C)Ljava/lang/Appendable;",
486                    Self::append_character,
487                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
488                ),
489            ],
490            fields: vec![],
491            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
492        }
493    }
494
495    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
496        tracing::debug!("java.lang.StringBuffer::<init>({this:?})");
497
498        jvm.invoke_special(&this, "java/lang/StringBuffer", "<init>", "(I)V", (16,)).await
499    }
500
501    async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
502        tracing::debug!("java.lang.StringBuffer::<init>({this:?}, {capacity})");
503
504        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", (capacity,))
505            .await
506    }
507
508    async fn init_with_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
509        tracing::debug!("java.lang.StringBuffer::<init>({this:?}, {string:?})");
510
511        if string.is_null() {
512            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
513        }
514
515        let chars = JavaLangString::to_utf16(jvm, &string).await?;
516        let _: () = jvm
517            .invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", ((chars.len() + 16) as i32,))
518            .await?;
519        let _: ClassInstanceRef<Self> = jvm
520            .invoke_virtual(
521                &this,
522                "java/lang/StringBuffer",
523                "append",
524                "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
525                (string,),
526            )
527            .await?;
528        Ok(())
529    }
530
531    async fn init_with_char_sequence(
532        jvm: &Jvm,
533        _: &mut RuntimeContext,
534        this: ClassInstanceRef<Self>,
535        sequence: ClassInstanceRef<CharSequence>,
536    ) -> Result<()> {
537        if sequence.is_null() {
538            return Err(jvm.exception("java/lang/NullPointerException", "seq is null").await);
539        }
540        let length: i32 = jvm
541            .invoke_virtual(&sequence, &sequence.class_definition().name(), "length", "()I", ())
542            .await?;
543        let _: () = jvm
544            .invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", (length + 16,))
545            .await?;
546        let _: ClassInstanceRef<Self> = jvm
547            .invoke_virtual(
548                &this,
549                "java/lang/StringBuffer",
550                "append",
551                "(Ljava/lang/CharSequence;)Ljava/lang/StringBuffer;",
552                (sequence,),
553            )
554            .await?;
555        Ok(())
556    }
557
558    async fn append_string(
559        jvm: &Jvm,
560        _: &mut RuntimeContext,
561        mut this: ClassInstanceRef<Self>,
562        string: ClassInstanceRef<String>,
563    ) -> Result<ClassInstanceRef<Self>> {
564        tracing::debug!("java.lang.StringBuffer::append({this:?}, {string:?})");
565
566        let chars = if string.is_null() {
567            "null".encode_utf16().collect()
568        } else {
569            JavaLangString::to_utf16(jvm, &string).await?
570        };
571        Self::append_utf16(jvm, &mut this, chars).await?;
572        Ok(this)
573    }
574
575    async fn append_object(
576        jvm: &Jvm,
577        _: &mut RuntimeContext,
578        this: ClassInstanceRef<Self>,
579        object: ClassInstanceRef<Object>,
580    ) -> Result<ClassInstanceRef<Self>> {
581        tracing::debug!("java.lang.StringBuffer::append({this:?}, {object:?})");
582
583        let string: ClassInstanceRef<String> = if object.is_null() {
584            JavaLangString::from_rust_string(jvm, "null").await?.into()
585        } else {
586            jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
587                .await?
588        };
589        jvm.invoke_virtual(
590            &this,
591            "java/lang/StringBuffer",
592            "append",
593            "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
594            (string,),
595        )
596        .await
597    }
598
599    async fn append_string_buffer(
600        jvm: &Jvm,
601        _: &mut RuntimeContext,
602        this: ClassInstanceRef<Self>,
603        buffer: ClassInstanceRef<Self>,
604    ) -> Result<ClassInstanceRef<Self>> {
605        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
606            .invoke_special(
607                &this,
608                "java/lang/AbstractStringBuilder",
609                "append",
610                "(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;",
611                (buffer,),
612            )
613            .await?;
614        Ok(this)
615    }
616
617    async fn append_char_sequence(
618        jvm: &Jvm,
619        _: &mut RuntimeContext,
620        this: ClassInstanceRef<Self>,
621        sequence: ClassInstanceRef<CharSequence>,
622    ) -> Result<ClassInstanceRef<Self>> {
623        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
624            .invoke_special(
625                &this,
626                "java/lang/AbstractStringBuilder",
627                "append",
628                "(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
629                (sequence,),
630            )
631            .await?;
632        Ok(this)
633    }
634
635    async fn append_char_sequence_range(
636        jvm: &Jvm,
637        _: &mut RuntimeContext,
638        this: ClassInstanceRef<Self>,
639        sequence: ClassInstanceRef<CharSequence>,
640        start: i32,
641        end: i32,
642    ) -> Result<ClassInstanceRef<Self>> {
643        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
644            .invoke_special(
645                &this,
646                "java/lang/AbstractStringBuilder",
647                "append",
648                "(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
649                (sequence, start, end),
650            )
651            .await?;
652        Ok(this)
653    }
654
655    async fn append_boolean(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: bool) -> Result<ClassInstanceRef<Self>> {
656        tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
657
658        Self::append_utf16(jvm, &mut this, (if value { "true" } else { "false" }).encode_utf16().collect()).await?;
659        Ok(this)
660    }
661
662    async fn append_character(
663        jvm: &Jvm,
664        _: &mut RuntimeContext,
665        mut this: ClassInstanceRef<Self>,
666        value: JavaChar,
667    ) -> Result<ClassInstanceRef<Self>> {
668        tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
669
670        Self::append_utf16(jvm, &mut this, vec![value]).await?;
671        Ok(this)
672    }
673
674    async fn append_integer(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<ClassInstanceRef<Self>> {
675        tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
676
677        Self::append_utf16(jvm, &mut this, value.to_string().encode_utf16().collect()).await?;
678        Ok(this)
679    }
680
681    async fn append_code_point(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, code_point: i32) -> Result<ClassInstanceRef<Self>> {
682        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
683            .invoke_special(
684                &this,
685                "java/lang/AbstractStringBuilder",
686                "appendCodePoint",
687                "(I)Ljava/lang/AbstractStringBuilder;",
688                (code_point,),
689            )
690            .await?;
691        Ok(this)
692    }
693
694    async fn append_long(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<Self>> {
695        tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
696
697        Self::append_utf16(jvm, &mut this, value.to_string().encode_utf16().collect()).await?;
698        Ok(this)
699    }
700
701    async fn append_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<ClassInstanceRef<Self>> {
702        tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
703
704        let string: ClassInstanceRef<String> = jvm
705            .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
706            .await?;
707        jvm.invoke_virtual(
708            &this,
709            "java/lang/StringBuffer",
710            "append",
711            "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
712            (string,),
713        )
714        .await
715    }
716
717    async fn append_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<Self>> {
718        tracing::debug!("java.lang.StringBuffer::append({this:?}, {value})");
719
720        let string: ClassInstanceRef<String> = jvm
721            .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
722            .await?;
723        jvm.invoke_virtual(
724            &this,
725            "java/lang/StringBuffer",
726            "append",
727            "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
728            (string,),
729        )
730        .await
731    }
732
733    async fn append_char_array_all(
734        jvm: &Jvm,
735        _: &mut RuntimeContext,
736        mut this: ClassInstanceRef<Self>,
737        array: ClassInstanceRef<Array<JavaChar>>,
738    ) -> Result<ClassInstanceRef<Self>> {
739        tracing::debug!("java.lang.StringBuffer::append({this:?}, {array:?})");
740
741        if array.is_null() {
742            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
743        }
744        let length = jvm.array_length(&array).await?;
745        let chars = jvm.load_array(&array, 0, length).await?;
746        Self::append_utf16(jvm, &mut this, chars).await?;
747        Ok(this)
748    }
749
750    async fn append_char_array(
751        jvm: &Jvm,
752        _: &mut RuntimeContext,
753        mut this: ClassInstanceRef<Self>,
754        array: ClassInstanceRef<Array<JavaChar>>,
755        offset: i32,
756        length: i32,
757    ) -> Result<ClassInstanceRef<Self>> {
758        tracing::debug!("java.lang.StringBuffer::append({this:?}, {array:?}, {offset}, {length})");
759
760        if array.is_null() {
761            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
762        }
763        let array_length = jvm.array_length(&array).await? as i32;
764        if offset < 0 || length < 0 || offset > array_length - length {
765            return Err(jvm
766                .exception(
767                    "java/lang/IndexOutOfBoundsException",
768                    &alloc::format!("offset {offset}, length {length}, array length {array_length}"),
769                )
770                .await);
771        }
772        let chars = jvm.load_array(&array, offset as usize, length as usize).await?;
773        Self::append_utf16(jvm, &mut this, chars).await?;
774        Ok(this)
775    }
776
777    async fn insert_string(
778        jvm: &Jvm,
779        _: &mut RuntimeContext,
780        mut this: ClassInstanceRef<Self>,
781        offset: i32,
782        string: ClassInstanceRef<String>,
783    ) -> Result<ClassInstanceRef<Self>> {
784        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {string:?})");
785
786        let chars = if string.is_null() {
787            "null".encode_utf16().collect()
788        } else {
789            JavaLangString::to_utf16(jvm, &string).await?
790        };
791        Self::insert_utf16(jvm, &mut this, offset, chars).await?;
792        Ok(this)
793    }
794
795    async fn insert_object(
796        jvm: &Jvm,
797        _: &mut RuntimeContext,
798        this: ClassInstanceRef<Self>,
799        offset: i32,
800        object: ClassInstanceRef<Object>,
801    ) -> Result<ClassInstanceRef<Self>> {
802        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {object:?})");
803
804        let string: ClassInstanceRef<String> = if object.is_null() {
805            JavaLangString::from_rust_string(jvm, "null").await?.into()
806        } else {
807            jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
808                .await?
809        };
810        jvm.invoke_virtual(
811            &this,
812            "java/lang/StringBuffer",
813            "insert",
814            "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
815            (offset, string),
816        )
817        .await
818    }
819
820    async fn insert_boolean(
821        jvm: &Jvm,
822        _: &mut RuntimeContext,
823        this: ClassInstanceRef<Self>,
824        offset: i32,
825        value: bool,
826    ) -> Result<ClassInstanceRef<Self>> {
827        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
828
829        let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
830        jvm.invoke_virtual(
831            &this,
832            "java/lang/StringBuffer",
833            "insert",
834            "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
835            (offset, string),
836        )
837        .await
838    }
839
840    async fn insert_character(
841        jvm: &Jvm,
842        _: &mut RuntimeContext,
843        mut this: ClassInstanceRef<Self>,
844        offset: i32,
845        value: JavaChar,
846    ) -> Result<ClassInstanceRef<Self>> {
847        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
848
849        Self::insert_utf16(jvm, &mut this, offset, vec![value]).await?;
850        Ok(this)
851    }
852
853    async fn insert_integer(
854        jvm: &Jvm,
855        _: &mut RuntimeContext,
856        this: ClassInstanceRef<Self>,
857        offset: i32,
858        value: i32,
859    ) -> Result<ClassInstanceRef<Self>> {
860        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
861
862        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
863        jvm.invoke_virtual(
864            &this,
865            "java/lang/StringBuffer",
866            "insert",
867            "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
868            (offset, string),
869        )
870        .await
871    }
872
873    async fn insert_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i64) -> Result<ClassInstanceRef<Self>> {
874        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
875
876        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
877        jvm.invoke_virtual(
878            &this,
879            "java/lang/StringBuffer",
880            "insert",
881            "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
882            (offset, string),
883        )
884        .await
885    }
886
887    async fn insert_float(
888        jvm: &Jvm,
889        _: &mut RuntimeContext,
890        this: ClassInstanceRef<Self>,
891        offset: i32,
892        value: f32,
893    ) -> Result<ClassInstanceRef<Self>> {
894        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
895
896        let string: ClassInstanceRef<String> = jvm
897            .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
898            .await?;
899        jvm.invoke_virtual(
900            &this,
901            "java/lang/StringBuffer",
902            "insert",
903            "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
904            (offset, string),
905        )
906        .await
907    }
908
909    async fn insert_double(
910        jvm: &Jvm,
911        _: &mut RuntimeContext,
912        this: ClassInstanceRef<Self>,
913        offset: i32,
914        value: f64,
915    ) -> Result<ClassInstanceRef<Self>> {
916        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {value})");
917
918        let string: ClassInstanceRef<String> = jvm
919            .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
920            .await?;
921        jvm.invoke_virtual(
922            &this,
923            "java/lang/StringBuffer",
924            "insert",
925            "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
926            (offset, string),
927        )
928        .await
929    }
930
931    async fn insert_char_array(
932        jvm: &Jvm,
933        _: &mut RuntimeContext,
934        mut this: ClassInstanceRef<Self>,
935        offset: i32,
936        array: ClassInstanceRef<Array<JavaChar>>,
937    ) -> Result<ClassInstanceRef<Self>> {
938        tracing::debug!("java.lang.StringBuffer::insert({this:?}, {offset}, {array:?})");
939
940        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
941        if offset < 0 || offset > count {
942            return Err(jvm
943                .exception(
944                    "java/lang/StringIndexOutOfBoundsException",
945                    &alloc::format!("offset {offset}, length {count}"),
946                )
947                .await);
948        }
949        if array.is_null() {
950            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
951        }
952        let chars = jvm.load_array(&array, 0, jvm.array_length(&array).await?).await?;
953        Self::insert_utf16(jvm, &mut this, offset, chars).await?;
954        Ok(this)
955    }
956
957    async fn insert_char_array_range(
958        jvm: &Jvm,
959        _: &mut RuntimeContext,
960        this: ClassInstanceRef<Self>,
961        index: i32,
962        array: ClassInstanceRef<Array<JavaChar>>,
963        offset: i32,
964        length: i32,
965    ) -> Result<ClassInstanceRef<Self>> {
966        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
967            .invoke_special(
968                &this,
969                "java/lang/AbstractStringBuilder",
970                "insert",
971                "(I[CII)Ljava/lang/AbstractStringBuilder;",
972                (index, array, offset, length),
973            )
974            .await?;
975        Ok(this)
976    }
977
978    async fn insert_char_sequence(
979        jvm: &Jvm,
980        _: &mut RuntimeContext,
981        this: ClassInstanceRef<Self>,
982        offset: i32,
983        sequence: ClassInstanceRef<CharSequence>,
984    ) -> Result<ClassInstanceRef<Self>> {
985        if sequence.is_null() {
986            let sequence = JavaLangString::from_rust_string(jvm, "null").await?;
987            let _: ClassInstanceRef<Self> = jvm
988                .invoke_virtual(
989                    &this,
990                    "java/lang/StringBuffer",
991                    "insert",
992                    "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
993                    (offset, sequence),
994                )
995                .await?;
996        } else if jvm.is_instance(&**sequence, "java/lang/String") {
997            let sequence: ClassInstanceRef<String> = ClassInstanceRef::new(sequence.instance);
998            let _: ClassInstanceRef<Self> = jvm
999                .invoke_virtual(
1000                    &this,
1001                    "java/lang/StringBuffer",
1002                    "insert",
1003                    "(ILjava/lang/String;)Ljava/lang/StringBuffer;",
1004                    (offset, sequence),
1005                )
1006                .await?;
1007        } else {
1008            let length: i32 = jvm
1009                .invoke_virtual(&sequence, &sequence.class_definition().name(), "length", "()I", ())
1010                .await?;
1011            let _: ClassInstanceRef<Self> = jvm
1012                .invoke_virtual(
1013                    &this,
1014                    "java/lang/StringBuffer",
1015                    "insert",
1016                    "(ILjava/lang/CharSequence;II)Ljava/lang/StringBuffer;",
1017                    (offset, sequence, 0, length),
1018                )
1019                .await?;
1020        }
1021        Ok(this)
1022    }
1023
1024    async fn insert_char_sequence_range(
1025        jvm: &Jvm,
1026        _: &mut RuntimeContext,
1027        this: ClassInstanceRef<Self>,
1028        offset: i32,
1029        sequence: ClassInstanceRef<CharSequence>,
1030        start: i32,
1031        end: i32,
1032    ) -> Result<ClassInstanceRef<Self>> {
1033        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
1034            .invoke_special(
1035                &this,
1036                "java/lang/AbstractStringBuilder",
1037                "insert",
1038                "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
1039                (offset, sequence, start, end),
1040            )
1041            .await?;
1042        Ok(this)
1043    }
1044
1045    async fn delete(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, start: i32, end: i32) -> Result<ClassInstanceRef<Self>> {
1046        tracing::debug!("java.lang.StringBuffer::delete({this:?}, {start}, {end})");
1047
1048        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1049        let end = end.min(count);
1050        if start < 0 || start > end {
1051            return Err(jvm
1052                .exception(
1053                    "java/lang/StringIndexOutOfBoundsException",
1054                    &alloc::format!("start {start}, end {end}, length {count}"),
1055                )
1056                .await);
1057        }
1058
1059        if start != end {
1060            let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1061            let tail: Vec<JavaChar> = jvm.load_array(&value, end as usize, (count - end) as usize).await?;
1062            jvm.store_array(&mut value, start as usize, tail).await?;
1063            jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - (end - start))
1064                .await?;
1065        }
1066        Ok(this)
1067    }
1068
1069    async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Self>> {
1070        tracing::debug!("java.lang.StringBuffer::deleteCharAt({this:?}, {index})");
1071
1072        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1073        if index < 0 || index >= count {
1074            return Err(jvm
1075                .exception(
1076                    "java/lang/StringIndexOutOfBoundsException",
1077                    &alloc::format!("index {index}, length {count}"),
1078                )
1079                .await);
1080        }
1081
1082        let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1083        let tail: Vec<JavaChar> = jvm.load_array(&value, (index + 1) as usize, (count - index - 1) as usize).await?;
1084        jvm.store_array(&mut value, index as usize, tail).await?;
1085        jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", count - 1).await?;
1086        Ok(this)
1087    }
1088
1089    async fn replace(
1090        jvm: &Jvm,
1091        _: &mut RuntimeContext,
1092        mut this: ClassInstanceRef<Self>,
1093        start: i32,
1094        end: i32,
1095        string: ClassInstanceRef<String>,
1096    ) -> Result<ClassInstanceRef<Self>> {
1097        tracing::debug!("java.lang.StringBuffer::replace({this:?}, {start}, {end}, {string:?})");
1098
1099        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1100        let end = end.min(count);
1101        if start < 0 || start > count || start > end {
1102            return Err(jvm
1103                .exception(
1104                    "java/lang/StringIndexOutOfBoundsException",
1105                    &alloc::format!("start {start}, end {end}, length {count}"),
1106                )
1107                .await);
1108        }
1109        if string.is_null() {
1110            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1111        }
1112
1113        let replacement = JavaLangString::to_utf16(jvm, &string).await?;
1114        let replacement_length = replacement.len() as i32;
1115        let new_count = count + replacement_length - (end - start);
1116        let mut value = Self::expand_capacity(jvm, &mut this, new_count).await?;
1117        let tail: Vec<JavaChar> = jvm.load_array(&value, end as usize, (count - end) as usize).await?;
1118        jvm.store_array(&mut value, (start + replacement_length) as usize, tail).await?;
1119        jvm.store_array(&mut value, start as usize, replacement).await?;
1120        jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_count).await?;
1121        Ok(this)
1122    }
1123
1124    async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, start: i32) -> Result<ClassInstanceRef<String>> {
1125        tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start})");
1126
1127        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1128        jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, count))
1129            .await
1130    }
1131
1132    async fn substring_range(
1133        jvm: &Jvm,
1134        _: &mut RuntimeContext,
1135        this: ClassInstanceRef<Self>,
1136        start: i32,
1137        end: i32,
1138    ) -> Result<ClassInstanceRef<String>> {
1139        tracing::debug!("java.lang.StringBuffer::substring({this:?}, {start}, {end})");
1140
1141        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1142        if start < 0 || end > count || start > end {
1143            return Err(jvm
1144                .exception(
1145                    "java/lang/StringIndexOutOfBoundsException",
1146                    &alloc::format!("start {start}, end {end}, length {count}"),
1147                )
1148                .await);
1149        }
1150
1151        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1152        Ok(jvm.new_class("java/lang/String", "([CII)V", (value, start, end - start)).await?.into())
1153    }
1154
1155    async fn sub_sequence(
1156        jvm: &Jvm,
1157        _: &mut RuntimeContext,
1158        this: ClassInstanceRef<Self>,
1159        start: i32,
1160        end: i32,
1161    ) -> Result<ClassInstanceRef<CharSequence>> {
1162        tracing::debug!("java.lang.StringBuffer::subSequence({this:?}, {start}, {end})");
1163
1164        jvm.invoke_virtual(&this, "java/lang/StringBuffer", "substring", "(II)Ljava/lang/String;", (start, end))
1165            .await
1166    }
1167
1168    async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1169        tracing::debug!("java.lang.StringBuffer::reverse({this:?})");
1170
1171        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1172        let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1173        let mut chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1174        chars.reverse();
1175        jvm.store_array(&mut value, 0, chars).await?;
1176        Ok(this)
1177    }
1178
1179    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1180        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "indexOf", "(Ljava/lang/String;)I", (string,))
1181            .await
1182    }
1183
1184    async fn index_of_from(
1185        jvm: &Jvm,
1186        _: &mut RuntimeContext,
1187        this: ClassInstanceRef<Self>,
1188        string: ClassInstanceRef<String>,
1189        from_index: i32,
1190    ) -> Result<i32> {
1191        jvm.invoke_special(
1192            &this,
1193            "java/lang/AbstractStringBuilder",
1194            "indexOf",
1195            "(Ljava/lang/String;I)I",
1196            (string, from_index),
1197        )
1198        .await
1199    }
1200
1201    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1202        jvm.invoke_special(
1203            &this,
1204            "java/lang/AbstractStringBuilder",
1205            "lastIndexOf",
1206            "(Ljava/lang/String;)I",
1207            (string,),
1208        )
1209        .await
1210    }
1211
1212    async fn last_index_of_from(
1213        jvm: &Jvm,
1214        _: &mut RuntimeContext,
1215        this: ClassInstanceRef<Self>,
1216        string: ClassInstanceRef<String>,
1217        from_index: i32,
1218    ) -> Result<i32> {
1219        jvm.invoke_special(
1220            &this,
1221            "java/lang/AbstractStringBuilder",
1222            "lastIndexOf",
1223            "(Ljava/lang/String;I)I",
1224            (string, from_index),
1225        )
1226        .await
1227    }
1228
1229    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
1230        tracing::debug!("java.lang.StringBuffer::toString({this:?})");
1231
1232        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1233        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1234
1235        // the buffer stays mutable, so snapshot it instead of handing it to the sharing constructor
1236        let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1237
1238        Ok(JavaLangString::from_utf16(jvm, chars).await?.into())
1239    }
1240
1241    async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1242        tracing::debug!("java.lang.StringBuffer::capacity({this:?})");
1243
1244        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1245        Ok(jvm.array_length(&value).await? as i32)
1246    }
1247
1248    async fn ensure_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
1249        tracing::debug!("java.lang.StringBuffer::ensureCapacity({this:?}, {minimum_capacity})");
1250
1251        if minimum_capacity > 0 {
1252            Self::expand_capacity(jvm, &mut this, minimum_capacity).await?;
1253        }
1254        Ok(())
1255    }
1256
1257    async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
1258        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "trimToSize", "()V", ())
1259            .await
1260    }
1261
1262    async fn set_length(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_length: i32) -> Result<()> {
1263        tracing::debug!("java.lang.StringBuffer::setLength({this:?}, {new_length})");
1264
1265        if new_length < 0 {
1266            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &new_length.to_string()).await);
1267        }
1268
1269        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1270        if new_length > count {
1271            let mut value = Self::expand_capacity(jvm, &mut this, new_length).await?;
1272            jvm.store_array(&mut value, count as usize, vec![0 as JavaChar; (new_length - count) as usize])
1273                .await?;
1274        }
1275        jvm.put_field(&mut this, "java/lang/StringBuffer", "count", "I", new_length).await?;
1276        Ok(())
1277    }
1278
1279    async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
1280        tracing::debug!("java.lang.StringBuffer::length({this:?})");
1281
1282        jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await
1283    }
1284
1285    async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<JavaChar> {
1286        tracing::debug!("java.lang.StringBuffer::charAt({this:?}, {index})");
1287
1288        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1289        if index < 0 || index >= count {
1290            return Err(jvm
1291                .exception(
1292                    "java/lang/StringIndexOutOfBoundsException",
1293                    &alloc::format!("index {index}, length {count}"),
1294                )
1295                .await);
1296        }
1297
1298        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1299        Ok(jvm.load_array(&value, index as usize, 1).await?[0])
1300    }
1301
1302    async fn code_point_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1303        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointAt", "(I)I", (index,))
1304            .await
1305    }
1306
1307    async fn code_point_before(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
1308        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointBefore", "(I)I", (index,))
1309            .await
1310    }
1311
1312    async fn code_point_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, begin: i32, end: i32) -> Result<i32> {
1313        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "codePointCount", "(II)I", (begin, end))
1314            .await
1315    }
1316
1317    async fn offset_by_code_points(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, offset: i32) -> Result<i32> {
1318        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "offsetByCodePoints", "(II)I", (index, offset))
1319            .await
1320    }
1321
1322    async fn set_char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32, character: JavaChar) -> Result<()> {
1323        tracing::debug!("java.lang.StringBuffer::setCharAt({this:?}, {index}, {character})");
1324
1325        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1326        if index < 0 || index >= count {
1327            return Err(jvm
1328                .exception(
1329                    "java/lang/StringIndexOutOfBoundsException",
1330                    &alloc::format!("index {index}, length {count}"),
1331                )
1332                .await);
1333        }
1334
1335        let mut value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1336        jvm.store_array(&mut value, index as usize, [character]).await
1337    }
1338
1339    async fn get_chars(
1340        jvm: &Jvm,
1341        _: &mut RuntimeContext,
1342        this: ClassInstanceRef<Self>,
1343        src_begin: i32,
1344        src_end: i32,
1345        mut destination: ClassInstanceRef<Array<JavaChar>>,
1346        dst_begin: i32,
1347    ) -> Result<()> {
1348        tracing::debug!("java.lang.StringBuffer::getChars({this:?}, {src_begin}, {src_end}, {destination:?}, {dst_begin})");
1349
1350        let count: i32 = jvm.get_field(&this, "java/lang/StringBuffer", "count", "I").await?;
1351        if src_begin < 0 || src_end > count || src_begin > src_end {
1352            return Err(jvm
1353                .exception(
1354                    "java/lang/StringIndexOutOfBoundsException",
1355                    &alloc::format!("start {src_begin}, end {src_end}, length {count}"),
1356                )
1357                .await);
1358        }
1359        if destination.is_null() {
1360            return Err(jvm.exception("java/lang/NullPointerException", "dst is null").await);
1361        }
1362
1363        let copy_length = src_end - src_begin;
1364        let destination_length = jvm.array_length(&destination).await? as i32;
1365        if dst_begin < 0 || dst_begin > destination_length - copy_length {
1366            return Err(jvm
1367                .exception(
1368                    "java/lang/ArrayIndexOutOfBoundsException",
1369                    &alloc::format!("offset {dst_begin}, length {copy_length}, array length {destination_length}"),
1370                )
1371                .await);
1372        }
1373
1374        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/StringBuffer", "value", "[C").await?;
1375        let chars: Vec<JavaChar> = jvm.load_array(&value, src_begin as usize, copy_length as usize).await?;
1376        jvm.store_array(&mut destination, dst_begin as usize, chars).await
1377    }
1378
1379    async fn expand_capacity(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<ClassInstanceRef<Array<JavaChar>>> {
1380        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/lang/StringBuffer", "value", "[C").await?;
1381        let old_capacity = jvm.array_length(&value).await? as i32;
1382        if minimum_capacity <= old_capacity {
1383            return Ok(value);
1384        }
1385
1386        let new_capacity = minimum_capacity.max(old_capacity.saturating_mul(2).saturating_add(2));
1387        let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1388        let chars: Vec<JavaChar> = jvm.load_array(&value, 0, count as usize).await?;
1389        let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?;
1390        jvm.store_array(&mut new_value, 0, chars).await?;
1391        jvm.put_field(this, "java/lang/StringBuffer", "value", "[C", new_value.clone()).await?;
1392        Ok(new_value.into())
1393    }
1394
1395    async fn append_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, chars: Vec<JavaChar>) -> Result<()> {
1396        let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1397        let new_count = count + chars.len() as i32;
1398        let mut value = Self::expand_capacity(jvm, this, new_count).await?;
1399        jvm.store_array(&mut value, count as usize, chars).await?;
1400        jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await
1401    }
1402
1403    async fn insert_utf16(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, offset: i32, chars: Vec<JavaChar>) -> Result<()> {
1404        let count: i32 = jvm.get_field(this, "java/lang/StringBuffer", "count", "I").await?;
1405        if offset < 0 || offset > count {
1406            return Err(jvm
1407                .exception(
1408                    "java/lang/StringIndexOutOfBoundsException",
1409                    &alloc::format!("offset {offset}, length {count}"),
1410                )
1411                .await);
1412        }
1413
1414        let inserted_length = chars.len() as i32;
1415        let new_count = count + inserted_length;
1416        let mut value = Self::expand_capacity(jvm, this, new_count).await?;
1417        let tail: Vec<JavaChar> = jvm.load_array(&value, offset as usize, (count - offset) as usize).await?;
1418        jvm.store_array(&mut value, (offset + inserted_length) as usize, tail).await?;
1419        jvm.store_array(&mut value, offset as usize, chars).await?;
1420        jvm.put_field(this, "java/lang/StringBuffer", "count", "I", new_count).await
1421    }
1422}