Skip to main content

rustjava_runtime/classes/java/lang/
double.rs

1use alloc::{format, string::String as RustString, 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.Double
16pub struct Double;
17
18impl Double {
19    pub fn as_proto() -> RuntimeClassProto {
20        RuntimeClassProto {
21            name: "java/lang/Double",
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>", "(D)V", Self::init, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init_string, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new(
29                    "parseDouble",
30                    "(Ljava/lang/String;)D",
31                    Self::parse_double,
32                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
33                ),
34                JavaMethodProto::new(
35                    "valueOf",
36                    "(D)Ljava/lang/Double;",
37                    Self::value_of,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
39                ),
40                JavaMethodProto::new(
41                    "valueOf",
42                    "(Ljava/lang/String;)Ljava/lang/Double;",
43                    Self::value_of_string,
44                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
45                ),
46                JavaMethodProto::new("byteValue", "()B", Self::byte_value, MethodAccessFlags::PUBLIC),
47                JavaMethodProto::new("shortValue", "()S", Self::short_value, MethodAccessFlags::PUBLIC),
48                JavaMethodProto::new("intValue", "()I", Self::int_value, MethodAccessFlags::PUBLIC),
49                JavaMethodProto::new("longValue", "()J", Self::long_value, MethodAccessFlags::PUBLIC),
50                JavaMethodProto::new("floatValue", "()F", Self::float_value, MethodAccessFlags::PUBLIC),
51                JavaMethodProto::new("doubleValue", "()D", Self::double_value, MethodAccessFlags::PUBLIC),
52                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
53                JavaMethodProto::new(
54                    "toString",
55                    "(D)Ljava/lang/String;",
56                    Self::to_string_static,
57                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
58                ),
59                JavaMethodProto::new("isNaN", "()Z", Self::is_nan, MethodAccessFlags::PUBLIC),
60                JavaMethodProto::new(
61                    "isNaN",
62                    "(D)Z",
63                    Self::is_nan_static,
64                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
65                ),
66                JavaMethodProto::new("isInfinite", "()Z", Self::is_infinite, MethodAccessFlags::PUBLIC),
67                JavaMethodProto::new(
68                    "isInfinite",
69                    "(D)Z",
70                    Self::is_infinite_static,
71                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
72                ),
73                JavaMethodProto::new(
74                    "doubleToLongBits",
75                    "(D)J",
76                    Self::double_to_long_bits,
77                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
78                ),
79                JavaMethodProto::new(
80                    "longBitsToDouble",
81                    "(J)D",
82                    Self::long_bits_to_double,
83                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
84                ),
85                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
86                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
87                JavaMethodProto::new("compareTo", "(Ljava/lang/Double;)I", Self::compare_to, MethodAccessFlags::PUBLIC),
88                JavaMethodProto::new("compareTo", "(Ljava/lang/Object;)I", Self::compare_to_object, MethodAccessFlags::PUBLIC),
89            ],
90            fields: vec![
91                JavaFieldProto::new(
92                    "POSITIVE_INFINITY",
93                    "D",
94                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
95                ),
96                JavaFieldProto::new(
97                    "NEGATIVE_INFINITY",
98                    "D",
99                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
100                ),
101                JavaFieldProto::new("NaN", "D", FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL),
102                JavaFieldProto::new(
103                    "MAX_VALUE",
104                    "D",
105                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
106                ),
107                JavaFieldProto::new(
108                    "MIN_VALUE",
109                    "D",
110                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
111                ),
112                JavaFieldProto::new(
113                    "TYPE",
114                    "Ljava/lang/Class;",
115                    FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL,
116                ),
117                JavaFieldProto::new("value", "D", FieldAccessFlags::PRIVATE | FieldAccessFlags::FINAL),
118            ],
119            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
120        }
121    }
122
123    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
124        jvm.put_static_field("java/lang/Double", "POSITIVE_INFINITY", "D", f64::INFINITY).await?;
125        jvm.put_static_field("java/lang/Double", "NEGATIVE_INFINITY", "D", f64::NEG_INFINITY)
126            .await?;
127        jvm.put_static_field("java/lang/Double", "NaN", "D", f64::NAN).await?;
128        jvm.put_static_field("java/lang/Double", "MAX_VALUE", "D", f64::MAX).await?;
129        jvm.put_static_field("java/lang/Double", "MIN_VALUE", "D", f64::from_bits(1)).await?;
130        jvm.put_static_field(
131            "java/lang/Double",
132            "TYPE",
133            "Ljava/lang/Class;",
134            JavaLangClass::from_rust_primitive(jvm, "double").await?,
135        )
136        .await
137    }
138
139    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
140        let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
141        jvm.put_field(&mut this, "java/lang/Double", "value", "D", value).await
142    }
143
144    async fn init_string(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: ClassInstanceRef<String>) -> Result<()> {
145        if value.is_null() {
146            return Err(jvm.exception("java/lang/NullPointerException", "value").await);
147        }
148        let value = JavaLangString::to_rust_string(jvm, &value).await?;
149        let value = Self::parse_value(jvm, &value).await?;
150        let _: () = jvm.invoke_special(&this, "java/lang/Number", "<init>", "()V", ()).await?;
151        jvm.put_field(&mut this, "java/lang/Double", "value", "D", value).await
152    }
153
154    async fn parse_value(jvm: &Jvm, value: &str) -> Result<f64> {
155        let trimmed = value.trim_matches(|character| character <= '\u{0020}');
156        let parsed = match trimmed {
157            "NaN" | "+NaN" | "-NaN" => Some(f64::NAN),
158            "Infinity" | "+Infinity" => Some(f64::INFINITY),
159            "-Infinity" => Some(f64::NEG_INFINITY),
160            _ => {
161                let number = match trimmed.as_bytes().last() {
162                    Some(b'f' | b'F' | b'd' | b'D') => &trimmed[..trimmed.len() - 1],
163                    _ => trimmed,
164                };
165                let bytes = number.as_bytes();
166                let mut index = 0;
167                if matches!(bytes.first(), Some(b'+' | b'-')) {
168                    index += 1;
169                }
170
171                let mut digits = 0;
172                while index < bytes.len() && bytes[index].is_ascii_digit() {
173                    index += 1;
174                    digits += 1;
175                }
176                if index < bytes.len() && bytes[index] == b'.' {
177                    index += 1;
178                    while index < bytes.len() && bytes[index].is_ascii_digit() {
179                        index += 1;
180                        digits += 1;
181                    }
182                }
183
184                if digits == 0 {
185                    None
186                } else {
187                    if index < bytes.len() && matches!(bytes[index], b'e' | b'E') {
188                        index += 1;
189                        if index < bytes.len() && matches!(bytes[index], b'+' | b'-') {
190                            index += 1;
191                        }
192                        let exponent_start = index;
193                        while index < bytes.len() && bytes[index].is_ascii_digit() {
194                            index += 1;
195                        }
196                        if exponent_start == index {
197                            index = bytes.len() + 1;
198                        }
199                    }
200                    if index == bytes.len() { number.parse::<f64>().ok() } else { None }
201                }
202            }
203        };
204
205        match parsed {
206            Some(value) => Ok(value),
207            None => Err(jvm
208                .exception("java/lang/NumberFormatException", &format!("For input string: \"{value}\""))
209                .await),
210        }
211    }
212
213    async fn parse_double(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<f64> {
214        if value.is_null() {
215            return Err(jvm.exception("java/lang/NullPointerException", "value").await);
216        }
217        let value = JavaLangString::to_rust_string(jvm, &value).await?;
218        Self::parse_value(jvm, &value).await
219    }
220
221    async fn value_of_string(jvm: &Jvm, _: &mut RuntimeContext, value: ClassInstanceRef<String>) -> Result<ClassInstanceRef<Self>> {
222        if value.is_null() {
223            return Err(jvm.exception("java/lang/NullPointerException", "value").await);
224        }
225        let value = JavaLangString::to_rust_string(jvm, &value).await?;
226        let value = Self::parse_value(jvm, &value).await?;
227        Ok(jvm.new_class("java/lang/Double", "(D)V", (value,)).await?.into())
228    }
229
230    async fn value_of(jvm: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<ClassInstanceRef<Self>> {
231        Ok(jvm.new_class("java/lang/Double", "(D)V", (value,)).await?.into())
232    }
233
234    async fn byte_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i8> {
235        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
236        Ok((value as i32) as i8)
237    }
238
239    async fn short_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i16> {
240        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
241        Ok((value as i32) as i16)
242    }
243
244    async fn int_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
245        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
246        Ok(value as i32)
247    }
248
249    async fn long_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
250        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
251        Ok(value as i64)
252    }
253
254    async fn float_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
255        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
256        Ok(value as f32)
257    }
258
259    async fn double_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
260        jvm.get_field(&this, "java/lang/Double", "value", "D").await
261    }
262
263    fn format_value(value: f64) -> RustString {
264        if value.is_nan() {
265            return "NaN".into();
266        }
267        if value == f64::INFINITY {
268            return "Infinity".into();
269        }
270        if value == f64::NEG_INFINITY {
271            return "-Infinity".into();
272        }
273        if value.to_bits() == 1 {
274            return "4.9E-324".into();
275        }
276        if value.to_bits() == 0x8000_0000_0000_0001 {
277            return "-4.9E-324".into();
278        }
279
280        let magnitude = value.abs();
281        let mut result = if value != 0.0 && !(0.001..10_000_000.0).contains(&magnitude) {
282            format!("{value:e}")
283        } else {
284            format!("{value}")
285        };
286        if let Some(exponent_index) = result.find('e') {
287            let exponent = result.split_off(exponent_index + 1);
288            result.pop();
289            if !result.contains('.') {
290                result.push_str(".0");
291            }
292            result.push('E');
293            result.push_str(exponent.strip_prefix('+').unwrap_or(&exponent));
294        } else if !result.contains('.') {
295            result.push_str(".0");
296        }
297        result
298    }
299
300    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
301        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
302        Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value)).await?.into())
303    }
304
305    async fn to_string_static(jvm: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<ClassInstanceRef<String>> {
306        Ok(JavaLangString::from_rust_string(jvm, &Self::format_value(value)).await?.into())
307    }
308
309    async fn is_nan(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
310        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
311        Ok(value.is_nan())
312    }
313
314    async fn is_nan_static(_: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<bool> {
315        Ok(value.is_nan())
316    }
317
318    async fn is_infinite(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
319        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
320        Ok(value.is_infinite())
321    }
322
323    async fn is_infinite_static(_: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<bool> {
324        Ok(value.is_infinite())
325    }
326
327    async fn double_to_long_bits(_: &Jvm, _: &mut RuntimeContext, value: f64) -> Result<i64> {
328        Ok(if value.is_nan() { 0x7ff8_0000_0000_0000 } else { value.to_bits() as i64 })
329    }
330
331    async fn long_bits_to_double(_: &Jvm, _: &mut RuntimeContext, bits: i64) -> Result<f64> {
332        Ok(f64::from_bits(bits as u64))
333    }
334
335    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
336        let value: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
337        let bits = if value.is_nan() { 0x7ff8_0000_0000_0000 } else { value.to_bits() };
338        Ok((bits ^ (bits >> 32)) as i32)
339    }
340
341    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
342        if other.is_null() || !jvm.is_instance(&**other, "java/lang/Double") {
343            return Ok(false);
344        }
345        let left: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
346        let right: f64 = jvm.invoke_virtual(&other, "java/lang/Double", "doubleValue", "()D", ()).await?;
347        let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() as i64 };
348        let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() as i64 };
349        Ok(left_bits == right_bits)
350    }
351
352    async fn compare_to(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Self>) -> Result<i32> {
353        if other.is_null() {
354            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
355        }
356        let left: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
357        let right: f64 = jvm.invoke_virtual(&other, "java/lang/Double", "doubleValue", "()D", ()).await?;
358        if left < right {
359            return Ok(-1);
360        }
361        if left > right {
362            return Ok(1);
363        }
364        let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() as i64 };
365        let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() as i64 };
366        Ok(left_bits.cmp(&right_bits) as i32)
367    }
368
369    async fn compare_to_object(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<i32> {
370        if other.is_null() {
371            return Err(jvm.exception("java/lang/NullPointerException", "other").await);
372        }
373        if !jvm.is_instance(&**other, "java/lang/Double") {
374            return Err(jvm.exception("java/lang/ClassCastException", "not Double").await);
375        }
376        let other = ClassInstanceRef::<Self>::from(other.instance);
377        let left: f64 = jvm.invoke_virtual(&this, "java/lang/Double", "doubleValue", "()D", ()).await?;
378        let right: f64 = jvm.invoke_virtual(&other, "java/lang/Double", "doubleValue", "()D", ()).await?;
379        if left < right {
380            return Ok(-1);
381        }
382        if left > right {
383            return Ok(1);
384        }
385        let left_bits = if left.is_nan() { 0x7ff8_0000_0000_0000 } else { left.to_bits() as i64 };
386        let right_bits = if right.is_nan() { 0x7ff8_0000_0000_0000 } else { right.to_bits() as i64 };
387        Ok(left_bits.cmp(&right_bits) as i32)
388    }
389}