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, "value", "[C", value).await?;
261        jvm.put_field(&mut this, "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, "count", "I").await?;
266        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "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, "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, "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, "count", "I", characters.len() as i32).await
283    }
284
285    async fn insert_characters(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, offset: i32, inserted: Vec<JavaChar>) -> Result<()> {
286        let mut characters = Self::characters(jvm, this).await?;
287        if offset < 0 || offset as usize > characters.len() {
288            return Err(jvm
289                .exception(
290                    "java/lang/StringIndexOutOfBoundsException",
291                    &format!("offset {offset}, length {}", characters.len()),
292                )
293                .await);
294        }
295        characters.splice(offset as usize..offset as usize, inserted);
296        Self::replace_characters(jvm, this, characters).await
297    }
298
299    async fn char_sequence_characters(jvm: &Jvm, sequence: &ClassInstanceRef<CharSequence>) -> Result<Vec<JavaChar>> {
300        if sequence.is_null() {
301            return Ok("null".encode_utf16().collect());
302        }
303        if jvm.is_instance(&***sequence, "java/lang/String") {
304            return JavaLangString::to_utf16(jvm, sequence).await;
305        }
306        let length: i32 = jvm
307            .invoke_virtual(sequence, &sequence.class_definition().name(), "length", "()I", ())
308            .await?;
309        let mut characters = Vec::with_capacity(length as usize);
310        for index in 0..length {
311            characters.push(
312                jvm.invoke_virtual(sequence, &sequence.class_definition().name(), "charAt", "(I)C", (index,))
313                    .await?,
314            );
315        }
316        Ok(characters)
317    }
318
319    async fn length(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
320        jvm.get_field(&this, "count", "I").await
321    }
322
323    async fn capacity(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
324        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
325        Ok(jvm.array_length(&value).await? as i32)
326    }
327
328    async fn ensure_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, minimum_capacity: i32) -> Result<()> {
329        if minimum_capacity <= 0 {
330            return Ok(());
331        }
332        let value: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "value", "[C").await?;
333        let old_capacity = jvm.array_length(&value).await? as i32;
334        if minimum_capacity <= old_capacity {
335            return Ok(());
336        }
337        let new_capacity = minimum_capacity.max(old_capacity.saturating_mul(2).saturating_add(2));
338        let characters = Self::characters(jvm, &this).await?;
339        let mut new_value = jvm.instantiate_array("C", new_capacity as usize).await?;
340        jvm.store_array(&mut new_value, 0, characters).await?;
341        jvm.put_field(&mut this, "value", "[C", new_value).await
342    }
343
344    async fn trim_to_size(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
345        let characters = Self::characters(jvm, &this).await?;
346        let mut value = jvm.instantiate_array("C", characters.len()).await?;
347        jvm.store_array(&mut value, 0, characters).await?;
348        jvm.put_field(&mut this, "value", "[C", value).await
349    }
350
351    async fn set_length(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, new_length: i32) -> Result<()> {
352        if new_length < 0 {
353            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &new_length.to_string()).await);
354        }
355        let mut characters = Self::characters(jvm, &this).await?;
356        characters.resize(new_length as usize, 0);
357        Self::replace_characters(jvm, &mut this, characters).await
358    }
359
360    async fn char_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<JavaChar> {
361        let characters = Self::characters(jvm, &this).await?;
362        if index < 0 || index as usize >= characters.len() {
363            return Err(jvm
364                .exception(
365                    "java/lang/StringIndexOutOfBoundsException",
366                    &format!("index {index}, length {}", characters.len()),
367                )
368                .await);
369        }
370        Ok(characters[index as usize])
371    }
372
373    async fn code_point_at(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
374        let characters = Self::characters(jvm, &this).await?;
375        if index < 0 || index as usize >= characters.len() {
376            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
377        }
378        let first = characters[index as usize];
379        if (0xd800..=0xdbff).contains(&first) && (index as usize + 1) < characters.len() {
380            let second = characters[index as usize + 1];
381            if (0xdc00..=0xdfff).contains(&second) {
382                return Ok((((first as i32 - 0xd800) << 10) | (second as i32 - 0xdc00)) + 0x10000);
383            }
384        }
385        Ok(first as i32)
386    }
387
388    async fn code_point_before(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, index: i32) -> Result<i32> {
389        let characters = Self::characters(jvm, &this).await?;
390        if index <= 0 || index as usize > characters.len() {
391            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
392        }
393        let second = characters[index as usize - 1];
394        if (0xdc00..=0xdfff).contains(&second) && index > 1 {
395            let first = characters[index as usize - 2];
396            if (0xd800..=0xdbff).contains(&first) {
397                return Ok((((first as i32 - 0xd800) << 10) | (second as i32 - 0xdc00)) + 0x10000);
398            }
399        }
400        Ok(second as i32)
401    }
402
403    async fn code_point_count(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, begin: i32, end: i32) -> Result<i32> {
404        let characters = Self::characters(jvm, &this).await?;
405        if begin < 0 || end > characters.len() as i32 || begin > end {
406            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid code point range").await);
407        }
408        let mut index = begin as usize;
409        let mut count = 0;
410        while index < end as usize {
411            if (0xd800..=0xdbff).contains(&characters[index]) && index + 1 < end as usize && (0xdc00..=0xdfff).contains(&characters[index + 1]) {
412                index += 2;
413            } else {
414                index += 1;
415            }
416            count += 1;
417        }
418        Ok(count)
419    }
420
421    async fn offset_by_code_points(
422        jvm: &Jvm,
423        _: &mut RuntimeContext,
424        this: ClassInstanceRef<Self>,
425        index: i32,
426        code_point_offset: i32,
427    ) -> Result<i32> {
428        let characters = Self::characters(jvm, &this).await?;
429        if index < 0 || index as usize > characters.len() {
430            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid index").await);
431        }
432        let mut cursor = index as usize;
433        if code_point_offset >= 0 {
434            for _ in 0..code_point_offset {
435                if cursor >= characters.len() {
436                    return Err(jvm
437                        .exception("java/lang/IndexOutOfBoundsException", "code point offset exceeds length")
438                        .await);
439                }
440                if (0xd800..=0xdbff).contains(&characters[cursor])
441                    && cursor + 1 < characters.len()
442                    && (0xdc00..=0xdfff).contains(&characters[cursor + 1])
443                {
444                    cursor += 2;
445                } else {
446                    cursor += 1;
447                }
448            }
449        } else {
450            for _ in code_point_offset..0 {
451                if cursor == 0 {
452                    return Err(jvm
453                        .exception("java/lang/IndexOutOfBoundsException", "code point offset precedes start")
454                        .await);
455                }
456                cursor -= 1;
457                if (0xdc00..=0xdfff).contains(&characters[cursor]) && cursor > 0 && (0xd800..=0xdbff).contains(&characters[cursor - 1]) {
458                    cursor -= 1;
459                }
460            }
461        }
462        Ok(cursor as i32)
463    }
464
465    async fn get_chars(
466        jvm: &Jvm,
467        _: &mut RuntimeContext,
468        this: ClassInstanceRef<Self>,
469        source_begin: i32,
470        source_end: i32,
471        mut destination: ClassInstanceRef<Array<JavaChar>>,
472        destination_begin: i32,
473    ) -> Result<()> {
474        let characters = Self::characters(jvm, &this).await?;
475        if source_begin < 0 || source_end > characters.len() as i32 || source_begin > source_end {
476            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", "invalid source range").await);
477        }
478        if destination.is_null() {
479            return Err(jvm.exception("java/lang/NullPointerException", "destination is null").await);
480        }
481        let copy_length = source_end - source_begin;
482        let destination_length = jvm.array_length(&destination).await? as i32;
483        if destination_begin < 0 || destination_begin > destination_length - copy_length {
484            return Err(jvm
485                .exception("java/lang/ArrayIndexOutOfBoundsException", "invalid destination range")
486                .await);
487        }
488        jvm.store_array(
489            &mut destination,
490            destination_begin as usize,
491            characters[source_begin as usize..source_end as usize].to_vec(),
492        )
493        .await
494    }
495
496    async fn set_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32, character: JavaChar) -> Result<()> {
497        let mut characters = Self::characters(jvm, &this).await?;
498        if index < 0 || index as usize >= characters.len() {
499            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
500        }
501        characters[index as usize] = character;
502        Self::replace_characters(jvm, &mut this, characters).await
503    }
504
505    async fn append_object(
506        jvm: &Jvm,
507        _: &mut RuntimeContext,
508        this: ClassInstanceRef<Self>,
509        object: ClassInstanceRef<Object>,
510    ) -> Result<ClassInstanceRef<Self>> {
511        let string: ClassInstanceRef<String> = if object.is_null() {
512            JavaLangString::from_rust_string(jvm, "null").await?.into()
513        } else {
514            jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
515                .await?
516        };
517        jvm.invoke_virtual(
518            &this,
519            "java/lang/AbstractStringBuilder",
520            "append",
521            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
522            (string,),
523        )
524        .await
525    }
526
527    async fn append_string(
528        jvm: &Jvm,
529        _: &mut RuntimeContext,
530        mut this: ClassInstanceRef<Self>,
531        string: ClassInstanceRef<String>,
532    ) -> Result<ClassInstanceRef<Self>> {
533        let mut characters = Self::characters(jvm, &this).await?;
534        if string.is_null() {
535            characters.extend("null".encode_utf16());
536        } else {
537            characters.extend(JavaLangString::to_utf16(jvm, &string).await?);
538        }
539        Self::replace_characters(jvm, &mut this, characters).await?;
540        Ok(this)
541    }
542
543    async fn append_string_buffer(
544        jvm: &Jvm,
545        _: &mut RuntimeContext,
546        this: ClassInstanceRef<Self>,
547        buffer: ClassInstanceRef<StringBuffer>,
548    ) -> Result<ClassInstanceRef<Self>> {
549        let string: ClassInstanceRef<String> = if buffer.is_null() {
550            JavaLangString::from_rust_string(jvm, "null").await?.into()
551        } else {
552            jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
553                .await?
554        };
555        jvm.invoke_virtual(
556            &this,
557            "java/lang/AbstractStringBuilder",
558            "append",
559            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
560            (string,),
561        )
562        .await
563    }
564
565    async fn append_char_sequence(
566        jvm: &Jvm,
567        _: &mut RuntimeContext,
568        mut this: ClassInstanceRef<Self>,
569        sequence: ClassInstanceRef<CharSequence>,
570    ) -> Result<ClassInstanceRef<Self>> {
571        let mut characters = Self::characters(jvm, &this).await?;
572        characters.extend(Self::char_sequence_characters(jvm, &sequence).await?);
573        Self::replace_characters(jvm, &mut this, characters).await?;
574        Ok(this)
575    }
576
577    async fn append_char_sequence_range(
578        jvm: &Jvm,
579        _: &mut RuntimeContext,
580        mut this: ClassInstanceRef<Self>,
581        sequence: ClassInstanceRef<CharSequence>,
582        start: i32,
583        end: i32,
584    ) -> Result<ClassInstanceRef<Self>> {
585        let source = Self::char_sequence_characters(jvm, &sequence).await?;
586        if start < 0 || end > source.len() as i32 || start > end {
587            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid CharSequence range").await);
588        }
589        let mut characters = Self::characters(jvm, &this).await?;
590        characters.extend_from_slice(&source[start as usize..end as usize]);
591        Self::replace_characters(jvm, &mut this, characters).await?;
592        Ok(this)
593    }
594
595    async fn append_char_array(
596        jvm: &Jvm,
597        _: &mut RuntimeContext,
598        this: ClassInstanceRef<Self>,
599        array: ClassInstanceRef<Array<JavaChar>>,
600    ) -> Result<ClassInstanceRef<Self>> {
601        if array.is_null() {
602            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
603        }
604        let length = jvm.array_length(&array).await? as i32;
605        jvm.invoke_virtual(
606            &this,
607            "java/lang/AbstractStringBuilder",
608            "append",
609            "([CII)Ljava/lang/AbstractStringBuilder;",
610            (array, 0, length),
611        )
612        .await
613    }
614
615    async fn append_char_array_range(
616        jvm: &Jvm,
617        _: &mut RuntimeContext,
618        mut this: ClassInstanceRef<Self>,
619        array: ClassInstanceRef<Array<JavaChar>>,
620        offset: i32,
621        length: i32,
622    ) -> Result<ClassInstanceRef<Self>> {
623        if array.is_null() {
624            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
625        }
626        let array_length = jvm.array_length(&array).await? as i32;
627        if offset < 0 || length < 0 || offset > array_length - length {
628            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid char array range").await);
629        }
630        let mut characters = Self::characters(jvm, &this).await?;
631        characters.extend(jvm.load_array::<JavaChar>(&array, offset as usize, length as usize).await?);
632        Self::replace_characters(jvm, &mut this, characters).await?;
633        Ok(this)
634    }
635
636    async fn append_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: bool) -> Result<ClassInstanceRef<Self>> {
637        let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
638        jvm.invoke_virtual(
639            &this,
640            "java/lang/AbstractStringBuilder",
641            "append",
642            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
643            (string,),
644        )
645        .await
646    }
647
648    async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: JavaChar) -> Result<ClassInstanceRef<Self>> {
649        let mut characters = Self::characters(jvm, &this).await?;
650        characters.push(value);
651        Self::replace_characters(jvm, &mut this, characters).await?;
652        Ok(this)
653    }
654
655    async fn append_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<ClassInstanceRef<Self>> {
656        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
657        jvm.invoke_virtual(
658            &this,
659            "java/lang/AbstractStringBuilder",
660            "append",
661            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
662            (string,),
663        )
664        .await
665    }
666
667    async fn append_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i64) -> Result<ClassInstanceRef<Self>> {
668        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
669        jvm.invoke_virtual(
670            &this,
671            "java/lang/AbstractStringBuilder",
672            "append",
673            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
674            (string,),
675        )
676        .await
677    }
678
679    async fn append_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<ClassInstanceRef<Self>> {
680        let string: ClassInstanceRef<String> = jvm
681            .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
682            .await?;
683        jvm.invoke_virtual(
684            &this,
685            "java/lang/AbstractStringBuilder",
686            "append",
687            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
688            (string,),
689        )
690        .await
691    }
692
693    async fn append_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<ClassInstanceRef<Self>> {
694        let string: ClassInstanceRef<String> = jvm
695            .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
696            .await?;
697        jvm.invoke_virtual(
698            &this,
699            "java/lang/AbstractStringBuilder",
700            "append",
701            "(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;",
702            (string,),
703        )
704        .await
705    }
706
707    async fn append_code_point(
708        jvm: &Jvm,
709        _: &mut RuntimeContext,
710        mut this: ClassInstanceRef<Self>,
711        code_point: i32,
712    ) -> Result<ClassInstanceRef<Self>> {
713        if !(0..=0x10ffff).contains(&code_point) {
714            return Err(jvm.exception("java/lang/IllegalArgumentException", "invalid code point").await);
715        }
716        let mut characters = Self::characters(jvm, &this).await?;
717        if code_point < 0x10000 {
718            characters.push(code_point as JavaChar);
719        } else {
720            let value = code_point - 0x10000;
721            characters.push((0xd800 + (value >> 10)) as JavaChar);
722            characters.push((0xdc00 + (value & 0x3ff)) as JavaChar);
723        }
724        Self::replace_characters(jvm, &mut this, characters).await?;
725        Ok(this)
726    }
727
728    async fn delete(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, start: i32, end: i32) -> Result<ClassInstanceRef<Self>> {
729        let mut characters = Self::characters(jvm, &this).await?;
730        let end = end.min(characters.len() as i32);
731        if start < 0 || start > end {
732            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", "invalid delete range").await);
733        }
734        characters.drain(start as usize..end as usize);
735        Self::replace_characters(jvm, &mut this, characters).await?;
736        Ok(this)
737    }
738
739    async fn delete_char_at(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, index: i32) -> Result<ClassInstanceRef<Self>> {
740        let mut characters = Self::characters(jvm, &this).await?;
741        if index < 0 || index as usize >= characters.len() {
742            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", &index.to_string()).await);
743        }
744        characters.remove(index as usize);
745        Self::replace_characters(jvm, &mut this, characters).await?;
746        Ok(this)
747    }
748
749    async fn replace(
750        jvm: &Jvm,
751        _: &mut RuntimeContext,
752        mut this: ClassInstanceRef<Self>,
753        start: i32,
754        end: i32,
755        string: ClassInstanceRef<String>,
756    ) -> Result<ClassInstanceRef<Self>> {
757        let mut characters = Self::characters(jvm, &this).await?;
758        let end = end.min(characters.len() as i32);
759        if start < 0 || start > characters.len() as i32 || start > end {
760            return Err(jvm.exception("java/lang/StringIndexOutOfBoundsException", "invalid replace range").await);
761        }
762        if string.is_null() {
763            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
764        }
765        characters.splice(start as usize..end as usize, JavaLangString::to_utf16(jvm, &string).await?);
766        Self::replace_characters(jvm, &mut this, characters).await?;
767        Ok(this)
768    }
769
770    async fn substring(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, start: i32) -> Result<ClassInstanceRef<String>> {
771        let count: i32 = jvm.get_field(&this, "count", "I").await?;
772        jvm.invoke_virtual(
773            &this,
774            "java/lang/AbstractStringBuilder",
775            "substring",
776            "(II)Ljava/lang/String;",
777            (start, count),
778        )
779        .await
780    }
781
782    async fn substring_range(
783        jvm: &Jvm,
784        _: &mut RuntimeContext,
785        this: ClassInstanceRef<Self>,
786        start: i32,
787        end: i32,
788    ) -> Result<ClassInstanceRef<String>> {
789        let characters = Self::characters(jvm, &this).await?;
790        if start < 0 || end > characters.len() as i32 || start > end {
791            return Err(jvm
792                .exception("java/lang/StringIndexOutOfBoundsException", "invalid substring range")
793                .await);
794        }
795        Ok(JavaLangString::from_utf16(jvm, characters[start as usize..end as usize].to_vec())
796            .await?
797            .into())
798    }
799
800    async fn sub_sequence(
801        jvm: &Jvm,
802        _: &mut RuntimeContext,
803        this: ClassInstanceRef<Self>,
804        start: i32,
805        end: i32,
806    ) -> Result<ClassInstanceRef<CharSequence>> {
807        jvm.invoke_virtual(
808            &this,
809            "java/lang/AbstractStringBuilder",
810            "substring",
811            "(II)Ljava/lang/String;",
812            (start, end),
813        )
814        .await
815    }
816
817    async fn insert_char_array_range(
818        jvm: &Jvm,
819        _: &mut RuntimeContext,
820        mut this: ClassInstanceRef<Self>,
821        offset: i32,
822        array: ClassInstanceRef<Array<JavaChar>>,
823        source_offset: i32,
824        length: i32,
825    ) -> Result<ClassInstanceRef<Self>> {
826        if array.is_null() {
827            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
828        }
829        let array_length = jvm.array_length(&array).await? as i32;
830        if source_offset < 0 || length < 0 || source_offset > array_length - length {
831            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid char array range").await);
832        }
833        let inserted = jvm.load_array(&array, source_offset as usize, length as usize).await?;
834        Self::insert_characters(jvm, &mut this, offset, inserted).await?;
835        Ok(this)
836    }
837
838    async fn insert_object(
839        jvm: &Jvm,
840        _: &mut RuntimeContext,
841        this: ClassInstanceRef<Self>,
842        offset: i32,
843        object: ClassInstanceRef<Object>,
844    ) -> Result<ClassInstanceRef<Self>> {
845        let string: ClassInstanceRef<String> = if object.is_null() {
846            JavaLangString::from_rust_string(jvm, "null").await?.into()
847        } else {
848            jvm.invoke_virtual(&object, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
849                .await?
850        };
851        jvm.invoke_virtual(
852            &this,
853            "java/lang/AbstractStringBuilder",
854            "insert",
855            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
856            (offset, string),
857        )
858        .await
859    }
860
861    async fn insert_string(
862        jvm: &Jvm,
863        _: &mut RuntimeContext,
864        mut this: ClassInstanceRef<Self>,
865        offset: i32,
866        string: ClassInstanceRef<String>,
867    ) -> Result<ClassInstanceRef<Self>> {
868        let inserted = if string.is_null() {
869            "null".encode_utf16().collect()
870        } else {
871            JavaLangString::to_utf16(jvm, &string).await?
872        };
873        Self::insert_characters(jvm, &mut this, offset, inserted).await?;
874        Ok(this)
875    }
876
877    async fn insert_char_array(
878        jvm: &Jvm,
879        _: &mut RuntimeContext,
880        this: ClassInstanceRef<Self>,
881        offset: i32,
882        array: ClassInstanceRef<Array<JavaChar>>,
883    ) -> Result<ClassInstanceRef<Self>> {
884        if array.is_null() {
885            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
886        }
887        let length = jvm.array_length(&array).await? as i32;
888        jvm.invoke_virtual(
889            &this,
890            "java/lang/AbstractStringBuilder",
891            "insert",
892            "(I[CII)Ljava/lang/AbstractStringBuilder;",
893            (offset, array, 0, length),
894        )
895        .await
896    }
897
898    async fn insert_char_sequence(
899        jvm: &Jvm,
900        _: &mut RuntimeContext,
901        mut this: ClassInstanceRef<Self>,
902        offset: i32,
903        sequence: ClassInstanceRef<CharSequence>,
904    ) -> Result<ClassInstanceRef<Self>> {
905        let inserted = Self::char_sequence_characters(jvm, &sequence).await?;
906        Self::insert_characters(jvm, &mut this, offset, inserted).await?;
907        Ok(this)
908    }
909
910    async fn insert_char_sequence_range(
911        jvm: &Jvm,
912        _: &mut RuntimeContext,
913        mut this: ClassInstanceRef<Self>,
914        offset: i32,
915        sequence: ClassInstanceRef<CharSequence>,
916        start: i32,
917        end: i32,
918    ) -> Result<ClassInstanceRef<Self>> {
919        let source = Self::char_sequence_characters(jvm, &sequence).await?;
920        if start < 0 || end > source.len() as i32 || start > end {
921            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid CharSequence range").await);
922        }
923        Self::insert_characters(jvm, &mut this, offset, source[start as usize..end as usize].to_vec()).await?;
924        Ok(this)
925    }
926
927    async fn insert_boolean(
928        jvm: &Jvm,
929        _: &mut RuntimeContext,
930        this: ClassInstanceRef<Self>,
931        offset: i32,
932        value: bool,
933    ) -> Result<ClassInstanceRef<Self>> {
934        let string = JavaLangString::from_rust_string(jvm, if value { "true" } else { "false" }).await?;
935        jvm.invoke_virtual(
936            &this,
937            "java/lang/AbstractStringBuilder",
938            "insert",
939            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
940            (offset, string),
941        )
942        .await
943    }
944
945    async fn insert_char(
946        jvm: &Jvm,
947        _: &mut RuntimeContext,
948        mut this: ClassInstanceRef<Self>,
949        offset: i32,
950        value: JavaChar,
951    ) -> Result<ClassInstanceRef<Self>> {
952        Self::insert_characters(jvm, &mut this, offset, vec![value]).await?;
953        Ok(this)
954    }
955
956    async fn insert_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i32) -> Result<ClassInstanceRef<Self>> {
957        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
958        jvm.invoke_virtual(
959            &this,
960            "java/lang/AbstractStringBuilder",
961            "insert",
962            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
963            (offset, string),
964        )
965        .await
966    }
967
968    async fn insert_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, offset: i32, value: i64) -> Result<ClassInstanceRef<Self>> {
969        let string = JavaLangString::from_rust_string(jvm, &value.to_string()).await?;
970        jvm.invoke_virtual(
971            &this,
972            "java/lang/AbstractStringBuilder",
973            "insert",
974            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
975            (offset, string),
976        )
977        .await
978    }
979
980    async fn insert_float(
981        jvm: &Jvm,
982        _: &mut RuntimeContext,
983        this: ClassInstanceRef<Self>,
984        offset: i32,
985        value: f32,
986    ) -> Result<ClassInstanceRef<Self>> {
987        let string: ClassInstanceRef<String> = jvm
988            .invoke_static("java/lang/Float", "toString", "(F)Ljava/lang/String;", (value,))
989            .await?;
990        jvm.invoke_virtual(
991            &this,
992            "java/lang/AbstractStringBuilder",
993            "insert",
994            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
995            (offset, string),
996        )
997        .await
998    }
999
1000    async fn insert_double(
1001        jvm: &Jvm,
1002        _: &mut RuntimeContext,
1003        this: ClassInstanceRef<Self>,
1004        offset: i32,
1005        value: f64,
1006    ) -> Result<ClassInstanceRef<Self>> {
1007        let string: ClassInstanceRef<String> = jvm
1008            .invoke_static("java/lang/Double", "toString", "(D)Ljava/lang/String;", (value,))
1009            .await?;
1010        jvm.invoke_virtual(
1011            &this,
1012            "java/lang/AbstractStringBuilder",
1013            "insert",
1014            "(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;",
1015            (offset, string),
1016        )
1017        .await
1018    }
1019
1020    async fn index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1021        jvm.invoke_virtual(&this, "java/lang/AbstractStringBuilder", "indexOf", "(Ljava/lang/String;I)I", (string, 0))
1022            .await
1023    }
1024
1025    async fn index_of_from(
1026        jvm: &Jvm,
1027        _: &mut RuntimeContext,
1028        this: ClassInstanceRef<Self>,
1029        string: ClassInstanceRef<String>,
1030        from_index: i32,
1031    ) -> Result<i32> {
1032        if string.is_null() {
1033            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1034        }
1035        let characters = Self::characters(jvm, &this).await?;
1036        let needle = JavaLangString::to_utf16(jvm, &string).await?;
1037        let start = from_index.max(0) as usize;
1038        if needle.is_empty() {
1039            return Ok(start.min(characters.len()) as i32);
1040        }
1041        if start > characters.len().saturating_sub(needle.len()) {
1042            return Ok(-1);
1043        }
1044        Ok(characters[start..]
1045            .windows(needle.len())
1046            .position(|candidate| candidate == needle)
1047            .map_or(-1, |index| (start + index) as i32))
1048    }
1049
1050    async fn last_index_of(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<i32> {
1051        let count: i32 = jvm.get_field(&this, "count", "I").await?;
1052        jvm.invoke_virtual(
1053            &this,
1054            "java/lang/AbstractStringBuilder",
1055            "lastIndexOf",
1056            "(Ljava/lang/String;I)I",
1057            (string, count),
1058        )
1059        .await
1060    }
1061
1062    async fn last_index_of_from(
1063        jvm: &Jvm,
1064        _: &mut RuntimeContext,
1065        this: ClassInstanceRef<Self>,
1066        string: ClassInstanceRef<String>,
1067        from_index: i32,
1068    ) -> Result<i32> {
1069        if string.is_null() {
1070            return Err(jvm.exception("java/lang/NullPointerException", "str is null").await);
1071        }
1072        let characters = Self::characters(jvm, &this).await?;
1073        let needle = JavaLangString::to_utf16(jvm, &string).await?;
1074        if needle.is_empty() {
1075            return Ok(from_index.min(characters.len() as i32).max(-1));
1076        }
1077        if from_index < 0 || needle.len() > characters.len() {
1078            return Ok(-1);
1079        }
1080        let last_start = (characters.len() - needle.len()).min(from_index as usize);
1081        for index in (0..=last_start).rev() {
1082            if characters[index..index + needle.len()] == needle {
1083                return Ok(index as i32);
1084            }
1085        }
1086        Ok(-1)
1087    }
1088
1089    async fn reverse(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Self>> {
1090        let mut characters = Self::characters(jvm, &this).await?;
1091        characters.reverse();
1092        let mut index = 0;
1093        while index + 1 < characters.len() {
1094            if (0xdc00..=0xdfff).contains(&characters[index]) && (0xd800..=0xdbff).contains(&characters[index + 1]) {
1095                characters.swap(index, index + 1);
1096                index += 2;
1097            } else {
1098                index += 1;
1099            }
1100        }
1101        Self::replace_characters(jvm, &mut this, characters).await?;
1102        Ok(this)
1103    }
1104}