Skip to main content

rustjava_runtime/classes/java/io/
file_output_stream.rs

1use alloc::vec;
2
3use bytemuck::cast_slice;
4
5use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    FileOpenOptions, RuntimeClassProto, RuntimeContext,
11    classes::java::io::{File, FileDescriptor},
12};
13
14// class java.io.FileOutputStream
15pub struct FileOutputStream;
16
17impl FileOutputStream {
18    pub fn as_proto() -> RuntimeClassProto {
19        RuntimeClassProto {
20            name: "java/io/FileOutputStream",
21            parent_class: Some("java/io/OutputStream"),
22            interfaces: vec![],
23            methods: vec![
24                JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("<init>", "(Ljava/io/File;Z)V", Self::init_with_append, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new(
27                    "<init>",
28                    "(Ljava/io/FileDescriptor;)V",
29                    Self::init_with_file_descriptor,
30                    MethodAccessFlags::PUBLIC,
31                ),
32                JavaMethodProto::new("write", "([BII)V", Self::write_bytes_offset, MethodAccessFlags::PUBLIC),
33                JavaMethodProto::new("write", "(I)V", Self::write, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
35            ],
36            fields: vec![
37                JavaFieldProto::new("fd", "Ljava/io/FileDescriptor;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
38                JavaFieldProto::new("append", "Z", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
39            ],
40            access_flags: ClassAccessFlags::PUBLIC,
41        }
42    }
43
44    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
45        tracing::debug!("java.io.FileOutputStream::<init>({this:?}, {file:?})");
46        jvm.invoke_special(&this, "java/io/FileOutputStream", "<init>", "(Ljava/io/File;Z)V", (file, false))
47            .await
48    }
49
50    async fn init_with_append(
51        jvm: &Jvm,
52        context: &mut RuntimeContext,
53        mut this: ClassInstanceRef<Self>,
54        file: ClassInstanceRef<File>,
55        append: bool,
56    ) -> Result<()> {
57        tracing::debug!("java.io.FileOutputStream::<init>({this:?}, {file:?}, {append})");
58        if file.is_null() {
59            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
60        }
61
62        let path = jvm.invoke_virtual(&file, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
63        let path = JavaLangString::to_rust_string(jvm, &path).await?;
64
65        let fd = context
66            .open(
67                &path,
68                FileOpenOptions {
69                    write: true,
70                    append,
71                    truncate: !append,
72                    create: true,
73                    ..Default::default()
74                },
75            )
76            .await;
77        if fd.is_err() {
78            return Err(jvm.exception("java/io/FileNotFoundException", "File not found").await);
79        }
80
81        let fd = FileDescriptor::from_fd(jvm, fd.unwrap()).await?;
82        let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "<init>", "()V", ()).await?;
83        jvm.put_field(&mut this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;", fd)
84            .await?;
85        jvm.put_field(&mut this, "java/io/FileOutputStream", "append", "Z", append).await
86    }
87
88    async fn init_with_file_descriptor(
89        jvm: &Jvm,
90        _: &mut RuntimeContext,
91        mut this: ClassInstanceRef<Self>,
92        file_descriptor: ClassInstanceRef<FileDescriptor>,
93    ) -> Result<()> {
94        tracing::debug!("java.io.FileOutputStream::<init>({this:?}, {file_descriptor:?})");
95        if file_descriptor.is_null() {
96            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
97        }
98
99        let _: () = jvm.invoke_special(&this, "java/io/OutputStream", "<init>", "()V", ()).await?;
100
101        jvm.put_field(&mut this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;", file_descriptor)
102            .await?;
103        jvm.put_field(&mut this, "java/io/FileOutputStream", "append", "Z", false).await?;
104
105        Ok(())
106    }
107
108    async fn write_bytes_offset(
109        jvm: &Jvm,
110        context: &mut RuntimeContext,
111        this: ClassInstanceRef<Self>,
112        buffer: ClassInstanceRef<Array<i8>>,
113        offset: i32,
114        length: i32,
115    ) -> Result<()> {
116        tracing::debug!("java.io.FileOutputStream::write({this:?}, {buffer:?}, {offset:?}, {length:?})");
117        if buffer.is_null() {
118            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
119        }
120
121        let fd = jvm.get_field(&this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;").await?;
122        let mut file = FileDescriptor::file(jvm, context, fd).await?;
123
124        let mut buf = vec![0; length as _];
125        jvm.array_raw_buffer(&buffer).await?.read(offset as _, &mut buf)?;
126
127        let bytes = cast_slice(&buf);
128        let mut written = 0;
129        while written < bytes.len() {
130            match file.write(&bytes[written..]).await {
131                Ok(0) | Err(_) => return Err(jvm.exception("java/io/IOException", "I/O error").await),
132                Ok(length) if length > bytes.len() - written => return Err(jvm.exception("java/io/IOException", "I/O error").await),
133                Ok(length) => written += length,
134            }
135        }
136
137        Ok(())
138    }
139
140    async fn write(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, byte: i32) -> Result<()> {
141        tracing::debug!("java.io.FileOutputStream::write({this:?}, {byte:?})");
142
143        let fd = jvm.get_field(&this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;").await?;
144        let mut file = FileDescriptor::file(jvm, context, fd).await?;
145
146        if !matches!(file.write(&[byte as u8]).await, Ok(1)) {
147            return Err(jvm.exception("java/io/IOException", "I/O error").await);
148        }
149
150        Ok(())
151    }
152
153    async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
154        tracing::debug!("java.io.FileOutputStream::close({this:?})");
155
156        let fd = jvm.get_field(&this, "java/io/FileOutputStream", "fd", "Ljava/io/FileDescriptor;").await?;
157        FileDescriptor::close(jvm, context, fd).await?;
158
159        Ok(())
160    }
161}