Skip to main content

rustjava_runtime/classes/java/io/
input_stream.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext};
8
9// abstract class java.io.InputStream
10pub struct InputStream;
11
12impl InputStream {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/io/InputStream",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec![],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
20                JavaMethodProto::new("available", "()I", Self::available, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new("read", "([BII)I", Self::read_offset, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("read", "([B)I", Self::read, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new_abstract("read", "()I", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
24                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
29            ],
30            fields: vec![],
31            access_flags: ClassAccessFlags::ABSTRACT,
32        }
33    }
34
35    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
36        tracing::debug!("java.io.InputStream::<init>({this:?})");
37
38        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
39
40        Ok(())
41    }
42
43    async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, b: ClassInstanceRef<Array<i8>>) -> Result<i32> {
44        tracing::debug!("java.io.InputStream::read({this:?}, {b:?})");
45
46        if b.is_null() {
47            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
48        }
49        let array_length = jvm.array_length(&b).await? as i32;
50
51        jvm.invoke_virtual(&this, "java/io/InputStream", "read", "([BII)I", (b, 0, array_length))
52            .await
53    }
54
55    async fn read_offset(
56        jvm: &Jvm,
57        _: &mut RuntimeContext,
58        this: ClassInstanceRef<Self>,
59        mut b: ClassInstanceRef<Array<i8>>,
60        off: i32,
61        len: i32,
62    ) -> Result<i32> {
63        tracing::debug!("java.io.InputStream::read({this:?}, {b:?}, {off}, {len})");
64
65        if b.is_null() {
66            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
67        }
68        let array_length = jvm.array_length(&b).await? as i32;
69        if off < 0 || len < 0 || off > array_length - len {
70            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
71        }
72        if len == 0 {
73            return Ok(0);
74        }
75
76        let first: i32 = jvm.invoke_virtual(&this, "java/io/InputStream", "read", "()I", ()).await?;
77        if first == -1 {
78            return Ok(-1);
79        }
80        jvm.store_array(&mut b, off as usize, [first as i8]).await?;
81
82        let mut count = 1;
83        while count < len {
84            let value: i32 = jvm.invoke_virtual(&this, "java/io/InputStream", "read", "()I", ()).await?;
85            if value == -1 {
86                break;
87            }
88            jvm.store_array(&mut b, (off + count) as usize, [value as i8]).await?;
89            count += 1;
90        }
91
92        Ok(count)
93    }
94
95    async fn available(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
96        tracing::debug!("java.io.InputStream::available({this:?})");
97        Ok(0)
98    }
99
100    async fn close(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
101        tracing::debug!("java.io.InputStream::close({this:?})");
102        Ok(())
103    }
104
105    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
106        tracing::debug!("java.io.InputStream::skip({this:?}, {n:?})");
107
108        if n <= 0 {
109            return Ok(0);
110        }
111
112        let scratch_size = n.min(4096);
113        let scratch = jvm.instantiate_array("B", scratch_size as _).await?;
114
115        let mut remaining = n;
116        while remaining > 0 {
117            let len_to_read = remaining.min(scratch_size) as i32;
118            let read: i32 = jvm
119                .invoke_virtual(&this, "java/io/InputStream", "read", "([BII)I", (scratch.clone(), 0, len_to_read))
120                .await?;
121            if read <= 0 {
122                break;
123            }
124
125            remaining -= read as i64;
126        }
127
128        Ok(n - remaining)
129    }
130
131    async fn mark(_jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {
132        tracing::debug!("java.io.InputStream::mark({this:?}, {readlimit:?})");
133
134        Ok(())
135    }
136
137    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
138        tracing::debug!("java.io.InputStream::reset({this:?})");
139
140        Err(jvm.exception("java/io/IOException", "reset not supported").await)
141    }
142
143    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
144        tracing::debug!("java.io.InputStream::markSupported({this:?})");
145        Ok(false)
146    }
147}