Skip to main content

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