Skip to main content

rustjava_runtime/classes/java/io/
buffered_input_stream.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::io::InputStream};
8
9const DEFAULT_BUFFER_SIZE: i32 = 8192;
10
11// class java.io.BufferedInputStream
12pub struct BufferedInputStream;
13
14impl BufferedInputStream {
15    pub fn as_proto() -> RuntimeClassProto {
16        RuntimeClassProto {
17            name: "java/io/BufferedInputStream",
18            parent_class: Some("java/io/FilterInputStream"),
19            interfaces: vec![],
20            methods: vec![
21                JavaMethodProto::new("<init>", "(Ljava/io/InputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("<init>", "(Ljava/io/InputStream;I)V", Self::init_with_size, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new(
24                    "read",
25                    "()I",
26                    Self::read_byte,
27                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
28                ),
29                JavaMethodProto::new("read", "([BII)I", Self::read, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
30                JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
31                JavaMethodProto::new(
32                    "available",
33                    "()I",
34                    Self::available,
35                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
36                ),
37                JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
38                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
39                JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
40                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
41            ],
42            fields: vec![
43                JavaFieldProto::new("buf", "[B", FieldAccessFlags::PROTECTED | FieldAccessFlags::VOLATILE),
44                JavaFieldProto::new("count", "I", FieldAccessFlags::PROTECTED),
45                JavaFieldProto::new("pos", "I", FieldAccessFlags::PROTECTED),
46                JavaFieldProto::new("markpos", "I", FieldAccessFlags::PROTECTED),
47                JavaFieldProto::new("marklimit", "I", FieldAccessFlags::PROTECTED),
48            ],
49            access_flags: ClassAccessFlags::PUBLIC,
50        }
51    }
52
53    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, r#in: ClassInstanceRef<InputStream>) -> Result<()> {
54        tracing::debug!("java.io.BufferedInputStream::<init>({this:?}, {in:?})", in = &r#in);
55
56        jvm.invoke_special(
57            &this,
58            "java/io/BufferedInputStream",
59            "<init>",
60            "(Ljava/io/InputStream;I)V",
61            (r#in, DEFAULT_BUFFER_SIZE),
62        )
63        .await
64    }
65
66    async fn init_with_size(
67        jvm: &Jvm,
68        _: &mut RuntimeContext,
69        mut this: ClassInstanceRef<Self>,
70        r#in: ClassInstanceRef<InputStream>,
71        size: i32,
72    ) -> Result<()> {
73        tracing::debug!("java.io.BufferedInputStream::<init>({this:?}, {in:?}, {size})", in = &r#in);
74
75        if r#in.is_null() {
76            return Err(jvm.exception("java/lang/NullPointerException", "input is null").await);
77        }
78        if size <= 0 {
79            return Err(jvm.exception("java/lang/IllegalArgumentException", "Buffer size <= 0").await);
80        }
81
82        let _: () = jvm
83            .invoke_special(&this, "java/io/FilterInputStream", "<init>", "(Ljava/io/InputStream;)V", (r#in,))
84            .await?;
85        let buffer = jvm.instantiate_array("B", size as usize).await?;
86        jvm.put_field(&mut this, "java/io/BufferedInputStream", "buf", "[B", buffer).await?;
87        jvm.put_field(&mut this, "java/io/BufferedInputStream", "count", "I", 0).await?;
88        jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", 0).await?;
89        jvm.put_field(&mut this, "java/io/BufferedInputStream", "markpos", "I", -1).await?;
90        jvm.put_field(&mut this, "java/io/BufferedInputStream", "marklimit", "I", 0).await
91    }
92
93    async fn fill(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<i32> {
94        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?;
95        let mut buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(this, "java/io/BufferedInputStream", "buf", "[B").await?;
96        if r#in.is_null() || buffer.is_null() {
97            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
98        }
99
100        let mut position: i32 = jvm.get_field(this, "java/io/BufferedInputStream", "pos", "I").await?;
101        let mut mark_position: i32 = jvm.get_field(this, "java/io/BufferedInputStream", "markpos", "I").await?;
102        let mark_limit: i32 = jvm.get_field(this, "java/io/BufferedInputStream", "marklimit", "I").await?;
103        let mut buffer_length = jvm.array_length(&buffer).await? as i32;
104
105        if mark_position < 0 {
106            position = 0;
107        } else if position >= buffer_length {
108            if mark_position > 0 {
109                let preserved = position - mark_position;
110                let _: () = jvm
111                    .invoke_static(
112                        "java/lang/System",
113                        "arraycopy",
114                        "(Ljava/lang/Object;ILjava/lang/Object;II)V",
115                        (buffer.clone(), mark_position, buffer.clone(), 0, preserved),
116                    )
117                    .await?;
118                position = preserved;
119                mark_position = 0;
120            } else if buffer_length >= mark_limit {
121                mark_position = -1;
122                position = 0;
123            } else {
124                let new_length = (buffer_length.saturating_mul(2)).min(mark_limit).max(buffer_length + 1);
125                let new_buffer: ClassInstanceRef<Array<i8>> = jvm.instantiate_array("B", new_length as usize).await?.into();
126                let _: () = jvm
127                    .invoke_static(
128                        "java/lang/System",
129                        "arraycopy",
130                        "(Ljava/lang/Object;ILjava/lang/Object;II)V",
131                        (buffer, 0, new_buffer.clone(), 0, position),
132                    )
133                    .await?;
134                buffer = new_buffer;
135                buffer_length = new_length;
136                jvm.put_field(this, "java/io/BufferedInputStream", "buf", "[B", buffer.clone()).await?;
137            }
138        }
139
140        jvm.put_field(this, "java/io/BufferedInputStream", "pos", "I", position).await?;
141        jvm.put_field(this, "java/io/BufferedInputStream", "markpos", "I", mark_position).await?;
142        jvm.put_field(this, "java/io/BufferedInputStream", "count", "I", position).await?;
143
144        let read: i32 = jvm
145            .invoke_virtual(
146                &r#in,
147                "java/io/InputStream",
148                "read",
149                "([BII)I",
150                (buffer, position, buffer_length - position),
151            )
152            .await?;
153        if read > 0 {
154            jvm.put_field(this, "java/io/BufferedInputStream", "count", "I", position + read).await?;
155        }
156        Ok(read)
157    }
158
159    async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
160        tracing::debug!("java.io.BufferedInputStream::read({this:?})");
161
162        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?;
163        let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?;
164        if r#in.is_null() || buffer.is_null() {
165            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
166        }
167
168        let mut position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
169        let mut count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?;
170        if position >= count {
171            if Self::fill(jvm, &mut this).await? == -1 {
172                return Ok(-1);
173            }
174            position = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
175            count = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?;
176            if position >= count {
177                return Ok(-1);
178            }
179        }
180
181        let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?;
182        let value = jvm.load_array::<i8>(&buffer, position as usize, 1).await?[0];
183        jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", position + 1).await?;
184        Ok(value as u8 as i32)
185    }
186
187    async fn read(
188        jvm: &Jvm,
189        _: &mut RuntimeContext,
190        mut this: ClassInstanceRef<Self>,
191        target: ClassInstanceRef<Array<i8>>,
192        offset: i32,
193        length: i32,
194    ) -> Result<i32> {
195        tracing::debug!("java.io.BufferedInputStream::read({this:?}, {target:?}, {offset}, {length})");
196
197        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?;
198        let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?;
199        if r#in.is_null() || buffer.is_null() {
200            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
201        }
202        if target.is_null() {
203            return Err(jvm.exception("java/lang/NullPointerException", "target is null").await);
204        }
205        let target_length = jvm.array_length(&target).await? as i32;
206        if offset < 0 || length < 0 || offset > target_length - length {
207            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
208        }
209        if length == 0 {
210            return Ok(0);
211        }
212
213        let mut total = 0;
214        while total < length {
215            let mut position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
216            let mut count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?;
217            if position >= count {
218                if Self::fill(jvm, &mut this).await? == -1 {
219                    break;
220                }
221                position = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
222                count = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?;
223                if position >= count {
224                    break;
225                }
226            }
227
228            let copied = (count - position).min(length - total);
229            let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?;
230            let _: () = jvm
231                .invoke_static(
232                    "java/lang/System",
233                    "arraycopy",
234                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
235                    (buffer, position, target.clone(), offset + total, copied),
236                )
237                .await?;
238            jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", position + copied)
239                .await?;
240            total += copied;
241
242            if total < length {
243                let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
244                if available == 0 {
245                    break;
246                }
247            }
248        }
249
250        if total == 0 { Ok(-1) } else { Ok(total) }
251    }
252
253    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, amount: i64) -> Result<i64> {
254        tracing::debug!("java.io.BufferedInputStream::skip({this:?}, {amount})");
255
256        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?;
257        let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?;
258        if r#in.is_null() || buffer.is_null() {
259            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
260        }
261        if amount <= 0 {
262            return Ok(0);
263        }
264
265        let mut position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
266        let mut count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?;
267        if position >= count {
268            let mark_position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "markpos", "I").await?;
269            if mark_position < 0 {
270                return jvm.invoke_virtual(&r#in, "java/io/InputStream", "skip", "(J)J", (amount,)).await;
271            }
272            if Self::fill(jvm, &mut this).await? == -1 {
273                return Ok(0);
274            }
275            position = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
276            count = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?;
277        }
278
279        let skipped = amount.min((count - position) as i64);
280        jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", position + skipped as i32)
281            .await?;
282        Ok(skipped)
283    }
284
285    async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
286        tracing::debug!("java.io.BufferedInputStream::available({this:?})");
287
288        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?;
289        let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?;
290        if r#in.is_null() || buffer.is_null() {
291            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
292        }
293        let position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
294        let count: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "count", "I").await?;
295        let underlying: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
296        Ok((count - position).saturating_add(underlying))
297    }
298
299    async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, read_limit: i32) -> Result<()> {
300        tracing::debug!("java.io.BufferedInputStream::mark({this:?}, {read_limit})");
301
302        let position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "pos", "I").await?;
303        jvm.put_field(&mut this, "java/io/BufferedInputStream", "marklimit", "I", read_limit)
304            .await?;
305        jvm.put_field(&mut this, "java/io/BufferedInputStream", "markpos", "I", position).await
306    }
307
308    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
309        tracing::debug!("java.io.BufferedInputStream::reset({this:?})");
310
311        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?;
312        let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedInputStream", "buf", "[B").await?;
313        if r#in.is_null() || buffer.is_null() {
314            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
315        }
316        let mark_position: i32 = jvm.get_field(&this, "java/io/BufferedInputStream", "markpos", "I").await?;
317        if mark_position < 0 {
318            return Err(jvm.exception("java/io/IOException", "Resetting to invalid mark").await);
319        }
320        jvm.put_field(&mut this, "java/io/BufferedInputStream", "pos", "I", mark_position).await
321    }
322
323    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
324        tracing::debug!("java.io.BufferedInputStream::markSupported({this:?})");
325        Ok(true)
326    }
327
328    async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
329        tracing::debug!("java.io.BufferedInputStream::close({this:?})");
330
331        let r#in: ClassInstanceRef<InputStream> = jvm.get_field(&this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;").await?;
332        if r#in.is_null() {
333            return Ok(());
334        }
335        let null_input: ClassInstanceRef<InputStream> = None.into();
336        let null_buffer: ClassInstanceRef<Array<i8>> = None.into();
337        jvm.put_field(&mut this, "java/io/BufferedInputStream", "in", "Ljava/io/InputStream;", null_input)
338            .await?;
339        jvm.put_field(&mut this, "java/io/BufferedInputStream", "buf", "[B", null_buffer).await?;
340        jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await
341    }
342}