Skip to main content

rustjava_runtime/classes/java/lang/
byte.rs

1use alloc::{format, vec};
2
3use jvm::{
4    ClassInstanceRef, Jvm, Result,
5    runtime::{JavaLangClass, JavaLangString},
6};
7use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
8use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
9
10use crate::{
11    RuntimeClassProto, RuntimeContext,
12    classes::java::lang::{Object, String},
13};
14
15// public final class java.lang.Byte
16pub struct Byte;
17
18impl Byte {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/lang/Byte",
22            parent_class: Some("java/lang/Number"),
23            interfaces: vec!["java/lang/Comparable"],
24            methods: vec![
25                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
26                JavaMethodProto::new("<init>", "(B)V", Self::init, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_string, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new(
29                    "parseByte",
30                    "(Ljava/lang/String;)B",
31                    Self::parse_byte,
32                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
33                ),
34                JavaMethodProto::new(
35                    "parseByte",
36                    "(Ljava/lang/String;I)B",
37                    Self::parse_byte_radix,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
39                ),
40                JavaMethodProto::new(
41                    "valueOf",
42                    "(B)Ljava/lang/Byte;",
43                    Self::value_of,
44                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
45                ),
46                JavaMethodProto::new(
47                    "valueOf",
48                    "(Ljava/lang/String;)Ljava/lang/Byte;",
49                    Self::value_of_string,
50                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
51                ),
52                JavaMethodProto::new(
53                    "valueOf",
54                    "(Ljava/lang/String;I)Ljava/lang/Byte;",
55                    Self::value_of_string_radix,
56                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
57                ),
58                JavaMethodProto::new(
59                    "decode",
60                    "(Ljava/lang/String;)Ljava/lang/Byte;",
61                    Self::decode,
62                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
63                ),
64                JavaMethodProto::new("byteValue", "()B", Self::byte_value, MethodAccessFlags::PUBLIC),
65                JavaMethodProto::new("shortValue", "()S", Self::short_value, MethodAccessFlags::PUBLIC),
66                JavaMethodProto::new("intValue", "()I", Self::int_value, MethodAccessFlags::PUBLIC),
67                JavaMethodProto::new("longValue", "()J", Self::long_value, MethodAccessFlags::PUBLIC),
68                JavaMethodProto::new("floatValue", "()F", Self::float_value, MethodAccessFlags::PUBLIC),
69                JavaMethodProto::new("doubleValue", "()D", Self::double_value, MethodAccessFlags::PUBLIC),
70                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
71                JavaMethodProto::new(
72                    "toString",
73                    "(B)Ljava/lang/String;",
74                    Self::to_string_static,
75                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
76                ),
77                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
78                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
79                JavaMethodProto::new("compareTo", "(Ljava/lang/Byte;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
80                JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to_object, MethodAccessFlags::PUBLIC),
81            ],
82            fields: vec![
83                JavaFieldProto::new(
84                    "MIN_VALUE",
85                    "B",
86                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
87                ),
88                JavaFieldProto::new(
89                    "MAX_VALUE",
90                    "B",
91                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
92                ),
93                JavaFieldProto::new(
94                    "TYPE",
95                    "Ljava/lang/Class;",
96                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
97                ),
98                JavaFieldProto::new("value", "B", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
99            ],
100            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
101        }
102    }
103
104    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
105        jvm.put_static_field("java/lang/Byte", "MIN_VALUE", "B", i8::MIN).await?;
106        jvm.put_static_field("java/lang/Byte", "MAX_VALUE", "B", i8::MAX).await?;
107        jvm.put_static_field(
108            "java/lang/Byte",
109            "TYPE",
110            "Ljava/lang/Class;",
111            JavaLangClass::from_rust_primitive(jvm, "byte").await?,
112        )
113        .await
114    }
115
116    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i8) -> Result<()> {
117        let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
118        jvm.put_field(&mut this, "value", "B", value).await
119    }
120
121    async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
122        let value: i8 = jvm
123            .invoke_static("java/lang/Byte", "parseByte", "(Ljava/lang/String;)B", (value,))
124            .await?;
125        let mut this = this;
126        let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
127        jvm.put_field(&mut this, "value", "B", value).await
128    }
129
130    async fn parse_byte(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<i8> {
131        let parsed: i32 = jvm
132            .invoke_static("java/lang/Integer", "parseInt", "(Ljava/lang/String;)I", (value,))
133            .await?;
134        if !(i32::from(i8::MIN)..=i32::from(i8::MAX)).contains(&parsed) {
135            return Err(jvm.exception("java/lang/NumberFormatException", "Value out of range").await);
136        }
137        Ok(parsed as i8)
138    }
139
140    async fn parse_byte_radix(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>, radix: i32) -> Result<i8> {
141        let parsed: i32 = jvm
142            .invoke_static("java/lang/Integer", "parseInt", "(Ljava/lang/String;I)I", (value, radix))
143            .await?;
144        if !(i32::from(i8::MIN)..=i32::from(i8::MAX)).contains(&parsed) {
145            return Err(jvm.exception("java/lang/NumberFormatException", "Value out of range").await);
146        }
147        Ok(parsed as i8)
148    }
149
150    async fn value_of_string(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
151        let value: i8 = jvm
152            .invoke_static("java/lang/Byte", "parseByte", "(Ljava/lang/String;)B", (value,))
153            .await?;
154        Ok(jvm.new_class("java/lang/Byte", "(B)V", (value,)).await?.into())
155    }
156
157    async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: i8) -> Result<ClassInstanceRef<Self>> {
158        Ok(jvm.new_class("java/lang/Byte", "(B)V", (value,)).await?.into())
159    }
160
161    async fn value_of_string_radix(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>, radix: i32) -> Result<ClassInstanceRef<Self>> {
162        let value: i8 = jvm
163            .invoke_static("java/lang/Byte", "parseByte", "(Ljava/lang/String;I)B", (value, radix))
164            .await?;
165        Ok(jvm.new_class("java/lang/Byte", "(B)V", (value,)).await?.into())
166    }
167
168    async fn decode(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
169        let integer = jvm
170            .invoke_static("java/lang/Integer", "decode", "(Ljava/lang/String;)Ljava/lang/Integer;", (value,))
171            .await?;
172        let value: i32 = jvm.invoke_virtual(&integer, "java/lang/Integer", "intValue", "()I", ()).await?;
173        if !(i32::from(i8::MIN)..=i32::from(i8::MAX)).contains(&value) {
174            return Err(jvm.exception("java/lang/NumberFormatException", "Value out of range").await);
175        }
176        Ok(jvm.new_class("java/lang/Byte", "(B)V", (value as i8,)).await?.into())
177    }
178
179    async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i8> {
180        jvm.get_field(&this, "value", "B").await
181    }
182
183    async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i16> {
184        let value: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
185        Ok(value as i16)
186    }
187
188    async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
189        let value: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
190        Ok(value as i32)
191    }
192
193    async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
194        let value: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
195        Ok(value as i64)
196    }
197
198    async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
199        let value: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
200        Ok(value as f32)
201    }
202
203    async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
204        let value: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
205        Ok(value as f64)
206    }
207
208    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
209        let value: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
210        Ok(JavaLangString::from_rust_string(jvm, &format!("{value}")).await?.into())
211    }
212
213    async fn to_string_static(jvm: &Jvm, _: &mut RuntimeContext, value: i8) -> Result<ClassInstanceRef<String>> {
214        Ok(JavaLangString::from_rust_string(jvm, &format!("{value}")).await?.into())
215    }
216
217    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
218        let value: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
219        Ok(value as i32)
220    }
221
222    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
223        if other.is_null() || !jvm.is_instance(&**other, "java/lang/Byte") {
224            return Ok(false);
225        }
226        let left: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
227        let right: i8 = jvm.invoke_virtual(&other, "java/lang/Byte", "byteValue", "()B", ()).await?;
228        Ok(left == right)
229    }
230
231    async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
232        if other.is_null() {
233            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
234        }
235        let left: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
236        let right: i8 = jvm.invoke_virtual(&other, "java/lang/Byte", "byteValue", "()B", ()).await?;
237        Ok(left.cmp(&right) as i32)
238    }
239
240    async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
241        if other.is_null() {
242            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
243        }
244        if !jvm.is_instance(&**other, "java/lang/Byte") {
245            return Err(jvm.exception("java/lang/ClassCastException", "not Byte").await);
246        }
247        let other = ClassInstanceRef::<Self>::from(other.instance);
248        let left: i8 = jvm.invoke_virtual(&this, "java/lang/Byte", "byteValue", "()B", ()).await?;
249        let right: i8 = jvm.invoke_virtual(&other, "java/lang/Byte", "byteValue", "()B", ()).await?;
250        Ok(left.cmp(&right) as i32)
251    }
252}