use alloc::vec;
use jvm::{Array, ClassInstanceRef, Jvm, Result};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::{RuntimeClassProto, RuntimeContext};
pub struct ByteArrayInputStream;
impl ByteArrayInputStream {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/io/ByteArrayInputStream",
parent_class: Some("java/io/InputStream"),
interfaces: vec![],
methods: vec![
JavaMethodProto::new("<init>", "([B)V", Self::init, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("<init>", "([BII)V", Self::init_with_offset_length, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"available",
"()I",
Self::available,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("read", "([BII)I", Self::read, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
JavaMethodProto::new(
"read",
"()I",
Self::read_byte,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
],
fields: vec![
JavaFieldProto::new("buf", "[B", FieldAccessFlags::PROTECTED),
JavaFieldProto::new("pos", "I", FieldAccessFlags::PROTECTED),
JavaFieldProto::new("count", "I", FieldAccessFlags::PROTECTED),
JavaFieldProto::new("mark", "I", FieldAccessFlags::PROTECTED),
],
access_flags: ClassAccessFlags::PUBLIC,
}
}
async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, data: ClassInstanceRef<Array<i8>>) -> Result<()> {
tracing::debug!("java.io.ByteArrayInputStream::<init>({this:?}, {data:?})");
if data.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
}
let count = jvm.array_length(&data).await?;
let _: () = jvm
.invoke_special(&this, "java/io/ByteArrayInputStream", "<init>", "([BII)V", (data, 0, count as i32))
.await?;
Ok(())
}
async fn init_with_offset_length(
jvm: &Jvm,
_: &mut RuntimeContext,
mut this: ClassInstanceRef<Self>,
data: ClassInstanceRef<Array<i8>>,
offset: i32,
length: i32,
) -> Result<()> {
tracing::debug!("java.io.ByteArrayInputStream::<init>({this:?}, {data:?}, {offset}, {length})");
if data.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
}
let data_length = jvm.array_length(&data).await? as i32;
if offset < 0 || length < 0 || offset > data_length {
return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
}
let _: () = jvm.invoke_special(&this, "java/io/InputStream", "<init>", "()V", ()).await?;
jvm.put_field(&mut this, "buf", "[B", data).await?;
jvm.put_field(&mut this, "pos", "I", offset).await?;
jvm.put_field(&mut this, "count", "I", (offset + length).min(data_length)).await?;
jvm.put_field(&mut this, "mark", "I", offset).await?;
Ok(())
}
async fn available(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
tracing::debug!("java.io.ByteArrayInputStream::available({this:?})");
let count: i32 = jvm.get_field(&this, "count", "I").await?;
let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
Ok((count - pos) as _)
}
async fn read(
jvm: &Jvm,
_: &mut RuntimeContext,
mut this: ClassInstanceRef<Self>,
b: ClassInstanceRef<Array<i8>>,
off: i32,
len: i32,
) -> Result<i32> {
tracing::debug!("java.io.ByteArrayInputStream::read({this:?}, {b:?}, {off}, {len})");
if b.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
}
let buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "buf", "[B").await?;
let count: i32 = jvm.get_field(&this, "count", "I").await?;
let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
let target_length = jvm.array_length(&b).await? as i32;
if off < 0 || len < 0 || off > target_length - len {
return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
}
if len == 0 {
return Ok(0);
}
let available = count - pos;
if available <= 0 {
return Ok(-1);
}
let len_to_read = if len > available { available } else { len };
let _: () = jvm
.invoke_static(
"java/lang/System",
"arraycopy",
"(Ljava/lang/Object;ILjava/lang/Object;II)V",
(buf, pos, b, off, len_to_read),
)
.await?;
jvm.put_field(&mut this, "pos", "I", pos + len_to_read).await?;
Ok(len_to_read)
}
async fn read_byte(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
tracing::debug!("java.io.ByteArrayInputStream::readByte({this:?})");
let buf = jvm.get_field(&this, "buf", "[B").await?;
let count: i32 = jvm.get_field(&this, "count", "I").await?;
let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
if pos >= count {
return Ok(-1);
}
let result: i8 = jvm.load_array(&buf, pos as _, 1).await?[0];
jvm.put_field(&mut this, "pos", "I", pos + 1).await?;
Ok(result as u8 as _)
}
async fn close(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<ByteArrayInputStream>) -> Result<()> {
tracing::debug!("java.io.ByteArrayInputStream::close({this:?})");
Ok(())
}
async fn skip(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
tracing::debug!("java.io.ByteArrayInputStream::skip({this:?}, {n:?})");
let count: i32 = jvm.get_field(&this, "count", "I").await?;
let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
let available = (count - pos) as i64;
let len_to_skip = n.max(0).min(available);
jvm.put_field(&mut this, "pos", "I", pos + len_to_skip as i32).await?;
Ok(len_to_skip)
}
async fn mark(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, readlimit: i32) -> Result<()> {
tracing::debug!("java.io.ByteArrayInputStream::mark({this:?}, {readlimit:?})");
let pos: i32 = jvm.get_field(&this, "pos", "I").await?;
jvm.put_field(&mut this, "mark", "I", pos).await?;
Ok(())
}
async fn reset(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.io.ByteArrayInputStream::reset({this:?})");
let mark: i32 = jvm.get_field(&this, "mark", "I").await?;
jvm.put_field(&mut this, "pos", "I", mark).await?;
Ok(())
}
async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
tracing::debug!("java.io.ByteArrayInputStream::markSupported({this:?})");
Ok(true)
}
}