Skip to main content

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