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
12pub 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}