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        if pathname.is_null() {
88            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
89        }
90
91        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
92
93        jvm.put_field(&mut this, "java/io/File", "path", "Ljava/lang/String;", pathname).await?;
94
95        Ok(())
96    }
97
98    async fn get_path(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
99        tracing::debug!("java.io.File::getPath({this:?})");
100
101        jvm.get_field(&this, "java/io/File", "path", "Ljava/lang/String;").await
102    }
103
104    async fn exists(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
105        tracing::debug!("java.io.File::exists({this:?})");
106
107        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
108        let path = JavaLangString::to_rust_string(jvm, &path).await?;
109
110        Ok(context.metadata(&path).await.is_ok())
111    }
112
113    async fn is_directory(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
114        tracing::debug!("java.io.File::isDirectory({this:?})");
115
116        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
117        let path = JavaLangString::to_rust_string(jvm, &path).await?;
118
119        Ok(context.metadata(&path).await.is_ok_and(|x| x.r#type == FileType::Directory))
120    }
121
122    async fn is_file(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
123        tracing::debug!("java.io.File::isFile({this:?})");
124
125        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
126        let path = JavaLangString::to_rust_string(jvm, &path).await?;
127
128        Ok(context.metadata(&path).await.is_ok_and(|x| x.r#type == FileType::File))
129    }
130
131    async fn delete(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
132        tracing::debug!("java.io.File::delete({this:?})");
133
134        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
135        let path = JavaLangString::to_rust_string(jvm, &path).await?;
136
137        Ok(context.unlink(&path).await.is_ok())
138    }
139
140    async fn length(jvm: &Jvm, context: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
141        tracing::debug!("java.io.File::length({this:?})");
142
143        let path = jvm.invoke_virtual(&this, "java/io/File", "getPath", "()Ljava/lang/String;", ()).await?;
144        let path = JavaLangString::to_rust_string(jvm, &path).await?;
145
146        // File.length() is 0 when the file does not exist
147        Ok(context.metadata(&path).await.map_or(0, |x| x.size as _))
148    }
149}