Skip to main content

rustjava_runtime/classes/java/lang/
string_builder.rs

1use alloc::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, StringBuffer},
10};
11
12// public final class java.lang.StringBuilder
13pub struct StringBuilder;
14
15impl StringBuilder {
16    pub fn as_proto() -> RuntimeClassProto {
17        RuntimeClassProto {
18            name: "java/lang/StringBuilder",
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/Object;)Ljava/lang/StringBuilder;",
34                    Self::append_object,
35                    MethodAccessFlags::PUBLIC,
36                ),
37                JavaMethodProto::new(
38                    "append",
39                    "(Ljava/lang/String;)Ljava/lang/StringBuilder;",
40                    Self::append_string,
41                    MethodAccessFlags::PUBLIC,
42                ),
43                JavaMethodProto::new(
44                    "append",
45                    "(Ljava/lang/StringBuffer;)Ljava/lang/StringBuilder;",
46                    Self::append_string_buffer,
47                    MethodAccessFlags::PUBLIC,
48                ),
49                JavaMethodProto::new(
50                    "append",
51                    "(Ljava/lang/CharSequence;)Ljava/lang/StringBuilder;",
52                    Self::append_char_sequence,
53                    MethodAccessFlags::PUBLIC,
54                ),
55                JavaMethodProto::new(
56                    "append",
57                    "(Ljava/lang/CharSequence;II)Ljava/lang/StringBuilder;",
58                    Self::append_char_sequence_range,
59                    MethodAccessFlags::PUBLIC,
60                ),
61                JavaMethodProto::new(
62                    "append",
63                    "([C)Ljava/lang/StringBuilder;",
64                    Self::append_char_array,
65                    MethodAccessFlags::PUBLIC,
66                ),
67                JavaMethodProto::new(
68                    "append",
69                    "([CII)Ljava/lang/StringBuilder;",
70                    Self::append_char_array_range,
71                    MethodAccessFlags::PUBLIC,
72                ),
73                JavaMethodProto::new("append", "(Z)Ljava/lang/StringBuilder;", Self::append_boolean, MethodAccessFlags::PUBLIC),
74                JavaMethodProto::new("append", "(C)Ljava/lang/StringBuilder;", Self::append_char, MethodAccessFlags::PUBLIC),
75                JavaMethodProto::new("append", "(I)Ljava/lang/StringBuilder;", Self::append_int, MethodAccessFlags::PUBLIC),
76                JavaMethodProto::new("append", "(J)Ljava/lang/StringBuilder;", Self::append_long, MethodAccessFlags::PUBLIC),
77                JavaMethodProto::new("append", "(F)Ljava/lang/StringBuilder;", Self::append_float, MethodAccessFlags::PUBLIC),
78                JavaMethodProto::new("append", "(D)Ljava/lang/StringBuilder;", Self::append_double, MethodAccessFlags::PUBLIC),
79                JavaMethodProto::new(
80                    "appendCodePoint",
81                    "(I)Ljava/lang/StringBuilder;",
82                    Self::append_code_point,
83                    MethodAccessFlags::PUBLIC,
84                ),
85                JavaMethodProto::new("delete", "(II)Ljava/lang/StringBuilder;", Self::delete, MethodAccessFlags::PUBLIC),
86                JavaMethodProto::new(
87                    "deleteCharAt",
88                    "(I)Ljava/lang/StringBuilder;",
89                    Self::delete_char_at,
90                    MethodAccessFlags::PUBLIC,
91                ),
92                JavaMethodProto::new(
93                    "replace",
94                    "(IILjava/lang/String;)Ljava/lang/StringBuilder;",
95                    Self::replace,
96                    MethodAccessFlags::PUBLIC,
97                ),
98                JavaMethodProto::new(
99                    "insert",
100                    "(I[CII)Ljava/lang/StringBuilder;",
101                    Self::insert_char_array_range,
102                    MethodAccessFlags::PUBLIC,
103                ),
104                JavaMethodProto::new(
105                    "insert",
106                    "(ILjava/lang/Object;)Ljava/lang/StringBuilder;",
107                    Self::insert_object,
108                    MethodAccessFlags::PUBLIC,
109                ),
110                JavaMethodProto::new(
111                    "insert",
112                    "(ILjava/lang/String;)Ljava/lang/StringBuilder;",
113                    Self::insert_string,
114                    MethodAccessFlags::PUBLIC,
115                ),
116                JavaMethodProto::new(
117                    "insert",
118                    "(I[C)Ljava/lang/StringBuilder;",
119                    Self::insert_char_array,
120                    MethodAccessFlags::PUBLIC,
121                ),
122                JavaMethodProto::new(
123                    "insert",
124                    "(ILjava/lang/CharSequence;)Ljava/lang/StringBuilder;",
125                    Self::insert_char_sequence,
126                    MethodAccessFlags::PUBLIC,
127                ),
128                JavaMethodProto::new(
129                    "insert",
130                    "(ILjava/lang/CharSequence;II)Ljava/lang/StringBuilder;",
131                    Self::insert_char_sequence_range,
132                    MethodAccessFlags::PUBLIC,
133                ),
134                JavaMethodProto::new("insert", "(IZ)Ljava/lang/StringBuilder;", Self::insert_boolean, MethodAccessFlags::PUBLIC),
135                JavaMethodProto::new("insert", "(IC)Ljava/lang/StringBuilder;", Self::insert_char, MethodAccessFlags::PUBLIC),
136                JavaMethodProto::new("insert", "(II)Ljava/lang/StringBuilder;", Self::insert_int, MethodAccessFlags::PUBLIC),
137                JavaMethodProto::new("insert", "(IJ)Ljava/lang/StringBuilder;", Self::insert_long, MethodAccessFlags::PUBLIC),
138                JavaMethodProto::new("insert", "(IF)Ljava/lang/StringBuilder;", Self::insert_float, MethodAccessFlags::PUBLIC),
139                JavaMethodProto::new("insert", "(ID)Ljava/lang/StringBuilder;", Self::insert_double, MethodAccessFlags::PUBLIC),
140                JavaMethodProto::new("indexOf", "(Ljava/lang/String;)I", Self::index_of, MethodAccessFlags::PUBLIC),
141                JavaMethodProto::new("indexOf", "(Ljava/lang/String;I)I", Self::index_of_from, MethodAccessFlags::PUBLIC),
142                JavaMethodProto::new("lastIndexOf", "(Ljava/lang/String;)I", Self::last_index_of, MethodAccessFlags::PUBLIC),
143                JavaMethodProto::new(
144                    "lastIndexOf",
145                    "(Ljava/lang/String;I)I",
146                    Self::last_index_of_from,
147                    MethodAccessFlags::PUBLIC,
148                ),
149                JavaMethodProto::new("reverse", "()Ljava/lang/StringBuilder;", Self::reverse, MethodAccessFlags::PUBLIC),
150                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
151                JavaMethodProto::new(
152                    "append",
153                    "(Ljava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
154                    Self::append_object,
155                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
156                ),
157                JavaMethodProto::new(
158                    "append",
159                    "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
160                    Self::append_string,
161                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
162                ),
163                JavaMethodProto::new(
164                    "append",
165                    "(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;",
166                    Self::append_string_buffer,
167                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
168                ),
169                JavaMethodProto::new(
170                    "append",
171                    "(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
172                    Self::append_char_sequence,
173                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
174                ),
175                JavaMethodProto::new(
176                    "append",
177                    "(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
178                    Self::append_char_sequence_range,
179                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
180                ),
181                JavaMethodProto::new(
182                    "append",
183                    "([C)Ljava/lang/AbstractStringBuilder;",
184                    Self::append_char_array,
185                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
186                ),
187                JavaMethodProto::new(
188                    "append",
189                    "([CII)Ljava/lang/AbstractStringBuilder;",
190                    Self::append_char_array_range,
191                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
192                ),
193                JavaMethodProto::new(
194                    "append",
195                    "(Z)Ljava/lang/AbstractStringBuilder;",
196                    Self::append_boolean,
197                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
198                ),
199                JavaMethodProto::new(
200                    "append",
201                    "(C)Ljava/lang/AbstractStringBuilder;",
202                    Self::append_char,
203                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
204                ),
205                JavaMethodProto::new(
206                    "append",
207                    "(I)Ljava/lang/AbstractStringBuilder;",
208                    Self::append_int,
209                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
210                ),
211                JavaMethodProto::new(
212                    "append",
213                    "(J)Ljava/lang/AbstractStringBuilder;",
214                    Self::append_long,
215                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
216                ),
217                JavaMethodProto::new(
218                    "append",
219                    "(F)Ljava/lang/AbstractStringBuilder;",
220                    Self::append_float,
221                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
222                ),
223                JavaMethodProto::new(
224                    "append",
225                    "(D)Ljava/lang/AbstractStringBuilder;",
226                    Self::append_double,
227                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
228                ),
229                JavaMethodProto::new(
230                    "appendCodePoint",
231                    "(I)Ljava/lang/AbstractStringBuilder;",
232                    Self::append_code_point,
233                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
234                ),
235                JavaMethodProto::new(
236                    "delete",
237                    "(II)Ljava/lang/AbstractStringBuilder;",
238                    Self::delete,
239                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
240                ),
241                JavaMethodProto::new(
242                    "deleteCharAt",
243                    "(I)Ljava/lang/AbstractStringBuilder;",
244                    Self::delete_char_at,
245                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
246                ),
247                JavaMethodProto::new(
248                    "replace",
249                    "(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
250                    Self::replace,
251                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
252                ),
253                JavaMethodProto::new(
254                    "insert",
255                    "(I[CII)Ljava/lang/AbstractStringBuilder;",
256                    Self::insert_char_array_range,
257                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
258                ),
259                JavaMethodProto::new(
260                    "insert",
261                    "(ILjava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
262                    Self::insert_object,
263                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
264                ),
265                JavaMethodProto::new(
266                    "insert",
267                    "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
268                    Self::insert_string,
269                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
270                ),
271                JavaMethodProto::new(
272                    "insert",
273                    "(I[C)Ljava/lang/AbstractStringBuilder;",
274                    Self::insert_char_array,
275                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
276                ),
277                JavaMethodProto::new(
278                    "insert",
279                    "(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
280                    Self::insert_char_sequence,
281                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
282                ),
283                JavaMethodProto::new(
284                    "insert",
285                    "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
286                    Self::insert_char_sequence_range,
287                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
288                ),
289                JavaMethodProto::new(
290                    "insert",
291                    "(IZ)Ljava/lang/AbstractStringBuilder;",
292                    Self::insert_boolean,
293                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
294                ),
295                JavaMethodProto::new(
296                    "insert",
297                    "(IC)Ljava/lang/AbstractStringBuilder;",
298                    Self::insert_char,
299                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
300                ),
301                JavaMethodProto::new(
302                    "insert",
303                    "(II)Ljava/lang/AbstractStringBuilder;",
304                    Self::insert_int,
305                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
306                ),
307                JavaMethodProto::new(
308                    "insert",
309                    "(IJ)Ljava/lang/AbstractStringBuilder;",
310                    Self::insert_long,
311                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
312                ),
313                JavaMethodProto::new(
314                    "insert",
315                    "(IF)Ljava/lang/AbstractStringBuilder;",
316                    Self::insert_float,
317                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
318                ),
319                JavaMethodProto::new(
320                    "insert",
321                    "(ID)Ljava/lang/AbstractStringBuilder;",
322                    Self::insert_double,
323                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
324                ),
325                JavaMethodProto::new(
326                    "reverse",
327                    "()Ljava/lang/AbstractStringBuilder;",
328                    Self::reverse,
329                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
330                ),
331                JavaMethodProto::new(
332                    "append",
333                    "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
334                    Self::append_char_sequence,
335                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
336                ),
337                JavaMethodProto::new(
338                    "append",
339                    "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
340                    Self::append_char_sequence_range,
341                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
342                ),
343                JavaMethodProto::new(
344                    "append",
345                    "(C)Ljava/lang/Appendable;",
346                    Self::append_char,
347                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
348                ),
349            ],
350            fields: vec![],
351            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
352        }
353    }
354
355    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
356        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", (16,))
357            .await
358    }
359
360    async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
361        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", (capacity,))
362            .await
363    }
364
365    async fn init_with_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
366        if string.is_null() {
367            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
368        }
369        let characters = JavaLangString::to_utf16(jvm, &string).await?;
370        let _: () = jvm
371            .invoke_special(
372                &this,
373                "java/lang/AbstractStringBuilder",
374                "<init>",
375                "(I)V",
376                ((characters.len() + 16) as i32,),
377            )
378            .await?;
379        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
380            .invoke_special(
381                &this,
382                "java/lang/AbstractStringBuilder",
383                "append",
384                "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
385                (string,),
386            )
387            .await?;
388        Ok(())
389    }
390
391    async fn init_with_char_sequence(
392        jvm: &Jvm,
393        _: &mut RuntimeContext,
394        this: ClassInstanceRef<Self>,
395        sequence: ClassInstanceRef<CharSequence>,
396    ) -> Result<()> {
397        if sequence.is_null() {
398            return Err(jvm.exception("java/lang/NullPointerException", "seq is null").await);
399        }
400        let length: i32 = jvm
401            .invoke_virtual(&sequence, &sequence.class_definition().name(), "length", "()I", ())
402            .await?;
403        let _: () = jvm
404            .invoke_special(&this, "java/lang/AbstractStringBuilder", "<init>", "(I)V", (length + 16,))
405            .await?;
406        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
407            .invoke_special(
408                &this,
409                "java/lang/AbstractStringBuilder",
410                "append",
411                "(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
412                (sequence,),
413            )
414            .await?;
415        Ok(())
416    }
417
418    async fn append_object(
419        jvm: &Jvm,
420        _: &mut RuntimeContext,
421        this: ClassInstanceRef<Self>,
422        object: ClassInstanceRef<Object>,
423    ) -> Result<ClassInstanceRef<Self>> {
424        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
425            .invoke_special(
426                &this,
427                "java/lang/AbstractStringBuilder",
428                "append",
429                "(Ljava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
430                (object,),
431            )
432            .await?;
433        Ok(this)
434    }
435
436    async fn append_string(
437        jvm: &Jvm,
438        _: &mut RuntimeContext,
439        this: ClassInstanceRef<Self>,
440        string: ClassInstanceRef<String>,
441    ) -> Result<ClassInstanceRef<Self>> {
442        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
443            .invoke_special(
444                &this,
445                "java/lang/AbstractStringBuilder",
446                "append",
447                "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
448                (string,),
449            )
450            .await?;
451        Ok(this)
452    }
453
454    async fn append_string_buffer(
455        jvm: &Jvm,
456        _: &mut RuntimeContext,
457        this: ClassInstanceRef<Self>,
458        buffer: ClassInstanceRef<StringBuffer>,
459    ) -> Result<ClassInstanceRef<Self>> {
460        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
461            .invoke_special(
462                &this,
463                "java/lang/AbstractStringBuilder",
464                "append",
465                "(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;",
466                (buffer,),
467            )
468            .await?;
469        Ok(this)
470    }
471
472    async fn append_char_sequence(
473        jvm: &Jvm,
474        _: &mut RuntimeContext,
475        this: ClassInstanceRef<Self>,
476        sequence: ClassInstanceRef<CharSequence>,
477    ) -> Result<ClassInstanceRef<Self>> {
478        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
479            .invoke_special(
480                &this,
481                "java/lang/AbstractStringBuilder",
482                "append",
483                "(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
484                (sequence,),
485            )
486            .await?;
487        Ok(this)
488    }
489
490    async fn append_char_sequence_range(
491        jvm: &Jvm,
492        _: &mut RuntimeContext,
493        this: ClassInstanceRef<Self>,
494        sequence: ClassInstanceRef<CharSequence>,
495        start: i32,
496        end: i32,
497    ) -> Result<ClassInstanceRef<Self>> {
498        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
499            .invoke_special(
500                &this,
501                "java/lang/AbstractStringBuilder",
502                "append",
503                "(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
504                (sequence, start, end),
505            )
506            .await?;
507        Ok(this)
508    }
509
510    async fn append_char_array(
511        jvm: &Jvm,
512        _: &mut RuntimeContext,
513        this: ClassInstanceRef<Self>,
514        array: ClassInstanceRef<Array<JavaChar>>,
515    ) -> Result<ClassInstanceRef<Self>> {
516        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
517            .invoke_special(
518                &this,
519                "java/lang/AbstractStringBuilder",
520                "append",
521                "([C)Ljava/lang/AbstractStringBuilder;",
522                (array,),
523            )
524            .await?;
525        Ok(this)
526    }
527
528    async fn append_char_array_range(
529        jvm: &Jvm,
530        _: &mut RuntimeContext,
531        this: ClassInstanceRef<Self>,
532        array: ClassInstanceRef<Array<JavaChar>>,
533        offset: i32,
534        length: i32,
535    ) -> Result<ClassInstanceRef<Self>> {
536        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
537            .invoke_special(
538                &this,
539                "java/lang/AbstractStringBuilder",
540                "append",
541                "([CII)Ljava/lang/AbstractStringBuilder;",
542                (array, offset, length),
543            )
544            .await?;
545        Ok(this)
546    }
547
548    async fn append_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<ClassInstanceRef<Self>> {
549        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
550            .invoke_special(
551                &this,
552                "java/lang/AbstractStringBuilder",
553                "append",
554                "(Z)Ljava/lang/AbstractStringBuilder;",
555                (value,),
556            )
557            .await?;
558        Ok(this)
559    }
560
561    async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: JavaChar) -> Result<ClassInstanceRef<Self>> {
562        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
563            .invoke_special(
564                &this,
565                "java/lang/AbstractStringBuilder",
566                "append",
567                "(C)Ljava/lang/AbstractStringBuilder;",
568                (value,),
569            )
570            .await?;
571        Ok(this)
572    }
573
574    async fn append_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<ClassInstanceRef<Self>> {
575        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
576            .invoke_special(
577                &this,
578                "java/lang/AbstractStringBuilder",
579                "append",
580                "(I)Ljava/lang/AbstractStringBuilder;",
581                (value,),
582            )
583            .await?;
584        Ok(this)
585    }
586
587    async fn append_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<Self>> {
588        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
589            .invoke_special(
590                &this,
591                "java/lang/AbstractStringBuilder",
592                "append",
593                "(J)Ljava/lang/AbstractStringBuilder;",
594                (value,),
595            )
596            .await?;
597        Ok(this)
598    }
599
600    async fn append_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<ClassInstanceRef<Self>> {
601        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
602            .invoke_special(
603                &this,
604                "java/lang/AbstractStringBuilder",
605                "append",
606                "(F)Ljava/lang/AbstractStringBuilder;",
607                (value,),
608            )
609            .await?;
610        Ok(this)
611    }
612
613    async fn append_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<Self>> {
614        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
615            .invoke_special(
616                &this,
617                "java/lang/AbstractStringBuilder",
618                "append",
619                "(D)Ljava/lang/AbstractStringBuilder;",
620                (value,),
621            )
622            .await?;
623        Ok(this)
624    }
625
626    async fn append_code_point(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, code_point: i32) -> Result<ClassInstanceRef<Self>> {
627        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
628            .invoke_special(
629                &this,
630                "java/lang/AbstractStringBuilder",
631                "appendCodePoint",
632                "(I)Ljava/lang/AbstractStringBuilder;",
633                (code_point,),
634            )
635            .await?;
636        Ok(this)
637    }
638
639    async fn delete(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, start: i32, end: i32) -> Result<ClassInstanceRef<Self>> {
640        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
641            .invoke_special(
642                &this,
643                "java/lang/AbstractStringBuilder",
644                "delete",
645                "(II)Ljava/lang/AbstractStringBuilder;",
646                (start, end),
647            )
648            .await?;
649        Ok(this)
650    }
651
652    async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Self>> {
653        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
654            .invoke_special(
655                &this,
656                "java/lang/AbstractStringBuilder",
657                "deleteCharAt",
658                "(I)Ljava/lang/AbstractStringBuilder;",
659                (index,),
660            )
661            .await?;
662        Ok(this)
663    }
664
665    async fn replace(
666        jvm: &Jvm,
667        _: &mut RuntimeContext,
668        this: ClassInstanceRef<Self>,
669        start: i32,
670        end: i32,
671        string: ClassInstanceRef<String>,
672    ) -> Result<ClassInstanceRef<Self>> {
673        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
674            .invoke_special(
675                &this,
676                "java/lang/AbstractStringBuilder",
677                "replace",
678                "(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
679                (start, end, string),
680            )
681            .await?;
682        Ok(this)
683    }
684
685    async fn insert_char_array_range(
686        jvm: &Jvm,
687        _: &mut RuntimeContext,
688        this: ClassInstanceRef<Self>,
689        index: i32,
690        array: ClassInstanceRef<Array<JavaChar>>,
691        offset: i32,
692        length: i32,
693    ) -> Result<ClassInstanceRef<Self>> {
694        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
695            .invoke_special(
696                &this,
697                "java/lang/AbstractStringBuilder",
698                "insert",
699                "(I[CII)Ljava/lang/AbstractStringBuilder;",
700                (index, array, offset, length),
701            )
702            .await?;
703        Ok(this)
704    }
705
706    async fn insert_object(
707        jvm: &Jvm,
708        _: &mut RuntimeContext,
709        this: ClassInstanceRef<Self>,
710        offset: i32,
711        object: ClassInstanceRef<Object>,
712    ) -> Result<ClassInstanceRef<Self>> {
713        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
714            .invoke_special(
715                &this,
716                "java/lang/AbstractStringBuilder",
717                "insert",
718                "(ILjava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
719                (offset, object),
720            )
721            .await?;
722        Ok(this)
723    }
724
725    async fn insert_string(
726        jvm: &Jvm,
727        _: &mut RuntimeContext,
728        this: ClassInstanceRef<Self>,
729        offset: i32,
730        string: ClassInstanceRef<String>,
731    ) -> Result<ClassInstanceRef<Self>> {
732        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
733            .invoke_special(
734                &this,
735                "java/lang/AbstractStringBuilder",
736                "insert",
737                "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
738                (offset, string),
739            )
740            .await?;
741        Ok(this)
742    }
743
744    async fn insert_char_array(
745        jvm: &Jvm,
746        _: &mut RuntimeContext,
747        this: ClassInstanceRef<Self>,
748        offset: i32,
749        array: ClassInstanceRef<Array<JavaChar>>,
750    ) -> Result<ClassInstanceRef<Self>> {
751        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
752            .invoke_special(
753                &this,
754                "java/lang/AbstractStringBuilder",
755                "insert",
756                "(I[C)Ljava/lang/AbstractStringBuilder;",
757                (offset, array),
758            )
759            .await?;
760        Ok(this)
761    }
762
763    async fn insert_char_sequence(
764        jvm: &Jvm,
765        _: &mut RuntimeContext,
766        this: ClassInstanceRef<Self>,
767        offset: i32,
768        sequence: ClassInstanceRef<CharSequence>,
769    ) -> Result<ClassInstanceRef<Self>> {
770        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
771            .invoke_special(
772                &this,
773                "java/lang/AbstractStringBuilder",
774                "insert",
775                "(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
776                (offset, sequence),
777            )
778            .await?;
779        Ok(this)
780    }
781
782    async fn insert_char_sequence_range(
783        jvm: &Jvm,
784        _: &mut RuntimeContext,
785        this: ClassInstanceRef<Self>,
786        offset: i32,
787        sequence: ClassInstanceRef<CharSequence>,
788        start: i32,
789        end: i32,
790    ) -> Result<ClassInstanceRef<Self>> {
791        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
792            .invoke_special(
793                &this,
794                "java/lang/AbstractStringBuilder",
795                "insert",
796                "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
797                (offset, sequence, start, end),
798            )
799            .await?;
800        Ok(this)
801    }
802
803    async fn insert_boolean(
804        jvm: &Jvm,
805        _: &mut RuntimeContext,
806        this: ClassInstanceRef<Self>,
807        offset: i32,
808        value: bool,
809    ) -> Result<ClassInstanceRef<Self>> {
810        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
811            .invoke_special(
812                &this,
813                "java/lang/AbstractStringBuilder",
814                "insert",
815                "(IZ)Ljava/lang/AbstractStringBuilder;",
816                (offset, value),
817            )
818            .await?;
819        Ok(this)
820    }
821
822    async fn insert_char(
823        jvm: &Jvm,
824        _: &mut RuntimeContext,
825        this: ClassInstanceRef<Self>,
826        offset: i32,
827        value: JavaChar,
828    ) -> Result<ClassInstanceRef<Self>> {
829        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
830            .invoke_special(
831                &this,
832                "java/lang/AbstractStringBuilder",
833                "insert",
834                "(IC)Ljava/lang/AbstractStringBuilder;",
835                (offset, value),
836            )
837            .await?;
838        Ok(this)
839    }
840
841    async fn insert_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i32) -> Result<ClassInstanceRef<Self>> {
842        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
843            .invoke_special(
844                &this,
845                "java/lang/AbstractStringBuilder",
846                "insert",
847                "(II)Ljava/lang/AbstractStringBuilder;",
848                (offset, value),
849            )
850            .await?;
851        Ok(this)
852    }
853
854    async fn insert_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i64) -> Result<ClassInstanceRef<Self>> {
855        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
856            .invoke_special(
857                &this,
858                "java/lang/AbstractStringBuilder",
859                "insert",
860                "(IJ)Ljava/lang/AbstractStringBuilder;",
861                (offset, value),
862            )
863            .await?;
864        Ok(this)
865    }
866
867    async fn insert_float(
868        jvm: &Jvm,
869        _: &mut RuntimeContext,
870        this: ClassInstanceRef<Self>,
871        offset: i32,
872        value: f32,
873    ) -> Result<ClassInstanceRef<Self>> {
874        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
875            .invoke_special(
876                &this,
877                "java/lang/AbstractStringBuilder",
878                "insert",
879                "(IF)Ljava/lang/AbstractStringBuilder;",
880                (offset, value),
881            )
882            .await?;
883        Ok(this)
884    }
885
886    async fn insert_double(
887        jvm: &Jvm,
888        _: &mut RuntimeContext,
889        this: ClassInstanceRef<Self>,
890        offset: i32,
891        value: f64,
892    ) -> Result<ClassInstanceRef<Self>> {
893        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
894            .invoke_special(
895                &this,
896                "java/lang/AbstractStringBuilder",
897                "insert",
898                "(ID)Ljava/lang/AbstractStringBuilder;",
899                (offset, value),
900            )
901            .await?;
902        Ok(this)
903    }
904
905    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
906        jvm.invoke_special(&this, "java/lang/AbstractStringBuilder", "indexOf", "(Ljava/lang/String;)I", (string,))
907            .await
908    }
909
910    async fn index_of_from(
911        jvm: &Jvm,
912        _: &mut RuntimeContext,
913        this: ClassInstanceRef<Self>,
914        string: ClassInstanceRef<String>,
915        from_index: i32,
916    ) -> Result<i32> {
917        jvm.invoke_special(
918            &this,
919            "java/lang/AbstractStringBuilder",
920            "indexOf",
921            "(Ljava/lang/String;I)I",
922            (string, from_index),
923        )
924        .await
925    }
926
927    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
928        jvm.invoke_special(
929            &this,
930            "java/lang/AbstractStringBuilder",
931            "lastIndexOf",
932            "(Ljava/lang/String;)I",
933            (string,),
934        )
935        .await
936    }
937
938    async fn last_index_of_from(
939        jvm: &Jvm,
940        _: &mut RuntimeContext,
941        this: ClassInstanceRef<Self>,
942        string: ClassInstanceRef<String>,
943        from_index: i32,
944    ) -> Result<i32> {
945        jvm.invoke_special(
946            &this,
947            "java/lang/AbstractStringBuilder",
948            "lastIndexOf",
949            "(Ljava/lang/String;I)I",
950            (string, from_index),
951        )
952        .await
953    }
954
955    async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
956        let _: ClassInstanceRef<AbstractStringBuilder> = jvm
957            .invoke_special(
958                &this,
959                "java/lang/AbstractStringBuilder",
960                "reverse",
961                "()Ljava/lang/AbstractStringBuilder;",
962                (),
963            )
964            .await?;
965        Ok(this)
966    }
967
968    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
969        let count: i32 = jvm.get_field(&this, "count", "I").await?;
970        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
971        Ok(JavaLangString::from_utf16(jvm, jvm.load_array(&value, 0, count as usize).await?)
972            .await?
973            .into())
974    }
975}