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
68        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
69
70        let name = JavaLangString::to_rust_string(jvm, &name).await?;
71        let mode = JavaLangString::to_rust_string(jvm, &mode).await?;
72
73        let write = mode.contains('w');
74
75        let fd_id = context
76            .open(
77                &name,
78                FileOpenOptions {
79                    read: true,
80                    write,
81                    create: write,
82                    ..Default::default()
83                },
84            )
85            .await;
86        if fd_id.is_err() {
87            return Err(jvm.exception("java/io/FileNotFoundException", "File not found").await);
88        }
89        let fd = FileDescriptor::from_fd(jvm, fd_id.unwrap()).await?;
90        jvm.put_field(&mut this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;", fd)
91            .await?;
92
93        Ok(())
94    }
95
96    async fn init_with_file(
97        jvm: &Jvm,
98        _context: &mut RuntimeContext,
99        this: ClassInstanceRef<Self>,
100        file: ClassInstanceRef<File>,
101        mode: ClassInstanceRef<String>,
102    ) -> Result<()> {
103        tracing::debug!("java.io.RandomAccessFile::<init>({this:?}, {file:?}, {mode:?})");
104
105        let name: ClassInstanceRef<String> = jvm.invoke_virtual(&file, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
106
107        let _: () = jvm
108            .invoke_special(
109                &this,
110                "java/io/RandomAccessFile",
111                "<init>",
112                "(Ljava/lang/String;Ljava/lang/String;)V",
113                (name, mode),
114            )
115            .await?;
116
117        Ok(())
118    }
119
120    async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buf: ClassInstanceRef<Array<i8>>) -> Result<i32> {
121        tracing::debug!("java.io.RandomAccessFile::read({this:?}, {buf:?})");
122
123        let length = jvm.array_length(&buf).await?;
124        let read = jvm
125            .invoke_virtual(&this, "java/io/RandomAccessFile", "read", "([BII)I", (buf, 0, length as i32))
126            .await?;
127
128        Ok(read)
129    }
130
131    async fn read_offset_length(
132        jvm: &Jvm,
133        context: &mut RuntimeContext,
134        this: ClassInstanceRef<Self>,
135        mut buf: ClassInstanceRef<Array<i8>>,
136        offset: i32,
137        length: i32,
138    ) -> Result<i32> {
139        tracing::debug!("java.io.RandomAccessFile::read({this:?}, {buf:?}, {offset:?}, {length:?})");
140
141        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
142        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
143
144        let mut rust_buf = vec![0; length as usize];
145        let Ok(read) = rust_file.read(&mut rust_buf).await else {
146            return Err(jvm.exception("java/io/IOException", "I/O error").await);
147        };
148
149        jvm.array_raw_buffer_mut(&mut buf).await?.write(offset as _, &rust_buf)?;
150
151        Ok(read as i32)
152    }
153
154    async fn write(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buf: ClassInstanceRef<Array<i8>>) -> Result<()> {
155        tracing::debug!("java.io.RandomAccessFile::write({this:?}, {buf:?})");
156
157        let length = jvm.array_length(&buf).await?;
158        let _: () = jvm
159            .invoke_virtual(&this, "java/io/RandomAccessFile", "write", "([BII)V", (buf, 0, length as i32))
160            .await?;
161
162        Ok(())
163    }
164
165    async fn write_offset_length(
166        jvm: &Jvm,
167        context: &mut RuntimeContext,
168        this: ClassInstanceRef<Self>,
169        buf: ClassInstanceRef<Array<i8>>,
170        offset: i32,
171        length: i32,
172    ) -> Result<()> {
173        tracing::debug!("java.io.RandomAccessFile::write({this:?}, {buf:?}, {offset:?}, {length:?})");
174
175        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
176        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
177
178        let mut rust_buf = vec![0; length as usize];
179        jvm.array_raw_buffer(&buf).await?.read(offset as _, &mut rust_buf)?;
180        let rust_buf = cast_vec(rust_buf);
181        let mut written = 0;
182        while written < rust_buf.len() {
183            match rust_file.write(&rust_buf[written..]).await {
184                Ok(0) | Err(_) => return Err(jvm.exception("java/io/IOException", "I/O error").await),
185                Ok(length) if length > rust_buf.len() - written => return Err(jvm.exception("java/io/IOException", "I/O error").await),
186                Ok(length) => written += length,
187            }
188        }
189
190        Ok(())
191    }
192
193    async fn seek(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, pos: i64) -> Result<()> {
194        tracing::debug!("java.io.RandomAccessFile::seek({this:?}, {pos:?})");
195
196        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
197        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
198
199        if rust_file.seek(pos as _).await.is_err() {
200            return Err(jvm.exception("java/io/IOException", "I/O error").await);
201        }
202
203        Ok(())
204    }
205
206    async fn set_length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>, new_length: i64) -> Result<()> {
207        tracing::debug!("java.io.RandomAccessFile::setLength({this:?}, {new_length:?})");
208
209        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
210        let mut rust_file = FileDescriptor::file(jvm, context, fd).await?;
211
212        if rust_file.set_len(new_length as _).await.is_err() {
213            return Err(jvm.exception("java/io/IOException", "I/O error").await);
214        }
215
216        Ok(())
217    }
218
219    async fn length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
220        tracing::debug!("java.io.RandomAccessFile::length({this:?})");
221
222        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
223        let rust_file = FileDescriptor::file(jvm, context, fd).await?;
224
225        let Ok(metadata) = rust_file.metadata().await else {
226            return Err(jvm.exception("java/io/IOException", "I/O error").await);
227        };
228        let len = metadata.size;
229
230        Ok(len as i64)
231    }
232
233    async fn get_file_pointer(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
234        tracing::debug!("java.io.RandomAccessFile::getFilePointer({this:?})");
235
236        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
237        let rust_file = FileDescriptor::file(jvm, context, fd).await?;
238
239        let Ok(pos) = rust_file.tell().await else {
240            return Err(jvm.exception("java/io/IOException", "I/O error").await);
241        };
242
243        Ok(pos as i64)
244    }
245
246    async fn get_fd(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<File>> {
247        tracing::debug!("java.io.RandomAccessFile::getFD({this:?})");
248
249        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
250
251        Ok(fd)
252    }
253
254    async fn close(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
255        tracing::debug!("java.io.RandomAccessFile::close({this:?})");
256
257        let fd = jvm.get_field(&this, "java/io/RandomAccessFile", "fd", "Ljava/io/FileDescriptor;").await?;
258        FileDescriptor::close(jvm, context, fd).await?;
259
260        Ok(())
261    }
262}