use alloc::vec;
use jvm::{Array, ClassInstanceRef, Jvm, Result};
use jvm_class_proto::JavaMethodProto;
use jvm_types::{ClassAccessFlags, MethodAccessFlags};
use crate::{RuntimeClassProto, RuntimeContext};
pub struct InputStream;
impl InputStream {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/io/InputStream",
parent_class: Some("java/lang/Object"),
interfaces: vec![],
methods: vec![
JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("available", "()I", Self::available, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("read", "([BII)I", Self::read_offset, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("read", "([B)I", Self::read, MethodAccessFlags::PUBLIC),
JavaMethodProto::new_abstract("read", "()I", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
],
fields: vec![],
access_flags: ClassAccessFlags::ABSTRACT,
}
}
async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.io.InputStream::<init>({this:?})");
let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
Ok(())
}
async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, b: ClassInstanceRef<Array<i8>>) -> Result<i32> {
tracing::debug!("java.io.InputStream::read({this:?}, {b:?})");
if b.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
}
let array_length = jvm.array_length(&b).await? as i32;
jvm.invoke_virtual(&this, "java/io/InputStream", "read", "([BII)I", (b, 0, array_length))
.await
}
async fn read_offset(
jvm: &Jvm,
_: &mut RuntimeContext,
this: ClassInstanceRef<Self>,
mut b: ClassInstanceRef<Array<i8>>,
off: i32,
len: i32,
) -> Result<i32> {
tracing::debug!("java.io.InputStream::read({this:?}, {b:?}, {off}, {len})");
if b.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
}
let array_length = jvm.array_length(&b).await? as i32;
if off < 0 || len < 0 || off > array_length - len {
return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
}
if len == 0 {
return Ok(0);
}
let first: i32 = jvm.invoke_virtual(&this, "java/io/InputStream", "read", "()I", ()).await?;
if first == -1 {
return Ok(-1);
}
jvm.store_array(&mut b, off as usize, [first as i8]).await?;
let mut count = 1;
while count < len {
let value: i32 = jvm.invoke_virtual(&this, "java/io/InputStream", "read", "()I", ()).await?;
if value == -1 {
break;
}
jvm.store_array(&mut b, (off + count) as usize, [value as i8]).await?;
count += 1;
}
Ok(count)
}
async fn available(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
tracing::debug!("java.io.InputStream::available({this:?})");
Ok(0)
}
async fn close(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.io.InputStream::close({this:?})");
Ok(())
}
async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
tracing::debug!("java.io.InputStream::skip({this:?}, {n:?})");
if n <= 0 {
return Ok(0);
}
let scratch_size = n.min(4096);
let scratch = jvm.instantiate_array("B", scratch_size as _).await?;
let mut remaining = n;
while remaining > 0 {
let len_to_read = remaining.min(scratch_size) as i32;
let read: i32 = jvm
.invoke_virtual(&this, "java/io/InputStream", "read", "([BII)I", (scratch.clone(), 0, len_to_read))
.await?;
if read <= 0 {
break;
}
remaining -= read as i64;
}
Ok(n - remaining)
}
async fn mark(_jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {
tracing::debug!("java.io.InputStream::mark({this:?}, {readlimit:?})");
Ok(())
}
async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.io.InputStream::reset({this:?})");
Err(jvm.exception("java/io/IOException", "reset not supported").await)
}
async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
tracing::debug!("java.io.InputStream::markSupported({this:?})");
Ok(false)
}
}