Skip to main content

rustjava_runtime/classes/java/util/
random.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext};
8
9// class java.util.Random
10pub struct Random;
11
12impl Random {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/Random",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec!["java/io/Serializable"],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
20                JavaMethodProto::new("<init>", "(J)V", Self::init_with_seed, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new("next", "(I)I", Self::next, MethodAccessFlags::PROTECTED | MethodAccessFlags::SYNCHRONIZED),
22                JavaMethodProto::new("nextBoolean", "()Z", Self::next_boolean, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new("nextBytes", "([B)V", Self::next_bytes, MethodAccessFlags::PUBLIC),
24                JavaMethodProto::new("nextInt", "()I", Self::next_int, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("nextInt", "(I)I", Self::next_int_with_bound, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("nextLong", "()J", Self::next_long, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("nextFloat", "()F", Self::next_float, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("nextDouble", "()D", Self::next_double, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new(
30                    "nextGaussian",
31                    "()D",
32                    Self::next_gaussian,
33                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
34                ),
35                JavaMethodProto::new(
36                    "setSeed",
37                    "(J)V",
38                    Self::set_seed,
39                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
40                ),
41            ],
42            fields: vec![
43                JavaFieldProto::new("seed", "J", FieldAccessFlags::PRIVATE),
44                JavaFieldProto::new("nextNextGaussian", "D", FieldAccessFlags::PRIVATE),
45                JavaFieldProto::new("haveNextNextGaussian", "Z", FieldAccessFlags::PRIVATE),
46            ],
47            access_flags: ClassAccessFlags::PUBLIC,
48        }
49    }
50
51    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
52        tracing::debug!("java.util.Random::<init>({this:?})");
53
54        let default_seed: i64 = jvm.invoke_static("java/lang/System", "currentTimeMillis", "()J", ()).await?;
55        let _: () = jvm.invoke_special(&this, "java/util/Random", "<init>", "(J)V", (default_seed,)).await?;
56
57        Ok(())
58    }
59
60    async fn init_with_seed(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, seed: i64) -> Result<()> {
61        tracing::debug!("java.util.Random::<init>({this:?}, {seed:?})");
62
63        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
64
65        let _: () = jvm.invoke_virtual(&this, "java/util/Random", "setSeed", "(J)V", (seed,)).await?;
66
67        Ok(())
68    }
69
70    async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, bits: i32) -> Result<i32> {
71        tracing::debug!("java.util.Random::next({this:?}, {bits:?})");
72
73        let seed: i64 = jvm.get_field(&this, "java/util/Random", "seed", "J").await?;
74        let next_seed = seed.wrapping_mul(0x5DEECE66D).wrapping_add(0xB) & 0xFFFFFFFFFFFF;
75
76        jvm.put_field(&mut this, "java/util/Random", "seed", "J", next_seed).await?;
77
78        let value = (next_seed as u64).wrapping_shr(((48 - bits) & 63) as u32) as i32;
79
80        Ok(value)
81    }
82
83    async fn next_boolean(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
84        tracing::debug!("java.util.Random::nextBoolean({this:?})");
85
86        let value: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (1,)).await?;
87        Ok(value != 0)
88    }
89
90    async fn next_bytes(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, mut bytes: ClassInstanceRef<Array<i8>>) -> Result<()> {
91        tracing::debug!("java.util.Random::nextBytes({this:?}, {bytes:?})");
92
93        if bytes.is_null() {
94            return Err(jvm.exception("java/lang/NullPointerException", "bytes is null").await);
95        }
96
97        let length = jvm.array_length(&bytes).await?;
98        let mut index = 0;
99        while index < length {
100            let mut random: i32 = jvm.invoke_virtual(&this, "java/util/Random", "nextInt", "()I", ()).await?;
101            let chunk_length = core::cmp::min(length - index, 4);
102            let mut chunk = alloc::vec::Vec::with_capacity(chunk_length);
103            for _ in 0..chunk_length {
104                chunk.push(random as i8);
105                random >>= 8;
106            }
107            jvm.store_array(&mut bytes, index, chunk).await?;
108            index += chunk_length;
109        }
110
111        Ok(())
112    }
113
114    async fn next_int(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
115        tracing::debug!("java.util.Random::nextInt({this:?})");
116        jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (32,)).await
117    }
118
119    async fn next_int_with_bound(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, bound: i32) -> Result<i32> {
120        tracing::debug!("java.util.Random::nextInt({this:?}, {bound:?})");
121
122        if bound <= 0 {
123            return Err(jvm.exception("java/lang/IllegalArgumentException", "n must be positive").await);
124        }
125
126        if (bound as u32).is_power_of_two() {
127            let bits: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (31,)).await?;
128            return Ok(((bound as i64 * bits as i64) >> 31) as i32);
129        }
130
131        loop {
132            let bits: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (31,)).await?;
133            let value = bits % bound;
134            if bits.wrapping_sub(value).wrapping_add(bound - 1) >= 0 {
135                return Ok(value);
136            }
137        }
138    }
139
140    async fn next_long(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i64> {
141        tracing::debug!("java.util.Random::nextLong({this:?})");
142
143        let high: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (32,)).await?;
144        let low: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (32,)).await?;
145        Ok((high as i64).wrapping_shl(32).wrapping_add(low as i64))
146    }
147
148    async fn next_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f32> {
149        tracing::debug!("java.util.Random::nextFloat({this:?})");
150
151        let bits: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (24,)).await?;
152        Ok(bits as f32 / (1u32 << 24) as f32)
153    }
154
155    async fn next_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<f64> {
156        tracing::debug!("java.util.Random::nextDouble({this:?})");
157
158        let high: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (26,)).await?;
159        let low: i32 = jvm.invoke_virtual(&this, "java/util/Random", "next", "(I)I", (27,)).await?;
160        Ok(((high as i64) << 27 | low as i64) as f64 / (1u64 << 53) as f64)
161    }
162
163    async fn next_gaussian(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<f64> {
164        tracing::debug!("java.util.Random::nextGaussian({this:?})");
165
166        let have_next_next_gaussian: bool = jvm.get_field(&this, "java/util/Random", "haveNextNextGaussian", "Z").await?;
167        if have_next_next_gaussian {
168            let next_next_gaussian: f64 = jvm.get_field(&this, "java/util/Random", "nextNextGaussian", "D").await?;
169            jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", false).await?;
170            return Ok(next_next_gaussian);
171        }
172
173        let (first, second, radius_squared) = loop {
174            let first = 2.0 * jvm.invoke_virtual::<_, f64>(&this, "java/util/Random", "nextDouble", "()D", ()).await? - 1.0;
175            let second = 2.0 * jvm.invoke_virtual::<_, f64>(&this, "java/util/Random", "nextDouble", "()D", ()).await? - 1.0;
176            let radius_squared = first * first + second * second;
177            if radius_squared < 1.0 && radius_squared != 0.0 {
178                break (first, second, radius_squared);
179            }
180        };
181        let multiplier = libm::sqrt(-2.0 * libm::log(radius_squared) / radius_squared);
182        jvm.put_field(&mut this, "java/util/Random", "nextNextGaussian", "D", second * multiplier)
183            .await?;
184        jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", true).await?;
185        Ok(first * multiplier)
186    }
187
188    async fn set_seed(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, seed: i64) -> Result<()> {
189        tracing::debug!("java.util.Random::setSeed({this:?}, {seed:?})");
190
191        let seed = (seed ^ 0x5DEECE66D) & ((1 << 48) - 1);
192
193        jvm.put_field(&mut this, "java/util/Random", "seed", "J", seed).await?;
194        jvm.put_field(&mut this, "java/util/Random", "haveNextNextGaussian", "Z", false).await?;
195
196        Ok(())
197    }
198}