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, "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}