Skip to main content

rustjava_runtime/classes/java/io/
random_access_file.rs

1use alloc::vec;
2
3use bytemuck::cast_vec;
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::{
12        io::{File, FileDescriptor},
13        lang::String,
14    },
15};
16
17// class java.io.RandomAccessFile
18pub struct RandomAccessFile;
19
20impl RandomAccessFile {
21    pub fn as_proto() -> RuntimeClassProto {
22        RuntimeClassProto {
23            name: "java/io/RandomAccessFile",
24            parent_class: Some("java/lang/Object"),
25            interfaces: vec!["java/io/DataInput", "java/io/DataOutput"],
26            methods: vec![
27                JavaMethodProto::new("<init>", "(Ljava/lang/String;Ljava/lang/String;)V", Self::init, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new(
29                    "<init>",
30                    "(Ljava/io/File;Ljava/lang/String;)V",
31                    Self::init_with_file,
32                    MethodAccessFlags::PUBLIC,
33                ),
34                JavaMethodProto::new("read", "([B)I", Self::read, MethodAccessFlags::PUBLIC),
35                JavaMethodProto::new("read", "([BII)I", Self::read_offset_length, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("write", "([B)V", Self::write, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new("write", "([BII)V", Self::write_offset_length, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new("length", "()J", Self::length, MethodAccessFlags::PUBLIC),
39                JavaMethodProto::new("getFilePointer", "()J", Self::get_file_pointer, MethodAccessFlags::PUBLIC),
40                JavaMethodProto::new(
41                    "getFD",
42                    "()Ljava/io/FileDescriptor;",
43                    Self::get_fd,
44                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
45                ),
46                JavaMethodProto::new("seek", "(J)V", Self::seek, MethodAccessFlags::PUBLIC),
47                JavaMethodProto::new("setLength", "(J)V", Self::set_length, MethodAccessFlags::PUBLIC),
48                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
49            ],
50            fields: vec![JavaFieldProto::new(
51                "fd",
52                "Ljava/io/FileDescriptor;",
53                FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL,
54            )],
55            access_flags: ClassAccessFlags::PUBLIC,
56        }
57    }
58
59    async fn init(
60        jvm: &Jvm,
61        context: &mut RuntimeContext,
62        mut this: ClassInstanceRef<Self>,
63        name: ClassInstanceRef<String>,
64        mode: ClassInstanceRef<String>,
65    ) -> Result<()> {
66        tracing::debug!("java.io.RandomAccessFile::<init>({this:?}, {name:?}, {mode:?})");
67        if name.is_null() || mode.is_null() {
68            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
69        }
70
71        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
72
73        let name = JavaLangString::to_rust_string(jvm, &name).await?;
74        let mode = JavaLangString::to_rust_string(jvm, &mode).await?;
75
76        let write = mode.contains('w');
77
78        let fd_id = context
79            .open(
80                &name,
81                FileOpenOptions {
82                    read: true,
83                    write,
84                    create: write,
85                    ..Default::default()
86                },
87            )
88            .await;
89        if fd_id.is_err() {
90            return Err(jvm.exception("java/io/FileNotFoundException", "File not found").await);
91        }
92        let fd = FileDescriptor::from_fd(jvm, fd_id.unwrap()).await?;
93        jvm.put_field(&mut this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;", fd)
94            .await?;
95
96        Ok(())
97    }
98
99    async fn init_with_file(
100        jvm: &Jvm,
101        _context: &mut RuntimeContext,
102        this: ClassInstanceRef<Self>,
103        file: ClassInstanceRef<File>,
104        mode: ClassInstanceRef<String>,
105    ) -> Result<()> {
106        tracing::debug!("java.io.RandomAccessFile::<init>({this:?}, {file:?}, {mode:?})");
107        if file.is_null() {
108            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
109        }
110
111        let name: ClassInstanceRef<String> = jvm.invoke_virtual(&file, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
112
113        let _: () = jvm
114            .invoke_special(
115                &this,
116                "java/io/RandomAccessFile",
117                "<init>",
118                "(Ljava/lang/String;Ljava/lang/String;)V",
119                (name, mode),
120            )
121            .await?;
122
123        Ok(())
124    }
125
126    async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buf: ClassInstanceRef<Array<i8>>) -> Result<i32> {
127        tracing::debug!("java.io.RandomAccessFile::read({this:?}, {buf:?})");
128        if buf.is_null() {
129            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
130        }
131
132        let length = jvm.array_length(&buf).await?;
133        let read = jvm
134            .invoke_virtual(&this, "java/io/RandomAccessFile", "read", "([BII)I", (buf, 0, length as i32))
135            .await?;
136
137        Ok(read)
138    }
139
140    async fn read_offset_length(
141        jvm: &Jvm,
142        context: &mut RuntimeContext,
143        this: ClassInstanceRef<Self>,
144        mut buf: ClassInstanceRef<Array<i8>>,
145        offset: i32,
146        length: i32,
147    ) -> Result<i32> {
148        tracing::debug!("java.io.RandomAccessFile::read({this:?}, {buf:?}, {offset:?}, {length:?})");
149        if buf.is_null() {
150            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
151        }
152
153        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
154        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
155
156        let mut rust_buf = vec![0; length as usize];
157        let Ok(read) = rust_file.read(&mut rust_buf).await else {
158            return Err(jvm.exception("java/io/IOException", "I/O error").await);
159        };
160
161        jvm.array_raw_buffer_mut(&mut buf).await?.write(offset as _, &rust_buf)?;
162
163        Ok(read as i32)
164    }
165
166    async fn write(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buf: ClassInstanceRef<Array<i8>>) -> Result<()> {
167        tracing::debug!("java.io.RandomAccessFile::write({this:?}, {buf:?})");
168        if buf.is_null() {
169            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
170        }
171
172        let length = jvm.array_length(&buf).await?;
173        let _: () = jvm
174            .invoke_virtual(&this, "java/io/RandomAccessFile", "write", "([BII)V", (buf, 0, length as i32))
175            .await?;
176
177        Ok(())
178    }
179
180    async fn write_offset_length(
181        jvm: &Jvm,
182        context: &mut RuntimeContext,
183        this: ClassInstanceRef<Self>,
184        buf: ClassInstanceRef<Array<i8>>,
185        offset: i32,
186        length: i32,
187    ) -> Result<()> {
188        tracing::debug!("java.io.RandomAccessFile::write({this:?}, {buf:?}, {offset:?}, {length:?})");
189        if buf.is_null() {
190            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
191        }
192
193        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
194        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
195
196        let mut rust_buf = vec![0; length as usize];
197        jvm.array_raw_buffer(&buf).await?.read(offset as _, &mut rust_buf)?;
198        let rust_buf = cast_vec(rust_buf);
199        let mut written = 0;
200        while written < rust_buf.len() {
201            match rust_file.write(&rust_buf[written..]).await {
202                Ok(0) | Err(_) => return Err(jvm.exception("java/io/IOException", "I/O error").await),
203                Ok(length) if length > rust_buf.len() - written => return Err(jvm.exception("java/io/IOException", "I/O error").await),
204                Ok(length) => written += length,
205            }
206        }
207
208        Ok(())
209    }
210
211    async fn seek(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, pos: i64) -> Result<()> {
212        tracing::debug!("java.io.RandomAccessFile::seek({this:?}, {pos:?})");
213
214        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
215        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
216
217        if rust_file.seek(pos as _).await.is_err() {
218            return Err(jvm.exception("java/io/IOException", "I/O error").await);
219        }
220
221        Ok(())
222    }
223
224    async fn set_length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, new_length: i64) -> Result<()> {
225        tracing::debug!("java.io.RandomAccessFile::setLength({this:?}, {new_length:?})");
226
227        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
228        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
229
230        if rust_file.set_len(new_length as _).await.is_err() {
231            return Err(jvm.exception("java/io/IOException", "I/O error").await);
232        }
233
234        Ok(())
235    }
236
237    async fn length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
238        tracing::debug!("java.io.RandomAccessFile::length({this:?})");
239
240        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
241        let rust_file = FileDescriptor::file(jvm, context, fd).await?;
242
243        let Ok(metadata) = rust_file.metadata().await else {
244            return Err(jvm.exception("java/io/IOException", "I/O error").await);
245        };
246        let len = metadata.size;
247
248        Ok(len as i64)
249    }
250
251    async fn get_file_pointer(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
252        tracing::debug!("java.io.RandomAccessFile::getFilePointer({this:?})");
253
254        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
255        let rust_file = FileDescriptor::file(jvm, context, fd).await?;
256
257        let Ok(pos) = rust_file.tell().await else {
258            return Err(jvm.exception("java/io/IOException", "I/O error").await);
259        };
260
261        Ok(pos as i64)
262    }
263
264    async fn get_fd(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<File>> {
265        tracing::debug!("java.io.RandomAccessFile::getFD({this:?})");
266
267        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
268
269        Ok(fd)
270    }
271
272    async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
273        tracing::debug!("java.io.RandomAccessFile::close({this:?})");
274
275        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
276        FileDescriptor::close(jvm, context, fd).await?;
277
278        Ok(())
279    }
280}