Skip to main content

rustjava_runtime/classes/java/io/
buffered_output_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, classes::java::io::OutputStream};
8
9const DEFAULT_BUFFER_SIZE: i32 = 8192;
10
11// class java.io.BufferedOutputStream
12pub struct BufferedOutputStream;
13
14impl BufferedOutputStream {
15    pub fn as_proto() -> RuntimeClassProto {
16        RuntimeClassProto {
17            name: "java/io/BufferedOutputStream",
18            parent_class: Some("java/io/FilterOutputStream"),
19            interfaces: vec![],
20            methods: vec![
21                JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;I)V", Self::init_with_size, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("write", "(I)V", Self::write, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
24                JavaMethodProto::new(
25                    "write",
26                    "([BII)V",
27                    Self::write_bytes,
28                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
29                ),
30                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
31            ],
32            fields: vec![
33                JavaFieldProto::new("buf", "[B", FieldAccessFlags::PROTECTED),
34                JavaFieldProto::new("count", "I", FieldAccessFlags::PROTECTED),
35            ],
36            access_flags: ClassAccessFlags::PUBLIC,
37        }
38    }
39
40    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, out: ClassInstanceRef<OutputStream>) -> Result<()> {
41        tracing::debug!("java.io.BufferedOutputStream::<init>({this:?}, {out:?})");
42        jvm.invoke_special(
43            &this,
44            "java/io/BufferedOutputStream",
45            "<init>",
46            "(Ljava/io/OutputStream;I)V",
47            (out, DEFAULT_BUFFER_SIZE),
48        )
49        .await
50    }
51
52    async fn init_with_size(
53        jvm: &Jvm,
54        _: &mut RuntimeContext,
55        mut this: ClassInstanceRef<Self>,
56        out: ClassInstanceRef<OutputStream>,
57        size: i32,
58    ) -> Result<()> {
59        tracing::debug!("java.io.BufferedOutputStream::<init>({this:?}, {out:?}, {size})");
60
61        if out.is_null() {
62            return Err(jvm.exception("java/lang/NullPointerException", "output is null").await);
63        }
64        if size <= 0 {
65            return Err(jvm.exception("java/lang/IllegalArgumentException", "Buffer size <= 0").await);
66        }
67
68        let _: () = jvm
69            .invoke_special(&this, "java/io/FilterOutputStream", "<init>", "(Ljava/io/OutputStream;)V", (out,))
70            .await?;
71        let buffer = jvm.instantiate_array("B", size as usize).await?;
72        jvm.put_field(&mut this, "java/io/BufferedOutputStream", "buf", "[B", buffer).await?;
73        jvm.put_field(&mut this, "java/io/BufferedOutputStream", "count", "I", 0).await
74    }
75
76    async fn flush_buffer(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
77        let out: ClassInstanceRef<OutputStream> = jvm
78            .get_field(this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;")
79            .await?;
80        let buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(this, "java/io/BufferedOutputStream", "buf", "[B").await?;
81        if out.is_null() || buffer.is_null() {
82            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
83        }
84        let count: i32 = jvm.get_field(this, "java/io/BufferedOutputStream", "count", "I").await?;
85        if count > 0 {
86            let _: () = jvm
87                .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (buffer, 0, count))
88                .await?;
89            jvm.put_field(this, "java/io/BufferedOutputStream", "count", "I", 0).await?;
90        }
91        Ok(())
92    }
93
94    async fn write(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
95        tracing::debug!("java.io.BufferedOutputStream::write({this:?}, {value})");
96
97        let out: ClassInstanceRef<OutputStream> = jvm
98            .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;")
99            .await?;
100        let mut buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?;
101        if out.is_null() || buffer.is_null() {
102            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
103        }
104        let mut count: i32 = jvm.get_field(&this, "java/io/BufferedOutputStream", "count", "I").await?;
105        if count >= jvm.array_length(&buffer).await? as i32 {
106            Self::flush_buffer(jvm, &mut this).await?;
107            count = 0;
108            buffer = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?;
109        }
110        jvm.store_array(&mut buffer, count as usize, [value as i8]).await?;
111        jvm.put_field(&mut this, "java/io/BufferedOutputStream", "count", "I", count + 1).await
112    }
113
114    async fn write_bytes(
115        jvm: &Jvm,
116        _: &mut RuntimeContext,
117        mut this: ClassInstanceRef<Self>,
118        bytes: ClassInstanceRef<Array<i8>>,
119        offset: i32,
120        length: i32,
121    ) -> Result<()> {
122        tracing::debug!("java.io.BufferedOutputStream::write({this:?}, {bytes:?}, {offset}, {length})");
123
124        let source_length = jvm.array_length(&bytes).await? as i32;
125        if offset < 0 || length < 0 || offset > source_length - length {
126            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
127        }
128        let out: ClassInstanceRef<OutputStream> = jvm
129            .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;")
130            .await?;
131        let mut buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?;
132        if out.is_null() || buffer.is_null() {
133            return Err(jvm.exception("java/io/IOException", "Stream closed").await);
134        }
135        if length == 0 {
136            return Ok(());
137        }
138
139        let buffer_length = jvm.array_length(&buffer).await? as i32;
140        if length >= buffer_length {
141            Self::flush_buffer(jvm, &mut this).await?;
142            return jvm
143                .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, offset, length))
144                .await;
145        }
146
147        let mut count: i32 = jvm.get_field(&this, "java/io/BufferedOutputStream", "count", "I").await?;
148        if length > buffer_length - count {
149            Self::flush_buffer(jvm, &mut this).await?;
150            count = 0;
151            buffer = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?;
152        }
153        let _: () = jvm
154            .invoke_static(
155                "java/lang/System",
156                "arraycopy",
157                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
158                (bytes, offset, buffer, count, length),
159            )
160            .await?;
161        jvm.put_field(&mut this, "java/io/BufferedOutputStream", "count", "I", count + length)
162            .await
163    }
164
165    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
166        tracing::debug!("java.io.BufferedOutputStream::flush({this:?})");
167
168        Self::flush_buffer(jvm, &mut this).await?;
169        let out: ClassInstanceRef<OutputStream> = jvm
170            .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;")
171            .await?;
172        jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await
173    }
174}