Skip to main content

rustjava_runtime/classes/java/io/
file.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{FileType, RuntimeClassProto, RuntimeContext, classes::java::lang::String};
8
9// class java.io.File
10pub struct File;
11
12impl File {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/io/File",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec!["java/io/Serializable"],
18            methods: vec![
19                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
20                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new("getPath", "()Ljava/lang/String;", Self::get_path, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("exists", "()Z", Self::exists, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("isDirectory", "()Z", Self::is_directory, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("isFile", "()Z", Self::is_file, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("delete", "()Z", Self::delete, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("length", "()J", Self::length, MethodAccessFlags::PUBLIC),
27            ],
28            fields: vec![
29                JavaFieldProto::new(
30                    "separatorChar",
31                    "C",
32                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
33                ),
34                JavaFieldProto::new(
35                    "separator",
36                    "Ljava/lang/String;",
37                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
38                ),
39                JavaFieldProto::new(
40                    "pathSeparatorChar",
41                    "C",
42                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
43                ),
44                JavaFieldProto::new(
45                    "pathSeparator",
46                    "Ljava/lang/String;",
47                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
48                ),
49                JavaFieldProto::new("path", "Ljava/lang/String;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
50            ],
51            access_flags: ClassAccessFlags::PUBLIC,
52        }
53    }
54
55    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
56        tracing::debug!("java.io.File::<clinit>()");
57
58        let separator_char = if cfg!(windows) { '\\' } else { '/' };
59        let separator = if cfg!(windows) { "\\" } else { "/" };
60        let path_separator_char = if cfg!(windows) { ';' } else { ':' };
61        let path_separator = if cfg!(windows) { ";" } else { ":" };
62
63        jvm.put_static_field("java/io/File", "separatorChar", "C", separator_char as JavaChar)
64            .await?;
65        jvm.put_static_field(
66            "java/io/File",
67            "separator",
68            "Ljava/lang/String;",
69            JavaLangString::from_rust_string(jvm, separator).await?,
70        )
71        .await?;
72        jvm.put_static_field("java/io/File", "pathSeparatorChar", "C", path_separator_char as JavaChar)
73            .await?;
74        jvm.put_static_field(
75            "java/io/File",
76            "pathSeparator",
77            "Ljava/lang/String;",
78            JavaLangString::from_rust_string(jvm, path_separator).await?,
79        )
80        .await?;
81
82        Ok(())
83    }
84
85    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, pathname: ClassInstanceRef<String>) -> Result<()> {
86        tracing::debug!("java.io.File::<init>({this:?}, {pathname:?})");
87
88        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
89
90        jvm.put_field(&mut this, "java/io/File", "path", "Ljava/lang/String;", pathname).await?;
91
92        Ok(())
93    }
94
95    async fn get_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
96        tracing::debug!("java.io.File::getPath({this:?})");
97
98        jvm.get_field(&this, "java/io/File", "path", "Ljava/lang/String;").await
99    }
100
101    async fn exists(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
102        tracing::debug!("java.io.File::exists({this:?})");
103
104        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
105        let path = JavaLangString::to_rust_string(jvm, &path).await?;
106
107        Ok(context.metadata(&path).await.is_ok())
108    }
109
110    async fn is_directory(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
111        tracing::debug!("java.io.File::isDirectory({this:?})");
112
113        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
114        let path = JavaLangString::to_rust_string(jvm, &path).await?;
115
116        Ok(context.metadata(&path).await.is_ok_and(|x| x.r#type == FileType::Directory))
117    }
118
119    async fn is_file(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
120        tracing::debug!("java.io.File::isFile({this:?})");
121
122        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
123        let path = JavaLangString::to_rust_string(jvm, &path).await?;
124
125        Ok(context.metadata(&path).await.is_ok_and(|x| x.r#type == FileType::File))
126    }
127
128    async fn delete(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
129        tracing::debug!("java.io.File::delete({this:?})");
130
131        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
132        let path = JavaLangString::to_rust_string(jvm, &path).await?;
133
134        Ok(context.unlink(&path).await.is_ok())
135    }
136
137    async fn length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
138        tracing::debug!("java.io.File::length({this:?})");
139
140        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
141        let path = JavaLangString::to_rust_string(jvm, &path).await?;
142
143        // File.length() is 0 when the file does not exist
144        Ok(context.metadata(&path).await.map_or(0, |x| x.size as _))
145    }
146}