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
11pub 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 if bytes.is_null() {
124 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
125 }
126
127 let source_length = jvm.array_length(&bytes).await? as i32;
128 if offset < 0 || length < 0 || offset > source_length - length {
129 return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
130 }
131 let out: ClassInstanceRef<OutputStream> = jvm
132 .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;")
133 .await?;
134 let mut buffer: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?;
135 if out.is_null() || buffer.is_null() {
136 return Err(jvm.exception("java/io/IOException", "Stream closed").await);
137 }
138 if length == 0 {
139 return Ok(());
140 }
141
142 let buffer_length = jvm.array_length(&buffer).await? as i32;
143 if length >= buffer_length {
144 Self::flush_buffer(jvm, &mut this).await?;
145 return jvm
146 .invoke_virtual(&out, "java/io/OutputStream", "write", "([BII)V", (bytes, offset, length))
147 .await;
148 }
149
150 let mut count: i32 = jvm.get_field(&this, "java/io/BufferedOutputStream", "count", "I").await?;
151 if length > buffer_length - count {
152 Self::flush_buffer(jvm, &mut this).await?;
153 count = 0;
154 buffer = jvm.get_field(&this, "java/io/BufferedOutputStream", "buf", "[B").await?;
155 }
156 let _: () = jvm
157 .invoke_static(
158 "java/lang/System",
159 "arraycopy",
160 "(Ljava/lang/Object;ILjava/lang/Object;II)V",
161 (bytes, offset, buffer, count, length),
162 )
163 .await?;
164 jvm.put_field(&mut this, "java/io/BufferedOutputStream", "count", "I", count + length)
165 .await
166 }
167
168 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
169 tracing::debug!("java.io.BufferedOutputStream::flush({this:?})");
170
171 Self::flush_buffer(jvm, &mut this).await?;
172 let out: ClassInstanceRef<OutputStream> = jvm
173 .get_field(&this, "java/io/BufferedOutputStream", "out", "Ljava/io/OutputStream;")
174 .await?;
175 jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", ()).await
176 }
177}