Skip to main content

rustjava_runtime/classes/java/lang/
long.rs

1use alloc::{format, string::String as RustString, vec};
2
3use jvm::{
4    ClassInstanceRef, JavaChar, JavaError, 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::{Character, Object, String},
13};
14
15// public final class java.lang.Long
16pub struct Long;
17
18impl Long {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/lang/Long",
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>", "(J)V", Self::init, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_string, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new(
29                    "parseLong",
30                    "(Ljava/lang/String;)J",
31                    Self::parse_long,
32                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
33                ),
34                JavaMethodProto::new(
35                    "parseLong",
36                    "(Ljava/lang/String;I)J",
37                    Self::parse_long_radix,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
39                ),
40                JavaMethodProto::new(
41                    "valueOf",
42                    "(J)Ljava/lang/Long;",
43                    Self::value_of,
44                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
45                ),
46                JavaMethodProto::new(
47                    "valueOf",
48                    "(Ljava/lang/String;)Ljava/lang/Long;",
49                    Self::value_of_string,
50                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
51                ),
52                JavaMethodProto::new(
53                    "valueOf",
54                    "(Ljava/lang/String;I)Ljava/lang/Long;",
55                    Self::value_of_string_radix,
56                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
57                ),
58                JavaMethodProto::new(
59                    "decode",
60                    "(Ljava/lang/String;)Ljava/lang/Long;",
61                    Self::decode,
62                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
63                ),
64                JavaMethodProto::new(
65                    "getLong",
66                    "(Ljava/lang/String;)Ljava/lang/Long;",
67                    Self::get_long,
68                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
69                ),
70                JavaMethodProto::new(
71                    "getLong",
72                    "(Ljava/lang/String;J)Ljava/lang/Long;",
73                    Self::get_long_value_default,
74                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
75                ),
76                JavaMethodProto::new(
77                    "getLong",
78                    "(Ljava/lang/String;Ljava/lang/Long;)Ljava/lang/Long;",
79                    Self::get_long_object_default,
80                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
81                ),
82                JavaMethodProto::new("byteValue", "()B", Self::byte_value, MethodAccessFlags::PUBLIC),
83                JavaMethodProto::new("shortValue", "()S", Self::short_value, MethodAccessFlags::PUBLIC),
84                JavaMethodProto::new("intValue", "()I", Self::int_value, MethodAccessFlags::PUBLIC),
85                JavaMethodProto::new("longValue", "()J", Self::long_value, MethodAccessFlags::PUBLIC),
86                JavaMethodProto::new("floatValue", "()F", Self::float_value, MethodAccessFlags::PUBLIC),
87                JavaMethodProto::new("doubleValue", "()D", Self::double_value, MethodAccessFlags::PUBLIC),
88                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
89                JavaMethodProto::new(
90                    "toString",
91                    "(J)Ljava/lang/String;",
92                    Self::to_string_static,
93                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
94                ),
95                JavaMethodProto::new(
96                    "toString",
97                    "(JI)Ljava/lang/String;",
98                    Self::to_string_radix,
99                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
100                ),
101                JavaMethodProto::new(
102                    "toBinaryString",
103                    "(J)Ljava/lang/String;",
104                    Self::to_binary_string,
105                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
106                ),
107                JavaMethodProto::new(
108                    "toOctalString",
109                    "(J)Ljava/lang/String;",
110                    Self::to_octal_string,
111                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
112                ),
113                JavaMethodProto::new(
114                    "toHexString",
115                    "(J)Ljava/lang/String;",
116                    Self::to_hex_string,
117                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
118                ),
119                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
120                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
121                JavaMethodProto::new("compareTo", "(Ljava/lang/Long;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
122                JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to_object, MethodAccessFlags::PUBLIC),
123            ],
124            fields: vec![
125                JavaFieldProto::new(
126                    "MIN_VALUE",
127                    "J",
128                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
129                ),
130                JavaFieldProto::new(
131                    "MAX_VALUE",
132                    "J",
133                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
134                ),
135                JavaFieldProto::new(
136                    "TYPE",
137                    "Ljava/lang/Class;",
138                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
139                ),
140                JavaFieldProto::new("value", "J", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
141            ],
142            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
143        }
144    }
145
146    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
147        jvm.put_static_field("java/lang/Long", "MIN_VALUE", "J", i64::MIN).await?;
148        jvm.put_static_field("java/lang/Long", "MAX_VALUE", "J", i64::MAX).await?;
149        jvm.put_static_field(
150            "java/lang/Long",
151            "TYPE",
152            "Ljava/lang/Class;",
153            JavaLangClass::from_rust_primitive(jvm, "long").await?,
154        )
155        .await
156    }
157    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i64) -> Result<()> {
158        let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
159        jvm.put_field(&mut this, "java/lang/Long", "value", "J", value).await
160    }
161    async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
162        let value: i64 = jvm
163            .invoke_static("java/lang/Long", "parseLong", "(Ljava/lang/String;)J", (value,))
164            .await?;
165        let mut this = this;
166        let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
167        jvm.put_field(&mut this, "java/lang/Long", "value", "J", value).await
168    }
169    fn parse_raw(value: &str, radix: u32) -> Option<i64> {
170        if !(2..=36).contains(&radix) || value.is_empty() {
171            return None;
172        }
173        let negative = value.starts_with('-');
174        let body = value.strip_prefix('-').or_else(|| value.strip_prefix('+')).unwrap_or(value);
175        if body.is_empty() {
176            return None;
177        }
178        let limit = if negative { i128::from(i64::MIN) } else { -i128::from(i64::MAX) };
179        let mut result = 0i128;
180        for value in body.chars() {
181            let value = JavaChar::try_from(u32::from(value)).ok()?;
182            let digit = i128::from(Character::digit_value(value, radix as i32));
183            if digit < 0 {
184                return None;
185            }
186            if result < (limit + digit) / i128::from(radix) {
187                return None;
188            }
189            result = result * i128::from(radix) - digit;
190        }
191        if !negative && result == i128::from(i64::MIN) {
192            return None;
193        }
194        Some(if negative { result as i64 } else { -result as i64 })
195    }
196    async fn parse_long(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<i64> {
197        if value.is_null() {
198            return Err(jvm.exception("java/lang/NumberFormatException", "null").await);
199        }
200        let value = JavaLangString::to_rust_string(jvm, &value).await?;
201        match Self::parse_raw(&value, 10) {
202            Some(value) => Ok(value),
203            None => Err(jvm
204                .exception("java/lang/NumberFormatException", &format!("For input string: \"{value}\""))
205                .await),
206        }
207    }
208    async fn parse_long_radix(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>, radix: i32) -> Result<i64> {
209        if value.is_null() {
210            return Err(jvm.exception("java/lang/NumberFormatException", "null").await);
211        }
212        let value = JavaLangString::to_rust_string(jvm, &value).await?;
213        match Self::parse_raw(&value, radix as u32) {
214            Some(value) => Ok(value),
215            None => Err(jvm
216                .exception("java/lang/NumberFormatException", &format!("For input string: \"{value}\""))
217                .await),
218        }
219    }
220    async fn value_of_string(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
221        let value: i64 = jvm
222            .invoke_static("java/lang/Long", "parseLong", "(Ljava/lang/String;)J", (value,))
223            .await?;
224        Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
225    }
226
227    async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<Self>> {
228        Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
229    }
230    async fn value_of_string_radix(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>, radix: i32) -> Result<ClassInstanceRef<Self>> {
231        let value: i64 = jvm
232            .invoke_static("java/lang/Long", "parseLong", "(Ljava/lang/String;I)J", (value, radix))
233            .await?;
234        Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
235    }
236    async fn decode(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
237        if value.is_null() {
238            return Err(jvm.exception("java/lang/NumberFormatException", "null").await);
239        }
240        let value = JavaLangString::to_rust_string(jvm, &value).await?;
241        let (sign, body) = if let Some(body) = value.strip_prefix('-') {
242            ("-", body)
243        } else if let Some(body) = value.strip_prefix('+') {
244            ("+", body)
245        } else {
246            ("", value.as_str())
247        };
248        let (radix, body) = if let Some(body) = body
249            .strip_prefix("0x")
250            .or_else(|| body.strip_prefix("0X"))
251            .or_else(|| body.strip_prefix('#'))
252        {
253            (16, body)
254        } else if body.starts_with('0') && body.len() > 1 {
255            (8, &body[1..])
256        } else {
257            (10, body)
258        };
259        if body.starts_with('-') || body.starts_with('+') {
260            return Err(jvm.exception("java/lang/NumberFormatException", "Sign character in wrong position").await);
261        }
262        let mut signed = RustString::from(sign);
263        signed.push_str(body);
264        let value = match Self::parse_raw(&signed, radix) {
265            Some(value) => value,
266            None => return Err(jvm.exception("java/lang/NumberFormatException", "invalid long").await),
267        };
268        Ok(jvm.new_class("java/lang/Long", "(J)V", (value,)).await?.into())
269    }
270    async fn get_long(jvm: &Jvm, _: &mut RuntimeContext, key: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
271        let default: ClassInstanceRef<Self> = None.into();
272        jvm.invoke_static(
273            "java/lang/Long",
274            "getLong",
275            "(Ljava/lang/String;Ljava/lang/Long;)Ljava/lang/Long;",
276            (key, default),
277        )
278        .await
279    }
280    async fn get_long_value_default(
281        jvm: &Jvm,
282        _: &mut RuntimeContext,
283        key: ClassInstanceRef<String>,
284        default: i64,
285    ) -> Result<ClassInstanceRef<Self>> {
286        let default = jvm.new_class("java/lang/Long", "(J)V", (default,)).await?;
287        jvm.invoke_static(
288            "java/lang/Long",
289            "getLong",
290            "(Ljava/lang/String;Ljava/lang/Long;)Ljava/lang/Long;",
291            (key, default),
292        )
293        .await
294    }
295    async fn get_long_object_default(
296        jvm: &Jvm,
297        _: &mut RuntimeContext,
298        key: ClassInstanceRef<String>,
299        default: ClassInstanceRef<Self>,
300    ) -> Result<ClassInstanceRef<Self>> {
301        if key.is_null() {
302            return Ok(default);
303        }
304        let value: ClassInstanceRef<String> = jvm
305            .invoke_static("java/lang/System", "getProperty", "(Ljava/lang/String;)Ljava/lang/String;", (key,))
306            .await?;
307        if value.is_null() {
308            return Ok(default);
309        }
310        match jvm
311            .invoke_static("java/lang/Long", "decode", "(Ljava/lang/String;)Ljava/lang/Long;", (value,))
312            .await
313        {
314            Ok(value) => Ok(value),
315            Err(JavaError::JavaException(exception)) if jvm.is_instance(&*exception, "java/lang/NumberFormatException") => Ok(default),
316            Err(error) => Err(error),
317        }
318    }
319    async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i8> {
320        Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as i8)
321    }
322    async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i16> {
323        Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as i16)
324    }
325    async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
326        Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as i32)
327    }
328    async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
329        jvm.get_field(&this, "java/lang/Long", "value", "J").await
330    }
331    async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
332        Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as f32)
333    }
334    async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
335        Ok(jvm.get_field::<i64>(&this, "java/lang/Long", "value", "J").await? as f64)
336    }
337    fn format_value(value: i64, radix: u32) -> RustString {
338        let radix = if (2..=36).contains(&radix) { radix } else { 10 };
339        if value == 0 {
340            return "0".into();
341        }
342        let negative = value < 0;
343        let mut magnitude = value.unsigned_abs();
344        let mut result = RustString::new();
345        while magnitude != 0 {
346            result.push(char::from_digit((magnitude % u64::from(radix)) as u32, radix).unwrap_or('0'));
347            magnitude /= u64::from(radix);
348        }
349        if negative {
350            result.push('-');
351        }
352        result.chars().rev().collect()
353    }
354    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
355        let value: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
356        Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value, 10)).await?.into())
357    }
358    async fn to_string_static(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
359        Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value, 10)).await?.into())
360    }
361    async fn to_string_radix(jvm: &Jvm, _: &mut RuntimeContext, value: i64, radix: i32) -> Result<ClassInstanceRef<String>> {
362        Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value, radix as u32))
363            .await?
364            .into())
365    }
366    async fn to_binary_string(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
367        let text = if value < 0 {
368            format!("{:064b}", value as u64)
369        } else {
370            Self::format_value(value, 2)
371        };
372        Ok(JavaLangString::from_rust_string(jvm, &text).await?.into())
373    }
374    async fn to_octal_string(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
375        let text = if value < 0 {
376            format!("{:022o}", value as u64)
377        } else {
378            Self::format_value(value, 8)
379        };
380        Ok(JavaLangString::from_rust_string(jvm, &text).await?.into())
381    }
382    async fn to_hex_string(jvm: &Jvm, _: &mut RuntimeContext, value: i64) -> Result<ClassInstanceRef<String>> {
383        let text = if value < 0 {
384            format!("{:016x}", value as u64)
385        } else {
386            Self::format_value(value, 16)
387        };
388        Ok(JavaLangString::from_rust_string(jvm, &text).await?.into())
389    }
390    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
391        let value: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
392        Ok((value ^ (value >> 32)) as i32)
393    }
394    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
395        if other.is_null() || !jvm.is_instance(&**other, "java/lang/Long") {
396            return Ok(false);
397        }
398        Ok(jvm.invoke_virtual::<_, i64>(&this, "java/lang/Long", "longValue", "()J", ()).await?
399            == jvm.invoke_virtual::<_, i64>(&other, "java/lang/Long", "longValue", "()J", ()).await?)
400    }
401    async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
402        if other.is_null() {
403            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
404        }
405        let left: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
406        let right: i64 = jvm.invoke_virtual(&other, "java/lang/Long", "longValue", "()J", ()).await?;
407        Ok(left.cmp(&right) as i32)
408    }
409    async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
410        if other.is_null() {
411            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
412        }
413        if !jvm.is_instance(&**other, "java/lang/Long") {
414            return Err(jvm.exception("java/lang/ClassCastException", "not Long").await);
415        }
416        let other = ClassInstanceRef::<Self>::from(other.instance);
417        let left: i64 = jvm.invoke_virtual(&this, "java/lang/Long", "longValue", "()J", ()).await?;
418        let right: i64 = jvm.invoke_virtual(&other, "java/lang/Long", "longValue", "()J", ()).await?;
419        Ok(left.cmp(&right) as i32)
420    }
421}