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, "buf", "[B", data).await?;
86        jvm.put_field(&mut this, "pos", "I", offset).await?;
87        jvm.put_field(&mut this, "count", "I", (offset + length).min(data_length)).await?;
88        jvm.put_field(&mut this, "mark", "I", offset).await?;
89
90        Ok(())
91    }
92
93    async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
94        tracing::debug!("java.io.ByteArrayInputStream::available({this:?})");
95
96        let count: i32 = jvm.get_field(&this, "count", "I").await?;
97        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
98
99        Ok((count - pos) as _)
100    }
101
102    async fn read(
103        jvm: &Jvm,
104        _: &mut RuntimeContext,
105        mut this: ClassInstanceRef<Self>,
106        b: ClassInstanceRef<Array<i8>>,
107        off: i32,
108        len: i32,
109    ) -> Result<i32> {
110        tracing::debug!("java.io.ByteArrayInputStream::read({this:?}, {b:?}, {off}, {len})");
111
112        if b.is_null() {
113            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
114        }
115        let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
116        let count: i32 = jvm.get_field(&this, "count", "I").await?;
117        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
118
119        let target_length = jvm.array_length(&b).await? as i32;
120        if off < 0 || len < 0 || off > target_length - len {
121            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
122        }
123        if len == 0 {
124            return Ok(0);
125        }
126
127        let available = count - pos;
128        if available <= 0 {
129            return Ok(-1);
130        }
131        let len_to_read = if len > available { available } else { len };
132
133        let _: () = jvm
134            .invoke_static(
135                "java/lang/System",
136                "arraycopy",
137                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
138                (buf, pos, b, off, len_to_read),
139            )
140            .await?;
141
142        jvm.put_field(&mut this, "pos", "I", pos + len_to_read).await?;
143
144        Ok(len_to_read)
145    }
146
147    async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
148        tracing::debug!("java.io.ByteArrayInputStream::readByte({this:?})");
149
150        let buf = jvm.get_field(&this, "buf", "[B").await?;
151        let count: i32 = jvm.get_field(&this, "count", "I").await?;
152        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
153
154        if pos >= count {
155            return Ok(-1);
156        }
157
158        let result: i8 = jvm.load_array(&buf, pos as _, 1).await?[0];
159
160        jvm.put_field(&mut this, "pos", "I", pos + 1).await?;
161
162        Ok(result as u8 as _)
163    }
164
165    async fn close(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<ByteArrayInputStream>) -> Result<()> {
166        tracing::debug!("java.io.ByteArrayInputStream::close({this:?})");
167
168        Ok(())
169    }
170
171    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
172        tracing::debug!("java.io.ByteArrayInputStream::skip({this:?}, {n:?})");
173
174        let count: i32 = jvm.get_field(&this, "count", "I").await?;
175        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
176
177        let available = (count - pos) as i64;
178        let len_to_skip = n.max(0).min(available);
179
180        jvm.put_field(&mut this, "pos", "I", pos + len_to_skip as i32).await?;
181
182        Ok(len_to_skip)
183    }
184
185    async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {
186        tracing::debug!("java.io.ByteArrayInputStream::mark({this:?}, {readlimit:?})");
187
188        let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
189        jvm.put_field(&mut this, "mark", "I", pos).await?;
190
191        Ok(())
192    }
193
194    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
195        tracing::debug!("java.io.ByteArrayInputStream::reset({this:?})");
196
197        let mark: i32 = jvm.get_field(&this, "mark", "I").await?;
198        jvm.put_field(&mut this, "pos", "I", mark).await?;
199
200        Ok(())
201    }
202
203    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
204        tracing::debug!("java.io.ByteArrayInputStream::markSupported({this:?})");
205        Ok(true)
206    }
207}