Skip to main content

rustjava_runtime/classes/java/util/
hashtable.rs

1use alloc::{string::String as RustString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::lang::{Object, String},
10};
11
12use super::HashtableEntry;
13
14const DEFAULT_INITIAL_CAPACITY: i32 = 11;
15const DEFAULT_LOAD_FACTOR: f32 = 0.75;
16
17// class java.util.Hashtable
18pub struct Hashtable;
19
20impl Hashtable {
21    pub fn as_proto() -> RuntimeClassProto {
22        RuntimeClassProto {
23            name: "java/util/Hashtable",
24            parent_class: Some("java/util/Dictionary"),
25            interfaces: vec!["java/util/Map", "java/lang/Cloneable", "java/io/Serializable"],
26            methods: vec![
27                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("<init>", "(Ljava/util/Map;)V", Self::init_from_map, MethodAccessFlags::PUBLIC),
30                JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
31                JavaMethodProto::new(
32                    "isEmpty",
33                    "()Z",
34                    Self::is_empty,
35                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
36                ),
37                JavaMethodProto::new(
38                    "contains",
39                    "(Ljava/lang/Object;)Z",
40                    Self::contains,
41                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
42                ),
43                JavaMethodProto::new(
44                    "containsKey",
45                    "(Ljava/lang/Object;)Z",
46                    Self::contains_key,
47                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
48                ),
49                JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, MethodAccessFlags::PUBLIC),
50                JavaMethodProto::new(
51                    "keys",
52                    "()Ljava/util/Enumeration;",
53                    Self::keys,
54                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
55                ),
56                JavaMethodProto::new(
57                    "elements",
58                    "()Ljava/util/Enumeration;",
59                    Self::elements,
60                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
61                ),
62                JavaMethodProto::new(
63                    "put",
64                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
65                    Self::put,
66                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
67                ),
68                JavaMethodProto::new(
69                    "putAll",
70                    "(Ljava/util/Map;)V",
71                    Self::put_all,
72                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
73                ),
74                JavaMethodProto::new(
75                    "get",
76                    "(Ljava/lang/Object;)Ljava/lang/Object;",
77                    Self::get,
78                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
79                ),
80                JavaMethodProto::new(
81                    "remove",
82                    "(Ljava/lang/Object;)Ljava/lang/Object;",
83                    Self::remove,
84                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
85                ),
86                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
87                JavaMethodProto::new("keySet", "()Ljava/util/Set;", Self::key_set, MethodAccessFlags::PUBLIC),
88                JavaMethodProto::new("values", "()Ljava/util/Collection;", Self::values, MethodAccessFlags::PUBLIC),
89                JavaMethodProto::new("entrySet", "()Ljava/util/Set;", Self::entry_set, MethodAccessFlags::PUBLIC),
90                JavaMethodProto::new("rehash", "()V", Self::rehash, MethodAccessFlags::PROTECTED),
91                JavaMethodProto::new(
92                    "equals",
93                    "(Ljava/lang/Object;)Z",
94                    Self::equals,
95                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
96                ),
97                JavaMethodProto::new(
98                    "hashCode",
99                    "()I",
100                    Self::hash_code,
101                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
102                ),
103                JavaMethodProto::new(
104                    "toString",
105                    "()Ljava/lang/String;",
106                    Self::to_string,
107                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
108                ),
109            ],
110            fields: vec![
111                JavaFieldProto::new(
112                    "table",
113                    "[Ljava/util/Hashtable$Entry;",
114                    FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT,
115                ),
116                JavaFieldProto::new("count", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT),
117                JavaFieldProto::new("threshold", "I", FieldAccessFlags::PRIVATE),
118                JavaFieldProto::new("loadFactor", "F", FieldAccessFlags::PRIVATE),
119            ],
120            access_flags: ClassAccessFlags::PUBLIC,
121        }
122    }
123
124    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
125        tracing::debug!("java.util.Hashtable::<init>({this:?})");
126
127        jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (DEFAULT_INITIAL_CAPACITY,))
128            .await
129    }
130
131    async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, initial_capacity: i32) -> Result<()> {
132        tracing::debug!("java.util.Hashtable::<init>({this:?}, {initial_capacity:?})");
133
134        if initial_capacity < 0 {
135            return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal Capacity").await);
136        }
137
138        let _: () = jvm.invoke_special(&this, "java/util/Dictionary", "<init>", "()V", ()).await?;
139
140        let initial_capacity = initial_capacity.max(1);
141        let table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", initial_capacity as usize).await?;
142        jvm.put_field(&mut this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;", table)
143            .await?;
144        jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", 0).await?;
145        jvm.put_field(
146            &mut this,
147            "java/util/Hashtable",
148            "threshold",
149            "I",
150            (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32,
151        )
152        .await?;
153        jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", DEFAULT_LOAD_FACTOR)
154            .await?;
155
156        Ok(())
157    }
158
159    async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
160        tracing::debug!("java.util.Hashtable::<init>({this:?}, {map:?})");
161
162        if map.is_null() {
163            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
164        }
165        let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
166        let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
167        let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (capacity,)).await?;
168        let _: () = jvm
169            .invoke_virtual(&this, "java/util/Hashtable", "putAll", "(Ljava/util/Map;)V", (map,))
170            .await?;
171
172        Ok(())
173    }
174
175    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
176        tracing::debug!("java.util.Hashtable::contains({this:?}, {value:?})");
177        jvm.invoke_virtual(&this, "java/util/Hashtable", "containsValue", "(Ljava/lang/Object;)Z", (value,))
178            .await
179    }
180
181    async fn keys(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
182        tracing::debug!("java.util.Hashtable::keys({this:?})");
183
184        let snapshot = Self::keys_snapshot(jvm, &this).await?;
185        Ok(jvm
186            .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
187            .await?
188            .into())
189    }
190
191    async fn elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
192        tracing::debug!("java.util.Hashtable::elements({this:?})");
193
194        let snapshot = Self::values_snapshot(jvm, &this).await?;
195        Ok(jvm
196            .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
197            .await?
198            .into())
199    }
200
201    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
202        tracing::debug!("java.util.Hashtable::size({this:?})");
203
204        jvm.get_field(&this, "java/util/Hashtable", "count", "I").await
205    }
206
207    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
208        tracing::debug!("java.util.Hashtable::isEmpty({this:?})");
209
210        let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
211
212        Ok(count == 0)
213    }
214
215    async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
216        tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})");
217
218        let key_hash = Self::key_hash(jvm, &key).await?;
219        let table = jvm
220            .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
221            .await?;
222        let table_len = jvm.array_length(&table).await? as i32;
223        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
224
225        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
226        while !entry.is_null() {
227            let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
228            if entry_hash == key_hash {
229                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
230                let equals: bool = jvm
231                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
232                    .await?;
233                if equals {
234                    return Ok(true);
235                }
236            }
237            entry = jvm
238                .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
239                .await?;
240        }
241
242        Ok(false)
243    }
244
245    async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
246        tracing::debug!("java.util.Hashtable::containsValue({this:?}, {value:?})");
247
248        if value.is_null() {
249            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
250        }
251
252        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
253            .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
254            .await?;
255        let table_len = jvm.array_length(&table).await?;
256        for bucket_index in 0..table_len {
257            let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
258            while !entry.is_null() {
259                let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
260                if Self::object_equals(jvm, &value, &entry_value).await? {
261                    return Ok(true);
262                }
263
264                entry = jvm
265                    .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
266                    .await?;
267            }
268        }
269
270        Ok(false)
271    }
272
273    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
274        tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})");
275
276        let key_hash = Self::key_hash(jvm, &key).await?;
277        let table = jvm
278            .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
279            .await?;
280        let table_len = jvm.array_length(&table).await? as i32;
281        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
282
283        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
284        while !entry.is_null() {
285            let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
286            if entry_hash == key_hash {
287                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
288                let equals: bool = jvm
289                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
290                    .await?;
291                if equals {
292                    return jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await;
293                }
294            }
295            entry = jvm
296                .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
297                .await?;
298        }
299
300        Ok(None.into())
301    }
302
303    async fn remove(
304        jvm: &Jvm,
305        _: &mut RuntimeContext,
306        mut this: ClassInstanceRef<Self>,
307        key: ClassInstanceRef<Object>,
308    ) -> Result<ClassInstanceRef<Object>> {
309        tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})");
310
311        let key_hash = Self::key_hash(jvm, &key).await?;
312        let mut table = jvm
313            .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
314            .await?;
315        let table_len = jvm.array_length(&table).await? as i32;
316        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
317
318        let mut prev: ClassInstanceRef<HashtableEntry> = None.into();
319        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
320
321        while !entry.is_null() {
322            let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
323            if entry_hash == key_hash {
324                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
325                let equals: bool = jvm
326                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
327                    .await?;
328                if equals {
329                    let next: ClassInstanceRef<HashtableEntry> = jvm
330                        .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
331                        .await?;
332                    if prev.is_null() {
333                        jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?;
334                    } else {
335                        jvm.put_field(&mut prev, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;", next)
336                            .await?;
337                    }
338
339                    let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
340                    jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", count - 1).await?;
341
342                    return jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await;
343                }
344            }
345            prev = entry;
346            entry = jvm
347                .get_field(&prev, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
348                .await?;
349        }
350
351        Ok(None.into())
352    }
353
354    async fn put(
355        jvm: &Jvm,
356        _: &mut RuntimeContext,
357        mut this: ClassInstanceRef<Self>,
358        key: ClassInstanceRef<Object>,
359        value: ClassInstanceRef<Object>,
360    ) -> Result<ClassInstanceRef<Object>> {
361        tracing::debug!("java.util.Hashtable::put({this:?}, {key:?}, {value:?})");
362
363        if value.is_null() {
364            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
365        }
366
367        let key_hash = Self::key_hash(jvm, &key).await?;
368        let mut table = jvm
369            .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
370            .await?;
371        let table_len = jvm.array_length(&table).await? as i32;
372        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
373
374        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
375        while !entry.is_null() {
376            let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
377            if entry_hash == key_hash {
378                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
379                let equals: bool = jvm
380                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
381                    .await?;
382                if equals {
383                    let old_value: ClassInstanceRef<Object> =
384                        jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
385                    jvm.put_field(&mut entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;", value)
386                        .await?;
387                    return Ok(old_value);
388                }
389            }
390            entry = jvm
391                .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
392                .await?;
393        }
394
395        let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
396        let threshold: i32 = jvm.get_field(&this, "java/util/Hashtable", "threshold", "I").await?;
397
398        if count >= threshold {
399            Self::rehash_table(jvm, &mut this).await?;
400            table = jvm
401                .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
402                .await?;
403            let new_table_len = jvm.array_length(&table).await? as i32;
404            let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize;
405
406            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, new_bucket_index, 1).await?.into_iter().next().unwrap();
407            let new_entry = jvm
408                .new_class(
409                    "java/util/Hashtable$Entry",
410                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
411                    (key_hash, key, value, existing),
412                )
413                .await?;
414            jvm.store_array(&mut table, new_bucket_index, core::iter::once(new_entry)).await?;
415        } else {
416            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
417            let new_entry = jvm
418                .new_class(
419                    "java/util/Hashtable$Entry",
420                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
421                    (key_hash, key, value, existing),
422                )
423                .await?;
424            jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?;
425        }
426
427        jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", count + 1).await?;
428
429        Ok(None.into())
430    }
431
432    async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
433        tracing::debug!("java.util.Hashtable::putAll({this:?}, {map:?})");
434
435        if map.is_null() {
436            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
437        }
438        if this.identity() == map.identity() {
439            return Ok(());
440        }
441
442        let entry_set: ClassInstanceRef<Object> = jvm
443            .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
444            .await?;
445        let entries: ClassInstanceRef<Array<Object>> = jvm
446            .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
447            .await?;
448        let count = jvm.array_length(&entries).await?;
449        let mut validated = Vec::with_capacity(count);
450        for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
451            let key: ClassInstanceRef<Object> = jvm
452                .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
453                .await?;
454            let value: ClassInstanceRef<Object> = jvm
455                .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
456                .await?;
457            if key.is_null() {
458                return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
459            }
460            if value.is_null() {
461                return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
462            }
463            validated.push((key, value));
464        }
465
466        for (key, value) in validated {
467            let _: ClassInstanceRef<Object> = jvm
468                .invoke_virtual(
469                    &this,
470                    "java/util/Hashtable",
471                    "put",
472                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
473                    (key, value),
474                )
475                .await?;
476        }
477
478        Ok(())
479    }
480
481    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
482        tracing::debug!("java.util.Hashtable::clear({this:?})");
483
484        let mut table: ClassInstanceRef<Array<HashtableEntry>> = jvm
485            .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
486            .await?;
487        let table_len = jvm.array_length(&table).await?;
488        if table_len > 0 {
489            let nulls: Vec<ClassInstanceRef<HashtableEntry>> = (0..table_len).map(|_| None.into()).collect();
490            jvm.store_array(&mut table, 0, nulls).await?;
491        }
492        jvm.put_field(&mut this, "java/util/Hashtable", "count", "I", 0).await?;
493
494        Ok(())
495    }
496
497    async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
498        tracing::debug!("java.util.Hashtable::keySet({this:?})");
499
500        let key_set = jvm.new_class("java/util/Hashtable$KeySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
501
502        Ok(key_set.into())
503    }
504
505    async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
506        tracing::debug!("java.util.Hashtable::values({this:?})");
507
508        let values = jvm.new_class("java/util/Hashtable$Values", "(Ljava/util/Hashtable;)V", (this,)).await?;
509
510        Ok(values.into())
511    }
512
513    async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
514        tracing::debug!("java.util.Hashtable::entrySet({this:?})");
515
516        let entry_set = jvm.new_class("java/util/Hashtable$EntrySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
517
518        Ok(entry_set.into())
519    }
520
521    pub(super) async fn keys_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
522        Self::snapshot_entries(jvm, this, SnapshotKind::Keys).await
523    }
524
525    pub(super) async fn values_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
526        Self::snapshot_entries(jvm, this, SnapshotKind::Values).await
527    }
528
529    pub(super) async fn entries_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
530        Self::snapshot_entries(jvm, this, SnapshotKind::Entries).await
531    }
532
533    pub(super) async fn find_entry(
534        jvm: &Jvm,
535        this: &ClassInstanceRef<Self>,
536        key: &ClassInstanceRef<Object>,
537    ) -> Result<ClassInstanceRef<HashtableEntry>> {
538        let key_hash = Self::key_hash(jvm, key).await?;
539        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
540            .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
541            .await?;
542        let table_len = jvm.array_length(&table).await? as i32;
543        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
544
545        let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
546        while !entry.is_null() {
547            let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
548            if entry_hash == key_hash {
549                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
550                let equals: bool = jvm
551                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
552                    .await?;
553                if equals {
554                    return Ok(entry);
555                }
556            }
557
558            entry = jvm
559                .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
560                .await?;
561        }
562
563        Ok(None.into())
564    }
565
566    async fn rehash(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
567        tracing::debug!("java.util.Hashtable::rehash({this:?})");
568        Self::rehash_table(jvm, &mut this).await
569    }
570
571    async fn rehash_table(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
572        let old_table = jvm
573            .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
574            .await?;
575        let old_capacity = jvm.array_length(&old_table).await?;
576        let new_capacity = old_capacity * 2 + 1;
577
578        let mut new_table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", new_capacity).await?;
579
580        for i in 0..old_capacity {
581            let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap();
582            while !entry.is_null() {
583                let next: ClassInstanceRef<HashtableEntry> = jvm
584                    .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
585                    .await?;
586                let entry_hash: i32 = jvm.get_field(&entry, "java/util/Hashtable$Entry", "hash", "I").await?;
587                let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize;
588
589                let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap();
590                jvm.put_field(&mut entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;", existing)
591                    .await?;
592                jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;
593
594                entry = next;
595            }
596        }
597
598        jvm.put_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;", new_table)
599            .await?;
600        jvm.put_field(
601            this,
602            "java/util/Hashtable",
603            "threshold",
604            "I",
605            (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32,
606        )
607        .await?;
608
609        Ok(())
610    }
611
612    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
613        tracing::debug!("java.util.Hashtable::equals({this:?}, {other:?})");
614
615        if !other.is_null() && this.identity() == other.identity() {
616            return Ok(true);
617        }
618        if other.is_null() || !jvm.is_instance(other.as_ref(), "java/util/Map") {
619            return Ok(false);
620        }
621
622        let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
623        let other_size: i32 = jvm.invoke_virtual(&other, &other.class_definition().name(), "size", "()I", ()).await?;
624        if count != other_size {
625            return Ok(false);
626        }
627
628        let comparison: Result<bool> = async {
629            let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
630                .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
631                .await?;
632            let table_len = jvm.array_length(&table).await?;
633            for bucket_index in 0..table_len {
634                let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
635                while !entry.is_null() {
636                    let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
637                    let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
638                    let other_value: ClassInstanceRef<Object> = jvm
639                        .invoke_virtual(
640                            &other,
641                            &other.class_definition().name(),
642                            "get",
643                            "(Ljava/lang/Object;)Ljava/lang/Object;",
644                            (key.clone(),),
645                        )
646                        .await?;
647                    if value.is_null() {
648                        if !other_value.is_null()
649                            || !jvm
650                                .invoke_virtual::<_, bool>(&other, &other.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,))
651                                .await?
652                        {
653                            return Ok(false);
654                        }
655                    } else if !jvm
656                        .invoke_virtual::<_, bool>(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other_value,))
657                        .await?
658                    {
659                        return Ok(false);
660                    }
661
662                    entry = jvm
663                        .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
664                        .await?;
665                }
666            }
667
668            Ok(true)
669        }
670        .await;
671        match comparison {
672            Err(JavaError::JavaException(exception))
673                if jvm.is_instance(exception.as_ref(), "java/lang/ClassCastException")
674                    || jvm.is_instance(exception.as_ref(), "java/lang/NullPointerException") =>
675            {
676                Ok(false)
677            }
678            result => result,
679        }
680    }
681
682    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
683        tracing::debug!("java.util.Hashtable::hashCode({this:?})");
684
685        let count: i32 = jvm.get_field(&this, "java/util/Hashtable", "count", "I").await?;
686        let load_factor: f32 = jvm.get_field(&this, "java/util/Hashtable", "loadFactor", "F").await?;
687        if count == 0 || load_factor < 0.0 {
688            return Ok(0);
689        }
690
691        jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", -load_factor).await?;
692        let result: Result<i32> = async {
693            let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
694                .get_field(&this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
695                .await?;
696            let table_len = jvm.array_length(&table).await?;
697            let mut hash = 0i32;
698            for bucket_index in 0..table_len {
699                let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
700                while !entry.is_null() {
701                    hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "java/lang/Object", "hashCode", "()I", ()).await?);
702                    entry = jvm
703                        .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
704                        .await?;
705                }
706            }
707
708            Ok(hash)
709        }
710        .await;
711        jvm.put_field(&mut this, "java/util/Hashtable", "loadFactor", "F", load_factor).await?;
712        result
713    }
714
715    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
716        tracing::debug!("java.util.Hashtable::toString({this:?})");
717
718        let snapshot = Self::entries_snapshot(jvm, &this).await?;
719        let count = jvm.array_length(&snapshot).await?;
720        let entries: Vec<ClassInstanceRef<Object>> = jvm.load_array(&snapshot, 0, count).await?;
721        let mut result = RustString::from("{");
722        for (index, entry) in entries.into_iter().enumerate() {
723            if index > 0 {
724                result.push_str(", ");
725            }
726
727            let entry: ClassInstanceRef<HashtableEntry> = ClassInstanceRef::new(entry.instance);
728            let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?;
729            if key.instance.as_ref().unwrap().equals(&**this)? {
730                result.push_str("(this Map)");
731            } else {
732                let text: ClassInstanceRef<String> = jvm
733                    .invoke_virtual(&key, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
734                    .await?;
735                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
736            }
737            result.push('=');
738
739            let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?;
740            if value.instance.as_ref().unwrap().equals(&**this)? {
741                result.push_str("(this Map)");
742            } else {
743                let text: ClassInstanceRef<String> = jvm
744                    .invoke_virtual(&value, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
745                    .await?;
746                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
747            }
748        }
749        result.push('}');
750
751        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
752    }
753
754    async fn load_bucket(
755        jvm: &Jvm,
756        table: &ClassInstanceRef<Array<HashtableEntry>>,
757        bucket_index: usize,
758    ) -> Result<ClassInstanceRef<HashtableEntry>> {
759        Ok(jvm.load_array(table, bucket_index, 1).await?.remove(0))
760    }
761
762    async fn key_hash(jvm: &Jvm, key: &ClassInstanceRef<Object>) -> Result<i32> {
763        if key.is_null() {
764            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
765        }
766
767        jvm.invoke_virtual(key, "java/lang/Object", "hashCode", "()I", ()).await
768    }
769
770    async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
771        if left.is_null() {
772            return Ok(right.is_null());
773        }
774
775        if right.is_null() {
776            return Ok(false);
777        }
778
779        jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
780            .await
781    }
782
783    async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef<Self>, kind: SnapshotKind) -> Result<ClassInstanceRef<Array<Object>>> {
784        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm
785            .get_field(this, "java/util/Hashtable", "table", "[Ljava/util/Hashtable$Entry;")
786            .await?;
787        let table_len = jvm.array_length(&table).await?;
788        let count: i32 = jvm.get_field(this, "java/util/Hashtable", "count", "I").await?;
789        let mut elements: Vec<ClassInstanceRef<Object>> = Vec::with_capacity(count as usize);
790
791        for bucket_index in 0..table_len {
792            let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
793            while !entry.is_null() {
794                let element = match kind {
795                    SnapshotKind::Keys => jvm.get_field(&entry, "java/util/Hashtable$Entry", "key", "Ljava/lang/Object;").await?,
796                    SnapshotKind::Values => jvm.get_field(&entry, "java/util/Hashtable$Entry", "value", "Ljava/lang/Object;").await?,
797                    SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance),
798                };
799                elements.push(element);
800
801                entry = jvm
802                    .get_field(&entry, "java/util/Hashtable$Entry", "next", "Ljava/util/Hashtable$Entry;")
803                    .await?;
804            }
805        }
806
807        let mut snapshot: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
808        if !elements.is_empty() {
809            jvm.store_array(&mut snapshot, 0, elements).await?;
810        }
811
812        Ok(snapshot)
813    }
814}
815
816#[derive(Copy, Clone)]
817enum SnapshotKind {
818    Keys,
819    Values,
820    Entries,
821}