Skip to main content

rustjava_runtime/classes/java/io/
byte_array_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};
8
9// class java.io.ByteArrayInputStream
10pub struct ByteArrayInputStream;
11
12impl ByteArrayInputStream {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/io/ByteArrayInputStream",
16            parent_class: Some("java/io/InputStream"),
17            interfaces: vec![],
18            methods: vec![
19                JavaMethodProto::new("<init>", "([B)V", Self::init, MethodAccessFlags::PUBLIC),
20                JavaMethodProto::new("<init>", "([BII)V", Self::init_with_offset_length, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new(
22                    "available",
23                    "()I",
24                    Self::available,
25                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
26                ),
27                JavaMethodProto::new("read", "([BII)I", Self::read, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
28                JavaMethodProto::new(
29                    "read",
30                    "()I",
31                    Self::read_byte,
32                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
33                ),
34                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
35                JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
36                JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
38                JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
39            ],
40            fields: vec![
41                JavaFieldProto::new("buf", "[B", FieldAccessFlags::PROTECTED),
42                JavaFieldProto::new("pos", "I", FieldAccessFlags::PROTECTED),
43                JavaFieldProto::new("count", "I", FieldAccessFlags::PROTECTED),
44                JavaFieldProto::new("mark", "I", FieldAccessFlags::PROTECTED),
45            ],
46            access_flags: ClassAccessFlags::PUBLIC,
47        }
48    }
49
50    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, data: ClassInstanceRef<Array<i8>>) -> Result<()> {
51        tracing::debug!("java.io.ByteArrayInputStream::<init>({this:?}, {data:?})");
52
53        if data.is_null() {
54            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
55        }
56        let count = jvm.array_length(&data).await?;
57
58        let _: () = jvm
59            .invoke_special(&this, "java/io/ByteArrayInputStream", "<init>", "([BII)V", (data, 0, count as i32))
60            .await?;
61
62        Ok(())
63    }
64
65    async fn init_with_offset_length(
66        jvm: &Jvm,
67        _: &mut RuntimeContext,
68        mut this: ClassInstanceRef<Self>,
69        data: ClassInstanceRef<Array<i8>>,
70        offset: i32,
71        length: i32,
72    ) -> Result<()> {
73        tracing::debug!("java.io.ByteArrayInputStream::<init>({this:?}, {data:?}, {offset}, {length})");
74
75        if data.is_null() {
76            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
77        }
78        let data_length = jvm.array_length(&data).await? as i32;
79        if offset < 0 || length < 0 || offset > data_length {
80            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
81        }
82
83        let _: () = jvm.invoke_special(&this, "java/io/InputStream", "<init>", "()V", ()).await?;
84
85        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "buf", "[B", data).await?;
86        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", offset).await?;
87        jvm.put_field(
88            &mut this,
89            "java/io/ByteArrayInputStream",
90            "count",
91            "I",
92            (offset + length).min(data_length),
93        )
94        .await?;
95        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "mark", "I", offset).await?;
96
97        Ok(())
98    }
99
100    async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
101        tracing::debug!("java.io.ByteArrayInputStream::available({this:?})");
102
103        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
104        let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
105
106        Ok((count - pos) as _)
107    }
108
109    async fn read(
110        jvm: &Jvm,
111        _: &mut RuntimeContext,
112        mut this: ClassInstanceRef<Self>,
113        b: ClassInstanceRef<Array<i8>>,
114        off: i32,
115        len: i32,
116    ) -> Result<i32> {
117        tracing::debug!("java.io.ByteArrayInputStream::read({this:?}, {b:?}, {off}, {len})");
118
119        if b.is_null() {
120            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
121        }
122        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/ByteArrayInputStream", "buf", "[B").await?;
123        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
124        let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
125
126        let target_length = jvm.array_length(&b).await? as i32;
127        if off < 0 || len < 0 || off > target_length - len {
128            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
129        }
130        if len == 0 {
131            return Ok(0);
132        }
133
134        let available = count - pos;
135        if available <= 0 {
136            return Ok(-1);
137        }
138        let len_to_read = if len > available { available } else { len };
139
140        let _: () = jvm
141            .invoke_static(
142                "java/lang/System",
143                "arraycopy",
144                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
145                (buf, pos, b, off, len_to_read),
146            )
147            .await?;
148
149        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + len_to_read)
150            .await?;
151
152        Ok(len_to_read)
153    }
154
155    async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
156        tracing::debug!("java.io.ByteArrayInputStream::readByte({this:?})");
157
158        let buf = jvm.get_field(&this, "java/io/ByteArrayInputStream", "buf", "[B").await?;
159        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
160        let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
161
162        if pos >= count {
163            return Ok(-1);
164        }
165
166        let result: i8 = jvm.load_array(&buf, pos as _, 1).await?[0];
167
168        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + 1).await?;
169
170        Ok(result as u8 as _)
171    }
172
173    async fn close(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<ByteArrayInputStream>) -> Result<()> {
174        tracing::debug!("java.io.ByteArrayInputStream::close({this:?})");
175
176        Ok(())
177    }
178
179    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
180        tracing::debug!("java.io.ByteArrayInputStream::skip({this:?}, {n:?})");
181
182        let count: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "count", "I").await?;
183        let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
184
185        let available = (count - pos) as i64;
186        let len_to_skip = n.max(0).min(available);
187
188        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", pos + len_to_skip as i32)
189            .await?;
190
191        Ok(len_to_skip)
192    }
193
194    async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {
195        tracing::debug!("java.io.ByteArrayInputStream::mark({this:?}, {readlimit:?})");
196
197        let pos: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "pos", "I").await?;
198        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "mark", "I", pos).await?;
199
200        Ok(())
201    }
202
203    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
204        tracing::debug!("java.io.ByteArrayInputStream::reset({this:?})");
205
206        let mark: i32 = jvm.get_field(&this, "java/io/ByteArrayInputStream", "mark", "I").await?;
207        jvm.put_field(&mut this, "java/io/ByteArrayInputStream", "pos", "I", mark).await?;
208
209        Ok(())
210    }
211
212    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
213        tracing::debug!("java.io.ByteArrayInputStream::markSupported({this:?})");
214        Ok(true)
215    }
216}