Skip to main content

rustjava_runtime/classes/java/util/jar/
jar_file.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        io::{File, InputStream},
11        lang::String,
12        util::{
13            Enumeration,
14            jar::{JarEntry, Manifest},
15            zip::ZipEntry,
16        },
17    },
18};
19
20// class java.util.jar.JarFile
21pub struct JarFile;
22
23impl JarFile {
24    pub fn as_proto() -> RuntimeClassProto {
25        RuntimeClassProto {
26            name: "java/util/jar/JarFile",
27            parent_class: Some("java/util/zip/ZipFile"),
28            interfaces: vec![],
29            methods: vec![
30                JavaMethodProto::new("<init>", "(Ljava/io/File;)V", Self::init, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_with_string, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new(
33                    "getJarEntry",
34                    "(Ljava/lang/String;)Ljava/util/jar/JarEntry;",
35                    Self::get_jar_entry,
36                    MethodAccessFlags::PUBLIC,
37                ),
38                JavaMethodProto::new("entries", "()Ljava/util/Enumeration;", Self::entries, MethodAccessFlags::PUBLIC),
39                JavaMethodProto::new("getManifest", "()Ljava/util/jar/Manifest;", Self::get_manifest, MethodAccessFlags::PUBLIC),
40            ],
41            fields: vec![],
42            access_flags: ClassAccessFlags::PUBLIC,
43        }
44    }
45
46    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, file: ClassInstanceRef<File>) -> Result<()> {
47        tracing::debug!("java.util.jar.JarFile::<init>({this:?}, {file:?})");
48
49        let _: () = jvm
50            .invoke_special(&this, "java/util/zip/ZipFile", "<init>", "(Ljava/io/File;)V", (file,))
51            .await?;
52
53        Ok(())
54    }
55
56    async fn init_with_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, name: ClassInstanceRef<String>) -> Result<()> {
57        tracing::debug!("java.util.jar.JarFile::<init>({this:?}, {name:?})");
58
59        let file = jvm.new_class("java/io/File", "(Ljava/lang/String;)V", (name,)).await?;
60
61        let _: () = jvm
62            .invoke_special(&this, "java/util/jar/JarFile", "<init>", "(Ljava/io/File;)V", (file,))
63            .await?;
64
65        Ok(())
66    }
67
68    async fn get_jar_entry(
69        jvm: &Jvm,
70        _: &mut RuntimeContext,
71        this: ClassInstanceRef<Self>,
72        name: ClassInstanceRef<String>,
73    ) -> Result<ClassInstanceRef<JarEntry>> {
74        tracing::debug!("java.util.jar.JarFile::getJarEntry({this:?}, {name:?})");
75
76        let zip_entry: ClassInstanceRef<ZipEntry> = jvm
77            .invoke_virtual(
78                &this,
79                "java/util/jar/JarFile",
80                "getEntry",
81                "(Ljava/lang/String;)Ljava/util/zip/ZipEntry;",
82                (name,),
83            )
84            .await?;
85
86        if zip_entry.is_null() {
87            return Ok(None.into());
88        }
89
90        let jar_entry = jvm
91            .new_class("java/util/jar/JarEntry", "(Ljava/util/zip/ZipEntry;)V", (zip_entry,))
92            .await?;
93
94        Ok(jar_entry.into())
95    }
96
97    async fn entries(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Enumeration>> {
98        tracing::debug!("java.util.jar.JarFile::entries({this:?})");
99
100        let zip_entries: ClassInstanceRef<Enumeration> = jvm
101            .invoke_special(&this, "java/util/zip/ZipFile", "entries", "()Ljava/util/Enumeration;", ())
102            .await?;
103
104        let entries = jvm
105            .new_class("java/util/jar/JarFile$Entries", "(Ljava/util/zip/ZipFile$Entries;)V", (zip_entries,))
106            .await?;
107
108        Ok(entries.into())
109    }
110
111    async fn get_manifest(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Manifest>> {
112        tracing::debug!("java.util.jar.JarFile::getManifest({this:?})");
113
114        let manifest_name = JavaLangString::from_rust_string(jvm, "META-INF/MANIFEST.MF").await?;
115        let manifest_file: ClassInstanceRef<JarEntry> = jvm
116            .invoke_virtual(
117                &this,
118                "java/util/jar/JarFile",
119                "getJarEntry",
120                "(Ljava/lang/String;)Ljava/util/jar/JarEntry;",
121                (manifest_name,),
122            )
123            .await?;
124
125        let input_stream: ClassInstanceRef<InputStream> = jvm
126            .invoke_virtual(
127                &this,
128                "java/util/jar/JarFile",
129                "getInputStream",
130                "(Ljava/util/zip/ZipEntry;)Ljava/io/InputStream;",
131                (manifest_file,),
132            )
133            .await?;
134
135        let manifest = jvm
136            .new_class("java/util/jar/Manifest", "(Ljava/io/InputStream;)V", (input_stream,))
137            .await?;
138
139        Ok(manifest.into())
140    }
141}