rustjava_runtime/classes/java/io/
input_stream.rs1use 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
9pub 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}