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