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, "java/io/StringReader", "str", "Ljava/lang/String;", value)
53            .await?;
54        jvm.put_field(&mut this, "java/io/StringReader", "length", "I", length).await?;
55        jvm.put_field(&mut this, "java/io/StringReader", "next", "I", 0).await?;
56        jvm.put_field(&mut this, "java/io/StringReader", "mark", "I", 0).await
57    }
58
59    async fn with_lock<T, F>(jvm: &Jvm, lock: &ClassInstanceRef<Object>, operation: F) -> Result<T>
60    where
61        F: Future<Output = Result<T>>,
62    {
63        jvm.monitor_enter(lock).await?;
64        match operation.await {
65            Ok(value) => {
66                jvm.monitor_exit(lock).await?;
67                Ok(value)
68            }
69            Err(error) => {
70                if let Err(exit_error) = jvm.monitor_exit(lock).await {
71                    tracing::error!(?exit_error, "failed to release StringReader lock");
72                }
73                Err(error)
74            }
75        }
76    }
77
78    async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
79        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
80        Self::with_lock(jvm, &lock, Self::read_char_locked(jvm, this)).await
81    }
82
83    async fn read_char_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<i32> {
84        tracing::debug!("java.io.StringReader::read({this:?})");
85
86        let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
87        if value.is_null() {
88            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
89        }
90        let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
91        let length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?;
92        if next >= length {
93            return Ok(-1);
94        }
95        let result: JavaChar = jvm.invoke_virtual(&value, "java/lang/String", "charAt", "(I)C", (next,)).await?;
96        jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + 1).await?;
97        Ok(result as i32)
98    }
99
100    async fn read(
101        jvm: &Jvm,
102        _: &mut RuntimeContext,
103        this: ClassInstanceRef<Self>,
104        target: ClassInstanceRef<Array<JavaChar>>,
105        offset: i32,
106        length: i32,
107    ) -> Result<i32> {
108        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
109        Self::with_lock(jvm, &lock, Self::read_locked(jvm, this, target, offset, length)).await
110    }
111
112    async fn read_locked(
113        jvm: &Jvm,
114        mut this: ClassInstanceRef<Self>,
115        target: ClassInstanceRef<Array<JavaChar>>,
116        offset: i32,
117        length: i32,
118    ) -> Result<i32> {
119        tracing::debug!("java.io.StringReader::read({this:?}, {target:?}, {offset}, {length})");
120
121        let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
122        if value.is_null() {
123            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
124        }
125        if target.is_null() {
126            return Err(jvm.exception("java/lang/NullPointerException", "target is null").await);
127        }
128        let target_length = jvm.array_length(&target).await? as i32;
129        if offset < 0 || length < 0 || offset > target_length - length {
130            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
131        }
132        if length == 0 {
133            return Ok(0);
134        }
135
136        let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
137        let source_length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?;
138        if next >= source_length {
139            return Ok(-1);
140        }
141        let copied = length.min(source_length - next);
142        let _: () = jvm
143            .invoke_virtual(&value, "java/lang/String", "getChars", "(II[CI)V", (next, next + copied, target, offset))
144            .await?;
145        jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + copied).await?;
146        Ok(copied)
147    }
148
149    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
150        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
151        Self::with_lock(jvm, &lock, Self::skip_locked(jvm, this, amount)).await
152    }
153
154    async fn skip_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
155        tracing::debug!("java.io.StringReader::skip({this:?}, {amount})");
156
157        let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
158        if value.is_null() {
159            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
160        }
161        if amount <= 0 {
162            return Ok(0);
163        }
164        let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
165        let length: i32 = jvm.get_field(&this, "java/io/StringReader", "length", "I").await?;
166        let skipped = amount.min((length - next) as i64);
167        jvm.put_field(&mut this, "java/io/StringReader", "next", "I", next + skipped as i32)
168            .await?;
169        Ok(skipped)
170    }
171
172    async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
173        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
174        Self::with_lock(jvm, &lock, Self::ready_locked(jvm, this)).await
175    }
176
177    async fn ready_locked(jvm: &Jvm, this: ClassInstanceRef<Self>) -> Result<bool> {
178        tracing::debug!("java.io.StringReader::ready({this:?})");
179
180        let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
181        if value.is_null() {
182            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
183        }
184        Ok(true)
185    }
186
187    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
188        tracing::debug!("java.io.StringReader::markSupported({this:?})");
189        Ok(true)
190    }
191
192    async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, read_ahead_limit: i32) -> Result<()> {
193        tracing::debug!("java.io.StringReader::mark({this:?}, {read_ahead_limit})");
194
195        if read_ahead_limit < 0 {
196            return Err(jvm.exception("java/lang/IllegalArgumentException", "Read-ahead limit < 0").await);
197        }
198        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
199        Self::with_lock(jvm, &lock, Self::mark_locked(jvm, this)).await
200    }
201
202    async fn mark_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
203        let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
204        if value.is_null() {
205            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
206        }
207        let next: i32 = jvm.get_field(&this, "java/io/StringReader", "next", "I").await?;
208        jvm.put_field(&mut this, "java/io/StringReader", "mark", "I", next).await
209    }
210
211    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
212        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
213        Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await
214    }
215
216    async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
217        tracing::debug!("java.io.StringReader::reset({this:?})");
218
219        let value: ClassInstanceRef<String> = jvm.get_field(&this, "java/io/StringReader", "str", "Ljava/lang/String;").await?;
220        if value.is_null() {
221            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
222        }
223        let mark: i32 = jvm.get_field(&this, "java/io/StringReader", "mark", "I").await?;
224        jvm.put_field(&mut this, "java/io/StringReader", "next", "I", mark).await
225    }
226
227    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
228        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/StringReader", "lock", "Ljava/lang/Object;").await?;
229        Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await
230    }
231
232    async fn close_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
233        tracing::debug!("java.io.StringReader::close({this:?})");
234
235        let null_string: ClassInstanceRef<String> = None.into();
236        jvm.put_field(&mut this, "java/io/StringReader", "str", "Ljava/lang/String;", null_string)
237            .await
238    }
239}