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