Skip to main content

rustjava_runtime/classes/java/lang/
abstract_string_builder.rs

1use alloc::{format, string::ToString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::lang::{CharSequence, Object, String, StringBuffer},
10};
11
12// abstract class java.lang.AbstractStringBuilder
13pub struct AbstractStringBuilder;
14
15impl AbstractStringBuilder {
16    pub fn as_proto() -> RuntimeClassProto {
17        RuntimeClassProto {
18            name: "java/lang/AbstractStringBuilder",
19            parent_class: Some("java/lang/Object"),
20            interfaces: vec!["java/lang/Appendable", "java/lang/CharSequence"],
21            methods: vec![
22                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::empty()),
23                JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, MethodAccessFlags::empty()),
24                JavaMethodProto::new("length", "()I", Self::length, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("capacity", "()I", Self::capacity, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("ensureCapacity", "(I)V", Self::ensure_capacity, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("trimToSize", "()V", Self::trim_to_size, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("setLength", "(I)V", Self::set_length, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("charAt", "(I)C", Self::char_at, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new("codePointAt", "(I)I", Self::code_point_at, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new("codePointBefore", "(I)I", Self::code_point_before, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new("codePointCount", "(II)I", Self::code_point_count, MethodAccessFlags::PUBLIC),
33                JavaMethodProto::new("offsetByCodePoints", "(II)I", Self::offset_by_code_points, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new("getChars", "(II[CI)V", Self::get_chars, MethodAccessFlags::PUBLIC),
35                JavaMethodProto::new("setCharAt", "(IC)V", Self::set_char_at, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new(
37                    "append",
38                    "(Ljava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
39                    Self::append_object,
40                    MethodAccessFlags::PUBLIC,
41                ),
42                JavaMethodProto::new(
43                    "append",
44                    "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
45                    Self::append_string,
46                    MethodAccessFlags::PUBLIC,
47                ),
48                JavaMethodProto::new(
49                    "append",
50                    "(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;",
51                    Self::append_string_buffer,
52                    MethodAccessFlags::PUBLIC,
53                ),
54                JavaMethodProto::new(
55                    "append",
56                    "(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
57                    Self::append_char_sequence,
58                    MethodAccessFlags::PUBLIC,
59                ),
60                JavaMethodProto::new(
61                    "append",
62                    "(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
63                    Self::append_char_sequence_range,
64                    MethodAccessFlags::PUBLIC,
65                ),
66                JavaMethodProto::new(
67                    "append",
68                    "([C)Ljava/lang/AbstractStringBuilder;",
69                    Self::append_char_array,
70                    MethodAccessFlags::PUBLIC,
71                ),
72                JavaMethodProto::new(
73                    "append",
74                    "([CII)Ljava/lang/AbstractStringBuilder;",
75                    Self::append_char_array_range,
76                    MethodAccessFlags::PUBLIC,
77                ),
78                JavaMethodProto::new(
79                    "append",
80                    "(Z)Ljava/lang/AbstractStringBuilder;",
81                    Self::append_boolean,
82                    MethodAccessFlags::PUBLIC,
83                ),
84                JavaMethodProto::new(
85                    "append",
86                    "(C)Ljava/lang/AbstractStringBuilder;",
87                    Self::append_char,
88                    MethodAccessFlags::PUBLIC,
89                ),
90                JavaMethodProto::new(
91                    "append",
92                    "(I)Ljava/lang/AbstractStringBuilder;",
93                    Self::append_int,
94                    MethodAccessFlags::PUBLIC,
95                ),
96                JavaMethodProto::new(
97                    "append",
98                    "(J)Ljava/lang/AbstractStringBuilder;",
99                    Self::append_long,
100                    MethodAccessFlags::PUBLIC,
101                ),
102                JavaMethodProto::new(
103                    "append",
104                    "(F)Ljava/lang/AbstractStringBuilder;",
105                    Self::append_float,
106                    MethodAccessFlags::PUBLIC,
107                ),
108                JavaMethodProto::new(
109                    "append",
110                    "(D)Ljava/lang/AbstractStringBuilder;",
111                    Self::append_double,
112                    MethodAccessFlags::PUBLIC,
113                ),
114                JavaMethodProto::new(
115                    "appendCodePoint",
116                    "(I)Ljava/lang/AbstractStringBuilder;",
117                    Self::append_code_point,
118                    MethodAccessFlags::PUBLIC,
119                ),
120                JavaMethodProto::new("delete", "(II)Ljava/lang/AbstractStringBuilder;", Self::delete, MethodAccessFlags::PUBLIC),
121                JavaMethodProto::new(
122                    "deleteCharAt",
123                    "(I)Ljava/lang/AbstractStringBuilder;",
124                    Self::delete_char_at,
125                    MethodAccessFlags::PUBLIC,
126                ),
127                JavaMethodProto::new(
128                    "replace",
129                    "(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
130                    Self::replace,
131                    MethodAccessFlags::PUBLIC,
132                ),
133                JavaMethodProto::new("substring", "(I)Ljava/lang/String;", Self::substring, MethodAccessFlags::PUBLIC),
134                JavaMethodProto::new("substring", "(II)Ljava/lang/String;", Self::substring_range, MethodAccessFlags::PUBLIC),
135                JavaMethodProto::new(
136                    "subSequence",
137                    "(II)Ljava/lang/CharSequence;",
138                    Self::sub_sequence,
139                    MethodAccessFlags::PUBLIC,
140                ),
141                JavaMethodProto::new(
142                    "insert",
143                    "(I[CII)Ljava/lang/AbstractStringBuilder;",
144                    Self::insert_char_array_range,
145                    MethodAccessFlags::PUBLIC,
146                ),
147                JavaMethodProto::new(
148                    "insert",
149                    "(ILjava/lang/Object;)Ljava/lang/AbstractStringBuilder;",
150                    Self::insert_object,
151                    MethodAccessFlags::PUBLIC,
152                ),
153                JavaMethodProto::new(
154                    "insert",
155                    "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
156                    Self::insert_string,
157                    MethodAccessFlags::PUBLIC,
158                ),
159                JavaMethodProto::new(
160                    "insert",
161                    "(I[C)Ljava/lang/AbstractStringBuilder;",
162                    Self::insert_char_array,
163                    MethodAccessFlags::PUBLIC,
164                ),
165                JavaMethodProto::new(
166                    "insert",
167                    "(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;",
168                    Self::insert_char_sequence,
169                    MethodAccessFlags::PUBLIC,
170                ),
171                JavaMethodProto::new(
172                    "insert",
173                    "(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;",
174                    Self::insert_char_sequence_range,
175                    MethodAccessFlags::PUBLIC,
176                ),
177                JavaMethodProto::new(
178                    "insert",
179                    "(IZ)Ljava/lang/AbstractStringBuilder;",
180                    Self::insert_boolean,
181                    MethodAccessFlags::PUBLIC,
182                ),
183                JavaMethodProto::new(
184                    "insert",
185                    "(IC)Ljava/lang/AbstractStringBuilder;",
186                    Self::insert_char,
187                    MethodAccessFlags::PUBLIC,
188                ),
189                JavaMethodProto::new(
190                    "insert",
191                    "(II)Ljava/lang/AbstractStringBuilder;",
192                    Self::insert_int,
193                    MethodAccessFlags::PUBLIC,
194                ),
195                JavaMethodProto::new(
196                    "insert",
197                    "(IJ)Ljava/lang/AbstractStringBuilder;",
198                    Self::insert_long,
199                    MethodAccessFlags::PUBLIC,
200                ),
201                JavaMethodProto::new(
202                    "insert",
203                    "(IF)Ljava/lang/AbstractStringBuilder;",
204                    Self::insert_float,
205                    MethodAccessFlags::PUBLIC,
206                ),
207                JavaMethodProto::new(
208                    "insert",
209                    "(ID)Ljava/lang/AbstractStringBuilder;",
210                    Self::insert_double,
211                    MethodAccessFlags::PUBLIC,
212                ),
213                JavaMethodProto::new("indexOf", "(Ljava/lang/String;)I", Self::index_of, MethodAccessFlags::PUBLIC),
214                JavaMethodProto::new("indexOf", "(Ljava/lang/String;I)I", Self::index_of_from, MethodAccessFlags::PUBLIC),
215                JavaMethodProto::new("lastIndexOf", "(Ljava/lang/String;)I", Self::last_index_of, MethodAccessFlags::PUBLIC),
216                JavaMethodProto::new(
217                    "lastIndexOf",
218                    "(Ljava/lang/String;I)I",
219                    Self::last_index_of_from,
220                    MethodAccessFlags::PUBLIC,
221                ),
222                JavaMethodProto::new("reverse", "()Ljava/lang/AbstractStringBuilder;", Self::reverse, MethodAccessFlags::PUBLIC),
223                JavaMethodProto::new(
224                    "append",
225                    "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
226                    Self::append_char_sequence,
227                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
228                ),
229                JavaMethodProto::new(
230                    "append",
231                    "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
232                    Self::append_char_sequence_range,
233                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
234                ),
235                JavaMethodProto::new(
236                    "append",
237                    "(C)Ljava/lang/Appendable;",
238                    Self::append_char,
239                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
240                ),
241            ],
242            fields: vec![
243                JavaFieldProto::new("value", "[C", FieldAccessFlags::empty()),
244                JavaFieldProto::new("count", "I", FieldAccessFlags::empty()),
245            ],
246            access_flags: ClassAccessFlags::ABSTRACT,
247        }
248    }
249
250    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
251        jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await
252    }
253
254    async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, capacity: i32) -> Result<()> {
255        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
256        if capacity < 0 {
257            return Err(jvm.exception("java/lang/NegativeArraySizeException", &capacity.to_string()).await);
258        }
259        let value = jvm.instantiate_array("C", capacity as usize).await?;
260        jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "value", "[C", value).await?;
261        jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "count", "I", 0).await
262    }
263
264    async fn characters(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<Vec<JavaChar>> {
265        let count: i32 = jvm.get_field(this, "java/lang/AbstractStringBuilder", "count", "I").await?;
266        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/lang/AbstractStringBuilder", "value", "[C").await?;
267        jvm.load_array(&value, 0, count as usize).await
268    }
269
270    async fn replace_characters(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, characters: Vec<JavaChar>) -> Result<()> {
271        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/lang/AbstractStringBuilder", "value", "[C").await?;
272        let old_capacity = jvm.array_length(&value).await?;
273        if characters.len() > old_capacity {
274            let new_capacity = characters.len().max(old_capacity.saturating_mul(2).saturating_add(2));
275            let mut new_value = jvm.instantiate_array("C", new_capacity).await?;
276            jvm.store_array(&mut new_value, 0, characters.clone()).await?;
277            jvm.put_field(this, "java/lang/AbstractStringBuilder", "value", "[C", new_value).await?;
278        } else if !characters.is_empty() {
279            let mut value = value;
280            jvm.store_array(&mut value, 0, characters.clone()).await?;
281        }
282        jvm.put_field(this, "java/lang/AbstractStringBuilder", "count", "I", characters.len() as i32)
283            .await
284    }
285
286    async fn insert_characters(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, offset: i32, inserted: Vec<JavaChar>) -> Result<()> {
287        let mut characters = Self::characters(jvm, this).await?;
288        if offset < 0 || offset as usize > characters.len() {
289            return Err(jvm
290                .exception(
291                    "java/lang/StringIndexOutOfBoundsException",
292                    &format!("offset {offset}, length {}", characters.len()),
293                )
294                .await);
295        }
296        characters.splice(offset as usize..offset as usize, inserted);
297        Self::replace_characters(jvm, this, characters).await
298    }
299
300    async fn char_sequence_characters(jvm: &Jvm, sequence: &ClassInstanceRef<CharSequence>) -> Result<Vec<JavaChar>> {
301        if sequence.is_null() {
302            return Ok("null".encode_utf16().collect());
303        }
304        if jvm.is_instance(&***sequence, "java/lang/String") {
305            return JavaLangString::to_utf16(jvm, sequence).await;
306        }
307        let length: i32 = jvm
308            .invoke_virtual(sequence, &sequence.class_definition().name(), "length", "()I", ())
309            .await?;
310        let mut characters = Vec::with_capacity(length as usize);
311        for index in 0..length {
312            characters.push(
313                jvm.invoke_virtual(sequence, &sequence.class_definition().name(), "charAt", "(I)C", (index,))
314                    .await?,
315            );
316        }
317        Ok(characters)
318    }
319
320    async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
321        jvm.get_field(&this, "java/lang/AbstractStringBuilder", "count", "I").await
322    }
323
324    async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
325        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "value", "[C").await?;
326        Ok(jvm.array_length(&value).await? as i32)
327    }
328
329    async fn ensure_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
330        if minimum_capacity <= 0 {
331            return Ok(());
332        }
333        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "value", "[C").await?;
334        let old_capacity = jvm.array_length(&value).await? as i32;
335        if minimum_capacity <= old_capacity {
336            return Ok(());
337        }
338        let new_capacity = minimum_capacity.max(old_capacity.saturating_mul(2).saturating_add(2));
339        let characters = Self::characters(jvm, &this).await?;
340        let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?;
341        jvm.store_array(&mut new_value, 0, characters).await?;
342        jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "value", "[C", new_value)
343            .await
344    }
345
346    async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
347        let characters = Self::characters(jvm, &this).await?;
348        let mut value = jvm.instantiate_array("C", characters.len()).await?;
349        jvm.store_array(&mut value, 0, characters).await?;
350        jvm.put_field(&mut this, "java/lang/AbstractStringBuilder", "value", "[C", value).await
351    }
352
353    async fn set_length(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_length: i32) -> Result<()> {
354        if new_length < 0 {
355            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &new_length.to_string()).await);
356        }
357        let mut characters = Self::characters(jvm, &this).await?;
358        characters.resize(new_length as usize, 0);
359        Self::replace_characters(jvm, &mut this, characters).await
360    }
361
362    async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<JavaChar> {
363        let characters = Self::characters(jvm, &this).await?;
364        if index < 0 || index as usize >= characters.len() {
365            return Err(jvm
366                .exception(
367                    "java/lang/StringIndexOutOfBoundsException",
368                    &format!("index {index}, length {}", characters.len()),
369                )
370                .await);
371        }
372        Ok(characters[index as usize])
373    }
374
375    async fn code_point_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
376        let characters = Self::characters(jvm, &this).await?;
377        if index < 0 || index as usize >= characters.len() {
378            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
379        }
380        let first = characters[index as usize];
381        if (0xd800..=0xdbff).contains(&first) && (index as usize + 1) < characters.len() {
382            let second = characters[index as usize + 1];
383            if (0xdc00..=0xdfff).contains(&second) {
384                return Ok((((first as i32 - 0xd800) << 10) | (second as i32 - 0xdc00)) + 0x10000);
385            }
386        }
387        Ok(first as i32)
388    }
389
390    async fn code_point_before(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
391        let characters = Self::characters(jvm, &this).await?;
392        if index <= 0 || index as usize > characters.len() {
393            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
394        }
395        let second = characters[index as usize - 1];
396        if (0xdc00..=0xdfff).contains(&second) && index > 1 {
397            let first = characters[index as usize - 2];
398            if (0xd800..=0xdbff).contains(&first) {
399                return Ok((((first as i32 - 0xd800) << 10) | (second as i32 - 0xdc00)) + 0x10000);
400            }
401        }
402        Ok(second as i32)
403    }
404
405    async fn code_point_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, begin: i32, end: i32) -> Result<i32> {
406        let characters = Self::characters(jvm, &this).await?;
407        if begin < 0 || end > characters.len() as i32 || begin > end {
408            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid code point range").await);
409        }
410        let mut index = begin as usize;
411        let mut count = 0;
412        while index < end as usize {
413            if (0xd800..=0xdbff).contains(&characters[index]) && index + 1 < end as usize && (0xdc00..=0xdfff).contains(&characters[index + 1]) {
414                index += 2;
415            } else {
416                index += 1;
417            }
418            count += 1;
419        }
420        Ok(count)
421    }
422
423    async fn offset_by_code_points(
424        jvm: &Jvm,
425        _: &mut RuntimeContext,
426        this: ClassInstanceRef<Self>,
427        index: i32,
428        code_point_offset: i32,
429    ) -> Result<i32> {
430        let characters = Self::characters(jvm, &this).await?;
431        if index < 0 || index as usize > characters.len() {
432            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid index").await);
433        }
434        let mut cursor = index as usize;
435        if code_point_offset >= 0 {
436            for _ in 0..code_point_offset {
437                if cursor >= characters.len() {
438                    return Err(jvm
439                        .exception("java/lang/IndexOutOfBoundsException", "code point offset exceeds length")
440                        .await);
441                }
442                if (0xd800..=0xdbff).contains(&characters[cursor])
443                    && cursor + 1 < characters.len()
444                    && (0xdc00..=0xdfff).contains(&characters[cursor + 1])
445                {
446                    cursor += 2;
447                } else {
448                    cursor += 1;
449                }
450            }
451        } else {
452            for _ in code_point_offset..0 {
453                if cursor == 0 {
454                    return Err(jvm
455                        .exception("java/lang/IndexOutOfBoundsException", "code point offset precedes start")
456                        .await);
457                }
458                cursor -= 1;
459                if (0xdc00..=0xdfff).contains(&characters[cursor]) && cursor > 0 && (0xd800..=0xdbff).contains(&characters[cursor - 1]) {
460                    cursor -= 1;
461                }
462            }
463        }
464        Ok(cursor as i32)
465    }
466
467    async fn get_chars(
468        jvm: &Jvm,
469        _: &mut RuntimeContext,
470        this: ClassInstanceRef<Self>,
471        source_begin: i32,
472        source_end: i32,
473        mut destination: ClassInstanceRef<Array<JavaChar>>,
474        destination_begin: i32,
475    ) -> Result<()> {
476        let characters = Self::characters(jvm, &this).await?;
477        if source_begin < 0 || source_end > characters.len() as i32 || source_begin > source_end {
478            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", "invalid source range").await);
479        }
480        if destination.is_null() {
481            return Err(jvm.exception("java/lang/NullPointerException", "destination is null").await);
482        }
483        let copy_length = source_end - source_begin;
484        let destination_length = jvm.array_length(&destination).await? as i32;
485        if destination_begin < 0 || destination_begin > destination_length - copy_length {
486            return Err(jvm
487                .exception("java/lang/ArrayIndexOutOfBoundsException", "invalid destination range")
488                .await);
489        }
490        jvm.store_array(
491            &mut destination,
492            destination_begin as usize,
493            characters[source_begin as usize..source_end as usize].to_vec(),
494        )
495        .await
496    }
497
498    async fn set_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32, character: JavaChar) -> Result<()> {
499        let mut characters = Self::characters(jvm, &this).await?;
500        if index < 0 || index as usize >= characters.len() {
501            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
502        }
503        characters[index as usize] = character;
504        Self::replace_characters(jvm, &mut this, characters).await
505    }
506
507    async fn append_object(
508        jvm: &Jvm,
509        _: &mut RuntimeContext,
510        this: ClassInstanceRef<Self>,
511        object: ClassInstanceRef<Object>,
512    ) -> Result<ClassInstanceRef<Self>> {
513        let string: ClassInstanceRef<String> = if object.is_null() {
514            JavaLangString::from_rust_string(jvm, "null").await?.into()
515        } else {
516            jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
517                .await?
518        };
519        jvm.invoke_virtual(
520            &this,
521            "java/lang/AbstractStringBuilder",
522            "append",
523            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
524            (string,),
525        )
526        .await
527    }
528
529    async fn append_string(
530        jvm: &Jvm,
531        _: &mut RuntimeContext,
532        mut this: ClassInstanceRef<Self>,
533        string: ClassInstanceRef<String>,
534    ) -> Result<ClassInstanceRef<Self>> {
535        let mut characters = Self::characters(jvm, &this).await?;
536        if string.is_null() {
537            characters.extend("null".encode_utf16());
538        } else {
539            characters.extend(JavaLangString::to_utf16(jvm, &string).await?);
540        }
541        Self::replace_characters(jvm, &mut this, characters).await?;
542        Ok(this)
543    }
544
545    async fn append_string_buffer(
546        jvm: &Jvm,
547        _: &mut RuntimeContext,
548        this: ClassInstanceRef<Self>,
549        buffer: ClassInstanceRef<StringBuffer>,
550    ) -> Result<ClassInstanceRef<Self>> {
551        let string: ClassInstanceRef<String> = if buffer.is_null() {
552            JavaLangString::from_rust_string(jvm, "null").await?.into()
553        } else {
554            jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
555                .await?
556        };
557        jvm.invoke_virtual(
558            &this,
559            "java/lang/AbstractStringBuilder",
560            "append",
561            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
562            (string,),
563        )
564        .await
565    }
566
567    async fn append_char_sequence(
568        jvm: &Jvm,
569        _: &mut RuntimeContext,
570        mut this: ClassInstanceRef<Self>,
571        sequence: ClassInstanceRef<CharSequence>,
572    ) -> Result<ClassInstanceRef<Self>> {
573        let mut characters = Self::characters(jvm, &this).await?;
574        characters.extend(Self::char_sequence_characters(jvm, &sequence).await?);
575        Self::replace_characters(jvm, &mut this, characters).await?;
576        Ok(this)
577    }
578
579    async fn append_char_sequence_range(
580        jvm: &Jvm,
581        _: &mut RuntimeContext,
582        mut this: ClassInstanceRef<Self>,
583        sequence: ClassInstanceRef<CharSequence>,
584        start: i32,
585        end: i32,
586    ) -> Result<ClassInstanceRef<Self>> {
587        let source = Self::char_sequence_characters(jvm, &sequence).await?;
588        if start < 0 || end > source.len() as i32 || start > end {
589            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid CharSequence range").await);
590        }
591        let mut characters = Self::characters(jvm, &this).await?;
592        characters.extend_from_slice(&source[start as usize..end as usize]);
593        Self::replace_characters(jvm, &mut this, characters).await?;
594        Ok(this)
595    }
596
597    async fn append_char_array(
598        jvm: &Jvm,
599        _: &mut RuntimeContext,
600        this: ClassInstanceRef<Self>,
601        array: ClassInstanceRef<Array<JavaChar>>,
602    ) -> Result<ClassInstanceRef<Self>> {
603        if array.is_null() {
604            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
605        }
606        let length = jvm.array_length(&array).await? as i32;
607        jvm.invoke_virtual(
608            &this,
609            "java/lang/AbstractStringBuilder",
610            "append",
611            "([CII)Ljava/lang/AbstractStringBuilder;",
612            (array, 0, length),
613        )
614        .await
615    }
616
617    async fn append_char_array_range(
618        jvm: &Jvm,
619        _: &mut RuntimeContext,
620        mut this: ClassInstanceRef<Self>,
621        array: ClassInstanceRef<Array<JavaChar>>,
622        offset: i32,
623        length: i32,
624    ) -> Result<ClassInstanceRef<Self>> {
625        if array.is_null() {
626            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
627        }
628        let array_length = jvm.array_length(&array).await? as i32;
629        if offset < 0 || length < 0 || offset > array_length - length {
630            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid char array range").await);
631        }
632        let mut characters = Self::characters(jvm, &this).await?;
633        characters.extend(jvm.load_array::<JavaChar>(&array, offset as usize, length as usize).await?);
634        Self::replace_characters(jvm, &mut this, characters).await?;
635        Ok(this)
636    }
637
638    async fn append_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<ClassInstanceRef<Self>> {
639        let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
640        jvm.invoke_virtual(
641            &this,
642            "java/lang/AbstractStringBuilder",
643            "append",
644            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
645            (string,),
646        )
647        .await
648    }
649
650    async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: JavaChar) -> Result<ClassInstanceRef<Self>> {
651        let mut characters = Self::characters(jvm, &this).await?;
652        characters.push(value);
653        Self::replace_characters(jvm, &mut this, characters).await?;
654        Ok(this)
655    }
656
657    async fn append_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<ClassInstanceRef<Self>> {
658        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
659        jvm.invoke_virtual(
660            &this,
661            "java/lang/AbstractStringBuilder",
662            "append",
663            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
664            (string,),
665        )
666        .await
667    }
668
669    async fn append_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<Self>> {
670        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
671        jvm.invoke_virtual(
672            &this,
673            "java/lang/AbstractStringBuilder",
674            "append",
675            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
676            (string,),
677        )
678        .await
679    }
680
681    async fn append_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<ClassInstanceRef<Self>> {
682        let string: ClassInstanceRef<String> = jvm
683            .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
684            .await?;
685        jvm.invoke_virtual(
686            &this,
687            "java/lang/AbstractStringBuilder",
688            "append",
689            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
690            (string,),
691        )
692        .await
693    }
694
695    async fn append_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<Self>> {
696        let string: ClassInstanceRef<String> = jvm
697            .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
698            .await?;
699        jvm.invoke_virtual(
700            &this,
701            "java/lang/AbstractStringBuilder",
702            "append",
703            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
704            (string,),
705        )
706        .await
707    }
708
709    async fn append_code_point(
710        jvm: &Jvm,
711        _: &mut RuntimeContext,
712        mut this: ClassInstanceRef<Self>,
713        code_point: i32,
714    ) -> Result<ClassInstanceRef<Self>> {
715        if !(0..=0x10ffff).contains(&code_point) {
716            return Err(jvm.exception("java/lang/IllegalArgumentException", "invalid code point").await);
717        }
718        let mut characters = Self::characters(jvm, &this).await?;
719        if code_point < 0x10000 {
720            characters.push(code_point as JavaChar);
721        } else {
722            let value = code_point - 0x10000;
723            characters.push((0xd800 + (value >> 10)) as JavaChar);
724            characters.push((0xdc00 + (value & 0x3ff)) as JavaChar);
725        }
726        Self::replace_characters(jvm, &mut this, characters).await?;
727        Ok(this)
728    }
729
730    async fn delete(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, start: i32, end: i32) -> Result<ClassInstanceRef<Self>> {
731        let mut characters = Self::characters(jvm, &this).await?;
732        let end = end.min(characters.len() as i32);
733        if start < 0 || start > end {
734            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", "invalid delete range").await);
735        }
736        characters.drain(start as usize..end as usize);
737        Self::replace_characters(jvm, &mut this, characters).await?;
738        Ok(this)
739    }
740
741    async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Self>> {
742        let mut characters = Self::characters(jvm, &this).await?;
743        if index < 0 || index as usize >= characters.len() {
744            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
745        }
746        characters.remove(index as usize);
747        Self::replace_characters(jvm, &mut this, characters).await?;
748        Ok(this)
749    }
750
751    async fn replace(
752        jvm: &Jvm,
753        _: &mut RuntimeContext,
754        mut this: ClassInstanceRef<Self>,
755        start: i32,
756        end: i32,
757        string: ClassInstanceRef<String>,
758    ) -> Result<ClassInstanceRef<Self>> {
759        let mut characters = Self::characters(jvm, &this).await?;
760        let end = end.min(characters.len() as i32);
761        if start < 0 || start > characters.len() as i32 || start > end {
762            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", "invalid replace range").await);
763        }
764        if string.is_null() {
765            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
766        }
767        characters.splice(start as usize..end as usize, JavaLangString::to_utf16(jvm, &string).await?);
768        Self::replace_characters(jvm, &mut this, characters).await?;
769        Ok(this)
770    }
771
772    async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, start: i32) -> Result<ClassInstanceRef<String>> {
773        let count: i32 = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "count", "I").await?;
774        jvm.invoke_virtual(
775            &this,
776            "java/lang/AbstractStringBuilder",
777            "substring",
778            "(II)Ljava/lang/String;",
779            (start, count),
780        )
781        .await
782    }
783
784    async fn substring_range(
785        jvm: &Jvm,
786        _: &mut RuntimeContext,
787        this: ClassInstanceRef<Self>,
788        start: i32,
789        end: i32,
790    ) -> Result<ClassInstanceRef<String>> {
791        let characters = Self::characters(jvm, &this).await?;
792        if start < 0 || end > characters.len() as i32 || start > end {
793            return Err(jvm
794                .exception("java/lang/StringIndexOutOfBoundsException", "invalid substring range")
795                .await);
796        }
797        Ok(JavaLangString::from_utf16(jvm, characters[start as usize..end as usize].to_vec())
798            .await?
799            .into())
800    }
801
802    async fn sub_sequence(
803        jvm: &Jvm,
804        _: &mut RuntimeContext,
805        this: ClassInstanceRef<Self>,
806        start: i32,
807        end: i32,
808    ) -> Result<ClassInstanceRef<CharSequence>> {
809        jvm.invoke_virtual(
810            &this,
811            "java/lang/AbstractStringBuilder",
812            "substring",
813            "(II)Ljava/lang/String;",
814            (start, end),
815        )
816        .await
817    }
818
819    async fn insert_char_array_range(
820        jvm: &Jvm,
821        _: &mut RuntimeContext,
822        mut this: ClassInstanceRef<Self>,
823        offset: i32,
824        array: ClassInstanceRef<Array<JavaChar>>,
825        source_offset: i32,
826        length: i32,
827    ) -> Result<ClassInstanceRef<Self>> {
828        if array.is_null() {
829            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
830        }
831        let array_length = jvm.array_length(&array).await? as i32;
832        if source_offset < 0 || length < 0 || source_offset > array_length - length {
833            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid char array range").await);
834        }
835        let inserted = jvm.load_array(&array, source_offset as usize, length as usize).await?;
836        Self::insert_characters(jvm, &mut this, offset, inserted).await?;
837        Ok(this)
838    }
839
840    async fn insert_object(
841        jvm: &Jvm,
842        _: &mut RuntimeContext,
843        this: ClassInstanceRef<Self>,
844        offset: i32,
845        object: ClassInstanceRef<Object>,
846    ) -> Result<ClassInstanceRef<Self>> {
847        let string: ClassInstanceRef<String> = if object.is_null() {
848            JavaLangString::from_rust_string(jvm, "null").await?.into()
849        } else {
850            jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
851                .await?
852        };
853        jvm.invoke_virtual(
854            &this,
855            "java/lang/AbstractStringBuilder",
856            "insert",
857            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
858            (offset, string),
859        )
860        .await
861    }
862
863    async fn insert_string(
864        jvm: &Jvm,
865        _: &mut RuntimeContext,
866        mut this: ClassInstanceRef<Self>,
867        offset: i32,
868        string: ClassInstanceRef<String>,
869    ) -> Result<ClassInstanceRef<Self>> {
870        let inserted = if string.is_null() {
871            "null".encode_utf16().collect()
872        } else {
873            JavaLangString::to_utf16(jvm, &string).await?
874        };
875        Self::insert_characters(jvm, &mut this, offset, inserted).await?;
876        Ok(this)
877    }
878
879    async fn insert_char_array(
880        jvm: &Jvm,
881        _: &mut RuntimeContext,
882        this: ClassInstanceRef<Self>,
883        offset: i32,
884        array: ClassInstanceRef<Array<JavaChar>>,
885    ) -> Result<ClassInstanceRef<Self>> {
886        if array.is_null() {
887            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
888        }
889        let length = jvm.array_length(&array).await? as i32;
890        jvm.invoke_virtual(
891            &this,
892            "java/lang/AbstractStringBuilder",
893            "insert",
894            "(I[CII)Ljava/lang/AbstractStringBuilder;",
895            (offset, array, 0, length),
896        )
897        .await
898    }
899
900    async fn insert_char_sequence(
901        jvm: &Jvm,
902        _: &mut RuntimeContext,
903        mut this: ClassInstanceRef<Self>,
904        offset: i32,
905        sequence: ClassInstanceRef<CharSequence>,
906    ) -> Result<ClassInstanceRef<Self>> {
907        let inserted = Self::char_sequence_characters(jvm, &sequence).await?;
908        Self::insert_characters(jvm, &mut this, offset, inserted).await?;
909        Ok(this)
910    }
911
912    async fn insert_char_sequence_range(
913        jvm: &Jvm,
914        _: &mut RuntimeContext,
915        mut this: ClassInstanceRef<Self>,
916        offset: i32,
917        sequence: ClassInstanceRef<CharSequence>,
918        start: i32,
919        end: i32,
920    ) -> Result<ClassInstanceRef<Self>> {
921        let source = Self::char_sequence_characters(jvm, &sequence).await?;
922        if start < 0 || end > source.len() as i32 || start > end {
923            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid CharSequence range").await);
924        }
925        Self::insert_characters(jvm, &mut this, offset, source[start as usize..end as usize].to_vec()).await?;
926        Ok(this)
927    }
928
929    async fn insert_boolean(
930        jvm: &Jvm,
931        _: &mut RuntimeContext,
932        this: ClassInstanceRef<Self>,
933        offset: i32,
934        value: bool,
935    ) -> Result<ClassInstanceRef<Self>> {
936        let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
937        jvm.invoke_virtual(
938            &this,
939            "java/lang/AbstractStringBuilder",
940            "insert",
941            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
942            (offset, string),
943        )
944        .await
945    }
946
947    async fn insert_char(
948        jvm: &Jvm,
949        _: &mut RuntimeContext,
950        mut this: ClassInstanceRef<Self>,
951        offset: i32,
952        value: JavaChar,
953    ) -> Result<ClassInstanceRef<Self>> {
954        Self::insert_characters(jvm, &mut this, offset, vec![value]).await?;
955        Ok(this)
956    }
957
958    async fn insert_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i32) -> Result<ClassInstanceRef<Self>> {
959        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
960        jvm.invoke_virtual(
961            &this,
962            "java/lang/AbstractStringBuilder",
963            "insert",
964            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
965            (offset, string),
966        )
967        .await
968    }
969
970    async fn insert_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i64) -> Result<ClassInstanceRef<Self>> {
971        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
972        jvm.invoke_virtual(
973            &this,
974            "java/lang/AbstractStringBuilder",
975            "insert",
976            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
977            (offset, string),
978        )
979        .await
980    }
981
982    async fn insert_float(
983        jvm: &Jvm,
984        _: &mut RuntimeContext,
985        this: ClassInstanceRef<Self>,
986        offset: i32,
987        value: f32,
988    ) -> Result<ClassInstanceRef<Self>> {
989        let string: ClassInstanceRef<String> = jvm
990            .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
991            .await?;
992        jvm.invoke_virtual(
993            &this,
994            "java/lang/AbstractStringBuilder",
995            "insert",
996            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
997            (offset, string),
998        )
999        .await
1000    }
1001
1002    async fn insert_double(
1003        jvm: &Jvm,
1004        _: &mut RuntimeContext,
1005        this: ClassInstanceRef<Self>,
1006        offset: i32,
1007        value: f64,
1008    ) -> Result<ClassInstanceRef<Self>> {
1009        let string: ClassInstanceRef<String> = jvm
1010            .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
1011            .await?;
1012        jvm.invoke_virtual(
1013            &this,
1014            "java/lang/AbstractStringBuilder",
1015            "insert",
1016            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
1017            (offset, string),
1018        )
1019        .await
1020    }
1021
1022    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1023        jvm.invoke_virtual(&this, "java/lang/AbstractStringBuilder", "indexOf", "(Ljava/lang/String;I)I", (string, 0))
1024            .await
1025    }
1026
1027    async fn index_of_from(
1028        jvm: &Jvm,
1029        _: &mut RuntimeContext,
1030        this: ClassInstanceRef<Self>,
1031        string: ClassInstanceRef<String>,
1032        from_index: i32,
1033    ) -> Result<i32> {
1034        if string.is_null() {
1035            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1036        }
1037        let characters = Self::characters(jvm, &this).await?;
1038        let needle = JavaLangString::to_utf16(jvm, &string).await?;
1039        let start = from_index.max(0) as usize;
1040        if needle.is_empty() {
1041            return Ok(start.min(characters.len()) as i32);
1042        }
1043        if start > characters.len().saturating_sub(needle.len()) {
1044            return Ok(-1);
1045        }
1046        Ok(characters[start..]
1047            .windows(needle.len())
1048            .position(|candidate| candidate == needle)
1049            .map_or(-1, |index| (start + index) as i32))
1050    }
1051
1052    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1053        let count: i32 = jvm.get_field(&this, "java/lang/AbstractStringBuilder", "count", "I").await?;
1054        jvm.invoke_virtual(
1055            &this,
1056            "java/lang/AbstractStringBuilder",
1057            "lastIndexOf",
1058            "(Ljava/lang/String;I)I",
1059            (string, count),
1060        )
1061        .await
1062    }
1063
1064    async fn last_index_of_from(
1065        jvm: &Jvm,
1066        _: &mut RuntimeContext,
1067        this: ClassInstanceRef<Self>,
1068        string: ClassInstanceRef<String>,
1069        from_index: i32,
1070    ) -> Result<i32> {
1071        if string.is_null() {
1072            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1073        }
1074        let characters = Self::characters(jvm, &this).await?;
1075        let needle = JavaLangString::to_utf16(jvm, &string).await?;
1076        if needle.is_empty() {
1077            return Ok(from_index.min(characters.len() as i32).max(-1));
1078        }
1079        if from_index < 0 || needle.len() > characters.len() {
1080            return Ok(-1);
1081        }
1082        let last_start = (characters.len() - needle.len()).min(from_index as usize);
1083        for index in (0..=last_start).rev() {
1084            if characters[index..index + needle.len()] == needle {
1085                return Ok(index as i32);
1086            }
1087        }
1088        Ok(-1)
1089    }
1090
1091    async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1092        let mut characters = Self::characters(jvm, &this).await?;
1093        characters.reverse();
1094        let mut index = 0;
1095        while index + 1 < characters.len() {
1096            if (0xdc00..=0xdfff).contains(&characters[index]) && (0xd800..=0xdbff).contains(&characters[index + 1]) {
1097                characters.swap(index, index + 1);
1098                index += 2;
1099            } else {
1100                index += 1;
1101            }
1102        }
1103        Self::replace_characters(jvm, &mut this, characters).await?;
1104        Ok(this)
1105    }
1106}