Skip to main content

rustjava_runtime/classes/java/io/
output_stream.rs

1use 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
9// abstract class java.io.OutputStream
10pub struct OutputStream;
11
12impl OutputStream {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/io/OutputStream",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec!["java/io/Closeable", "java/io/Flushable"],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
20                JavaMethodProto::new("write", "([B)V", Self::write_bytes, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new("write", "([BII)V", Self::write_bytes_offset, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new_abstract("write", "(I)V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
23                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
25            ],
26            fields: vec![],
27            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
28        }
29    }
30
31    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
32        tracing::debug!("java.io.OutputStream::<init>({this:?})");
33
34        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
35
36        Ok(())
37    }
38
39    async fn write_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buffer: ClassInstanceRef<Array<i8>>) -> Result<()> {
40        tracing::debug!("java.io.OutputStream::write({this:?}, {buffer:?})");
41
42        if buffer.is_null() {
43            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
44        }
45        let length = jvm.array_length(&buffer).await?;
46
47        let _: () = jvm
48            .invoke_virtual(&this, "java/io/OutputStream", "write", "([BII)V", (buffer, 0, length as i32))
49            .await?;
50
51        Ok(())
52    }
53
54    async fn write_bytes_offset(
55        jvm: &Jvm,
56        _: &mut RuntimeContext,
57        this: ClassInstanceRef<Self>,
58        buffer: ClassInstanceRef<Array<i8>>,
59        offset: i32,
60        length: i32,
61    ) -> Result<()> {
62        tracing::debug!("java.io.OutputStream::write({this:?}, {buffer:?}, {offset:?}, {length:?})");
63
64        if buffer.is_null() {
65            return Err(jvm.exception("java/lang/NullPointerException", "buffer is null").await);
66        }
67        let mut bytes = vec![0; length as usize];
68        jvm.array_raw_buffer(&buffer).await?.read(offset as _, &mut bytes)?;
69        for byte in bytes {
70            let _: () = jvm.invoke_virtual(&this, "java/io/OutputStream", "write", "(I)V", (byte as i32,)).await?;
71        }
72
73        Ok(())
74    }
75
76    async fn flush(_jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
77        tracing::debug!("java.io.OutputStream::flush({this:?})");
78
79        Ok(())
80    }
81
82    async fn close(_jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
83        tracing::debug!("java.io.OutputStream::close({this:?})");
84
85        Ok(())
86    }
87}