Skip to main content

rustjava_runtime/classes/java/lang/
enum.rs

1use alloc::{format, vec};
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangClass};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::lang::{Class, Object, String},
10};
11
12// public abstract class java.lang.Enum
13pub struct Enum;
14
15impl Enum {
16    pub fn as_proto() -> RuntimeClassProto {
17        RuntimeClassProto {
18            name: "java/lang/Enum",
19            parent_class: Some("java/lang/Object"),
20            interfaces: vec!["java/lang/Comparable", "java/io/Serializable"],
21            methods: vec![
22                JavaMethodProto::new("<init>", "(Ljava/lang/String;I)V", Self::init, MethodAccessFlags::PROTECTED),
23                JavaMethodProto::new(
24                    "name",
25                    "()Ljava/lang/String;",
26                    Self::name,
27                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
28                ),
29                JavaMethodProto::new("ordinal", "()I", Self::ordinal, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
30                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
31                JavaMethodProto::new(
32                    "equals",
33                    "(Ljava/lang/Object;)Z",
34                    Self::equals,
35                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
36                ),
37                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
38                JavaMethodProto::new(
39                    "clone",
40                    "()Ljava/lang/Object;",
41                    Self::clone,
42                    MethodAccessFlags::PROTECTED | MethodAccessFlags::FINAL,
43                ),
44                JavaMethodProto::new(
45                    "compareTo",
46                    "(Ljava/lang/Enum;)I",
47                    Self::compare_to,
48                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
49                ),
50                JavaMethodProto::new(
51                    "compareTo",
52                    "(Ljava/lang/Object;)I",
53                    Self::compare_to_object,
54                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
55                ),
56                JavaMethodProto::new(
57                    "getDeclaringClass",
58                    "()Ljava/lang/Class;",
59                    Self::get_declaring_class,
60                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
61                ),
62                JavaMethodProto::new(
63                    "valueOf",
64                    "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;",
65                    Self::value_of,
66                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
67                ),
68                JavaMethodProto::new("finalize", "()V", Self::finalize, MethodAccessFlags::PROTECTED | MethodAccessFlags::FINAL),
69            ],
70            fields: vec![
71                JavaFieldProto::new("name", "Ljava/lang/String;", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
72                JavaFieldProto::new("ordinal", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
73            ],
74            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
75        }
76    }
77
78    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, name: ClassInstanceRef<String>, ordinal: i32) -> Result<()> {
79        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
80        jvm.put_field(&mut this, "name", "Ljava/lang/String;", name).await?;
81        jvm.put_field(&mut this, "ordinal", "I", ordinal).await
82    }
83
84    async fn name(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
85        jvm.get_field(&this, "name", "Ljava/lang/String;").await
86    }
87
88    async fn ordinal(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
89        jvm.get_field(&this, "ordinal", "I").await
90    }
91
92    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
93        jvm.get_field(&this, "name", "Ljava/lang/String;").await
94    }
95
96    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
97        jvm.invoke_special(&this, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other,))
98            .await
99    }
100
101    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
102        jvm.invoke_special(&this, "java/lang/Object", "hashCode", "()I", ()).await
103    }
104
105    async fn clone(jvm: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
106        Err(jvm
107            .exception("java/lang/CloneNotSupportedException", "enum types may not be cloned")
108            .await)
109    }
110
111    async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
112        if other.is_null() {
113            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
114        }
115        let this_class = this.class_definition();
116        let this_declaring_class = match this_class.super_class_name() {
117            Some(parent) if parent != "java/lang/Enum" => parent.into(),
118            _ => this_class.name(),
119        };
120        let other_class = other.class_definition();
121        let other_declaring_class = match other_class.super_class_name() {
122            Some(parent) if parent != "java/lang/Enum" => parent.into(),
123            _ => other_class.name(),
124        };
125        if this_declaring_class != other_declaring_class {
126            return Err(jvm.exception("java/lang/ClassCastException", "enum types differ").await);
127        }
128        let this_ordinal: i32 = jvm.get_field(&this, "ordinal", "I").await?;
129        let other_ordinal: i32 = jvm.get_field(&other, "ordinal", "I").await?;
130        Ok(this_ordinal - other_ordinal)
131    }
132
133    async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
134        jvm.invoke_virtual(&this, "java/lang/Enum", "compareTo", "(Ljava/lang/Enum;)I", (other,))
135            .await
136    }
137
138    async fn get_declaring_class(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Class>> {
139        let class = this.class_definition();
140        let declaring_class = match class.super_class_name() {
141            Some(parent) if parent != "java/lang/Enum" => parent.into(),
142            _ => class.name(),
143        };
144        Ok(jvm.resolve_class(&declaring_class).await?.java_class().into())
145    }
146
147    async fn value_of(
148        jvm: &Jvm,
149        _: &mut RuntimeContext,
150        enum_type: ClassInstanceRef<Class>,
151        name: ClassInstanceRef<String>,
152    ) -> Result<ClassInstanceRef<Self>> {
153        if enum_type.is_null() || name.is_null() {
154            return Err(jvm.exception("java/lang/NullPointerException", "enumType or name is null").await);
155        }
156
157        let class_name = JavaLangClass::name(jvm, &enum_type).await?;
158        let name = jvm::runtime::JavaLangString::to_rust_string(jvm, &name).await?;
159        let class = JavaLangClass::to_rust_class(jvm, &enum_type).await?;
160        for field in class.fields() {
161            if field.name() == name
162                && field
163                    .access_flags()
164                    .contains(FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::ENUM)
165            {
166                return jvm.get_static_field(&class_name, &field.name(), &field.descriptor()).await;
167            }
168        }
169
170        Err(jvm
171            .exception(
172                "java/lang/IllegalArgumentException",
173                &format!("No enum constant {}.{name}", class_name.replace('/', ".")),
174            )
175            .await)
176    }
177
178    async fn finalize(_: &Jvm, _: &mut RuntimeContext, _: ClassInstanceRef<Self>) -> Result<()> {
179        Ok(())
180    }
181}