Skip to main content

rustjava_runtime/classes/java/io/
string_reader.rs

1use core::future::Future;
2
3use alloc::vec;
4
5use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    RuntimeClassProto, RuntimeContext,
11    classes::java::lang::{Object, String},
12};
13
14// class java.io.StringReader
15pub struct StringReader;
16
17impl StringReader {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/io/StringReader",
21            parent_class: Some("java/io/Reader"),
22            interfaces: vec![],
23            methods: vec![
24                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("read", "()I", Self::read_char, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("read", "([CII)I", Self::read, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("ready", "()Z", Self::ready, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
33            ],
34            fields: vec![
35                JavaFieldProto::new("str", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
36                JavaFieldProto::new("length", "I", FieldAccessFlags::PRIVATE),
37                JavaFieldProto::new("next", "I", FieldAccessFlags::PRIVATE),
38                JavaFieldProto::new("mark", "I", FieldAccessFlags::PRIVATE),
39            ],
40            access_flags: ClassAccessFlags::PUBLIC,
41        }
42    }
43
44    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
45        tracing::debug!("java.io.StringReader::<init>({this:?}, {value:?})");
46
47        if value.is_null() {
48            return Err(jvm.exception("java/lang/NullPointerException", "string is null").await);
49        }
50        let _: () = jvm.invoke_special(&this, "java/io/Reader", "<init>", "()V", ()).await?;
51        let length: i32 = jvm.invoke_virtual(&value, "java/lang/String", "length", "()I", ()).await?;
52        jvm.put_field(&mut this, "str", "Ljava/lang/String;", value).await?;
53        jvm.put_field(&mut this, "length", "I", length).await?;
54        jvm.put_field(&mut this, "next", "I", 0).await?;
55        jvm.put_field(&mut this, "mark", "I", 0).await
56    }
57
58    async fn with_lock<T, F>(jvm: &Jvm, lock: &ClassInstanceRef<Object>, operation: F) -> Result<T>
59    where
60        F: Future<Output = Result<T>>,
61    {
62        jvm.monitor_enter(lock).await?;
63        match operation.await {
64            Ok(value) => {
65                jvm.monitor_exit(lock).await?;
66                Ok(value)
67            }
68            Err(error) => {
69                if let Err(exit_error) = jvm.monitor_exit(lock).await {
70                    tracing::error!(?exit_error, "failed to release StringReader lock");
71                }
72                Err(error)
73            }
74        }
75    }
76
77    async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
78        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?;
79        Self::with_lock(jvm, &lock, Self::read_char_locked(jvm, this)).await
80    }
81
82    async fn read_char_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<i32> {
83        tracing::debug!("java.io.StringReader::read({this:?})");
84
85        let value: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
86        if value.is_null() {
87            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
88        }
89        let next: i32 = jvm.get_field(&this, "next", "I").await?;
90        let length: i32 = jvm.get_field(&this, "length", "I").await?;
91        if next >= length {
92            return Ok(-1);
93        }
94        let result: JavaChar = jvm.invoke_virtual(&value, "java/lang/String", "charAt", "(I)C", (next,)).await?;
95        jvm.put_field(&mut this, "next", "I", next + 1).await?;
96        Ok(result as i32)
97    }
98
99    async fn read(
100        jvm: &Jvm,
101        _: &mut RuntimeContext,
102        this: ClassInstanceRef<Self>,
103        target: ClassInstanceRef<Array<JavaChar>>,
104        offset: i32,
105        length: i32,
106    ) -> Result<i32> {
107        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?;
108        Self::with_lock(jvm, &lock, Self::read_locked(jvm, this, target, offset, length)).await
109    }
110
111    async fn read_locked(
112        jvm: &Jvm,
113        mut this: ClassInstanceRef<Self>,
114        target: ClassInstanceRef<Array<JavaChar>>,
115        offset: i32,
116        length: i32,
117    ) -> Result<i32> {
118        tracing::debug!("java.io.StringReader::read({this:?}, {target:?}, {offset}, {length})");
119
120        let value: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
121        if value.is_null() {
122            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
123        }
124        if target.is_null() {
125            return Err(jvm.exception("java/lang/NullPointerException", "target is null").await);
126        }
127        let target_length = jvm.array_length(&target).await? as i32;
128        if offset < 0 || length < 0 || offset > target_length - length {
129            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
130        }
131        if length == 0 {
132            return Ok(0);
133        }
134
135        let next: i32 = jvm.get_field(&this, "next", "I").await?;
136        let source_length: i32 = jvm.get_field(&this, "length", "I").await?;
137        if next >= source_length {
138            return Ok(-1);
139        }
140        let copied = length.min(source_length - next);
141        let _: () = jvm
142            .invoke_virtual(&value, "java/lang/String", "getChars", "(II[CI)V", (next, next + copied, target, offset))
143            .await?;
144        jvm.put_field(&mut this, "next", "I", next + copied).await?;
145        Ok(copied)
146    }
147
148    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
149        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?;
150        Self::with_lock(jvm, &lock, Self::skip_locked(jvm, this, amount)).await
151    }
152
153    async fn skip_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
154        tracing::debug!("java.io.StringReader::skip({this:?}, {amount})");
155
156        let value: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
157        if value.is_null() {
158            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
159        }
160        if amount <= 0 {
161            return Ok(0);
162        }
163        let next: i32 = jvm.get_field(&this, "next", "I").await?;
164        let length: i32 = jvm.get_field(&this, "length", "I").await?;
165        let skipped = amount.min((length - next) as i64);
166        jvm.put_field(&mut this, "next", "I", next + skipped as i32).await?;
167        Ok(skipped)
168    }
169
170    async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
171        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?;
172        Self::with_lock(jvm, &lock, Self::ready_locked(jvm, this)).await
173    }
174
175    async fn ready_locked(jvm: &Jvm, this: ClassInstanceRef<Self>) -> Result<bool> {
176        tracing::debug!("java.io.StringReader::ready({this:?})");
177
178        let value: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
179        if value.is_null() {
180            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
181        }
182        Ok(true)
183    }
184
185    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
186        tracing::debug!("java.io.StringReader::markSupported({this:?})");
187        Ok(true)
188    }
189
190    async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, read_ahead_limit: i32) -> Result<()> {
191        tracing::debug!("java.io.StringReader::mark({this:?}, {read_ahead_limit})");
192
193        if read_ahead_limit < 0 {
194            return Err(jvm.exception("java/lang/IllegalArgumentException", "Read-ahead limit < 0").await);
195        }
196        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?;
197        Self::with_lock(jvm, &lock, Self::mark_locked(jvm, this)).await
198    }
199
200    async fn mark_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
201        let value: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
202        if value.is_null() {
203            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
204        }
205        let next: i32 = jvm.get_field(&this, "next", "I").await?;
206        jvm.put_field(&mut this, "mark", "I", next).await
207    }
208
209    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
210        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?;
211        Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await
212    }
213
214    async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
215        tracing::debug!("java.io.StringReader::reset({this:?})");
216
217        let value: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
218        if value.is_null() {
219            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
220        }
221        let mark: i32 = jvm.get_field(&this, "mark", "I").await?;
222        jvm.put_field(&mut this, "next", "I", mark).await
223    }
224
225    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
226        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "lock", "Ljava/lang/Object;").await?;
227        Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await
228    }
229
230    async fn close_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
231        tracing::debug!("java.io.StringReader::close({this:?})");
232
233        let null_string: ClassInstanceRef<String> = None.into();
234        jvm.put_field(&mut this, "str", "Ljava/lang/String;", null_string).await
235    }
236}