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, "table", "[Ljava/util/Hashtable$Entry;", table).await?;
143        jvm.put_field(&mut this, "count", "I", 0).await?;
144        jvm.put_field(&mut this, "threshold", "I", (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
145            .await?;
146        jvm.put_field(&mut this, "loadFactor", "F", DEFAULT_LOAD_FACTOR).await?;
147
148        Ok(())
149    }
150
151    async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
152        tracing::debug!("java.util.Hashtable::<init>({this:?}, {map:?})");
153
154        if map.is_null() {
155            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
156        }
157        let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
158        let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
159        let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (capacity,)).await?;
160        let _: () = jvm
161            .invoke_virtual(&this, "java/util/Hashtable", "putAll", "(Ljava/util/Map;)V", (map,))
162            .await?;
163
164        Ok(())
165    }
166
167    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
168        tracing::debug!("java.util.Hashtable::contains({this:?}, {value:?})");
169        jvm.invoke_virtual(&this, "java/util/Hashtable", "containsValue", "(Ljava/lang/Object;)Z", (value,))
170            .await
171    }
172
173    async fn keys(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
174        tracing::debug!("java.util.Hashtable::keys({this:?})");
175
176        let snapshot = Self::keys_snapshot(jvm, &this).await?;
177        Ok(jvm
178            .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
179            .await?
180            .into())
181    }
182
183    async fn elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
184        tracing::debug!("java.util.Hashtable::elements({this:?})");
185
186        let snapshot = Self::values_snapshot(jvm, &this).await?;
187        Ok(jvm
188            .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
189            .await?
190            .into())
191    }
192
193    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
194        tracing::debug!("java.util.Hashtable::size({this:?})");
195
196        jvm.get_field(&this, "count", "I").await
197    }
198
199    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
200        tracing::debug!("java.util.Hashtable::isEmpty({this:?})");
201
202        let count: i32 = jvm.get_field(&this, "count", "I").await?;
203
204        Ok(count == 0)
205    }
206
207    async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
208        tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})");
209
210        let key_hash = Self::key_hash(jvm, &key).await?;
211        let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
212        let table_len = jvm.array_length(&table).await? as i32;
213        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
214
215        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
216        while !entry.is_null() {
217            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
218            if entry_hash == key_hash {
219                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
220                let equals: bool = jvm
221                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
222                    .await?;
223                if equals {
224                    return Ok(true);
225                }
226            }
227            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
228        }
229
230        Ok(false)
231    }
232
233    async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
234        tracing::debug!("java.util.Hashtable::containsValue({this:?}, {value:?})");
235
236        if value.is_null() {
237            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
238        }
239
240        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
241        let table_len = jvm.array_length(&table).await?;
242        for bucket_index in 0..table_len {
243            let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
244            while !entry.is_null() {
245                let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
246                if Self::object_equals(jvm, &value, &entry_value).await? {
247                    return Ok(true);
248                }
249
250                entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
251            }
252        }
253
254        Ok(false)
255    }
256
257    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
258        tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})");
259
260        let key_hash = Self::key_hash(jvm, &key).await?;
261        let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
262        let table_len = jvm.array_length(&table).await? as i32;
263        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
264
265        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
266        while !entry.is_null() {
267            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
268            if entry_hash == key_hash {
269                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
270                let equals: bool = jvm
271                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
272                    .await?;
273                if equals {
274                    return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
275                }
276            }
277            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
278        }
279
280        Ok(None.into())
281    }
282
283    async fn remove(
284        jvm: &Jvm,
285        _: &mut RuntimeContext,
286        mut this: ClassInstanceRef<Self>,
287        key: ClassInstanceRef<Object>,
288    ) -> Result<ClassInstanceRef<Object>> {
289        tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})");
290
291        let key_hash = Self::key_hash(jvm, &key).await?;
292        let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
293        let table_len = jvm.array_length(&table).await? as i32;
294        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
295
296        let mut prev: ClassInstanceRef<HashtableEntry> = None.into();
297        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
298
299        while !entry.is_null() {
300            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
301            if entry_hash == key_hash {
302                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
303                let equals: bool = jvm
304                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
305                    .await?;
306                if equals {
307                    let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
308                    if prev.is_null() {
309                        jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?;
310                    } else {
311                        jvm.put_field(&mut prev, "next", "Ljava/util/Hashtable$Entry;", next).await?;
312                    }
313
314                    let count: i32 = jvm.get_field(&this, "count", "I").await?;
315                    jvm.put_field(&mut this, "count", "I", count - 1).await?;
316
317                    return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
318                }
319            }
320            prev = entry;
321            entry = jvm.get_field(&prev, "next", "Ljava/util/Hashtable$Entry;").await?;
322        }
323
324        Ok(None.into())
325    }
326
327    async fn put(
328        jvm: &Jvm,
329        _: &mut RuntimeContext,
330        mut this: ClassInstanceRef<Self>,
331        key: ClassInstanceRef<Object>,
332        value: ClassInstanceRef<Object>,
333    ) -> Result<ClassInstanceRef<Object>> {
334        tracing::debug!("java.util.Hashtable::put({this:?}, {key:?}, {value:?})");
335
336        if value.is_null() {
337            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
338        }
339
340        let key_hash = Self::key_hash(jvm, &key).await?;
341        let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
342        let table_len = jvm.array_length(&table).await? as i32;
343        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
344
345        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
346        while !entry.is_null() {
347            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
348            if entry_hash == key_hash {
349                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
350                let equals: bool = jvm
351                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
352                    .await?;
353                if equals {
354                    let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
355                    jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?;
356                    return Ok(old_value);
357                }
358            }
359            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
360        }
361
362        let count: i32 = jvm.get_field(&this, "count", "I").await?;
363        let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?;
364
365        if count >= threshold {
366            Self::rehash_table(jvm, &mut this).await?;
367            table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
368            let new_table_len = jvm.array_length(&table).await? as i32;
369            let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize;
370
371            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, new_bucket_index, 1).await?.into_iter().next().unwrap();
372            let new_entry = jvm
373                .new_class(
374                    "java/util/Hashtable$Entry",
375                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
376                    (key_hash, key, value, existing),
377                )
378                .await?;
379            jvm.store_array(&mut table, new_bucket_index, core::iter::once(new_entry)).await?;
380        } else {
381            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
382            let new_entry = jvm
383                .new_class(
384                    "java/util/Hashtable$Entry",
385                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
386                    (key_hash, key, value, existing),
387                )
388                .await?;
389            jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?;
390        }
391
392        jvm.put_field(&mut this, "count", "I", count + 1).await?;
393
394        Ok(None.into())
395    }
396
397    async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
398        tracing::debug!("java.util.Hashtable::putAll({this:?}, {map:?})");
399
400        if map.is_null() {
401            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
402        }
403        if this.identity() == map.identity() {
404            return Ok(());
405        }
406
407        let entry_set: ClassInstanceRef<Object> = jvm
408            .invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
409            .await?;
410        let entries: ClassInstanceRef<Array<Object>> = jvm
411            .invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
412            .await?;
413        let count = jvm.array_length(&entries).await?;
414        let mut validated = Vec::with_capacity(count);
415        for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
416            let key: ClassInstanceRef<Object> = jvm
417                .invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
418                .await?;
419            let value: ClassInstanceRef<Object> = jvm
420                .invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
421                .await?;
422            if key.is_null() {
423                return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
424            }
425            if value.is_null() {
426                return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
427            }
428            validated.push((key, value));
429        }
430
431        for (key, value) in validated {
432            let _: ClassInstanceRef<Object> = jvm
433                .invoke_virtual(
434                    &this,
435                    "java/util/Hashtable",
436                    "put",
437                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
438                    (key, value),
439                )
440                .await?;
441        }
442
443        Ok(())
444    }
445
446    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
447        tracing::debug!("java.util.Hashtable::clear({this:?})");
448
449        let mut table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
450        let table_len = jvm.array_length(&table).await?;
451        if table_len > 0 {
452            let nulls: Vec<ClassInstanceRef<HashtableEntry>> = (0..table_len).map(|_| None.into()).collect();
453            jvm.store_array(&mut table, 0, nulls).await?;
454        }
455        jvm.put_field(&mut this, "count", "I", 0).await?;
456
457        Ok(())
458    }
459
460    async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
461        tracing::debug!("java.util.Hashtable::keySet({this:?})");
462
463        let key_set = jvm.new_class("java/util/Hashtable$KeySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
464
465        Ok(key_set.into())
466    }
467
468    async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
469        tracing::debug!("java.util.Hashtable::values({this:?})");
470
471        let values = jvm.new_class("java/util/Hashtable$Values", "(Ljava/util/Hashtable;)V", (this,)).await?;
472
473        Ok(values.into())
474    }
475
476    async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
477        tracing::debug!("java.util.Hashtable::entrySet({this:?})");
478
479        let entry_set = jvm.new_class("java/util/Hashtable$EntrySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
480
481        Ok(entry_set.into())
482    }
483
484    pub(super) async fn keys_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
485        Self::snapshot_entries(jvm, this, SnapshotKind::Keys).await
486    }
487
488    pub(super) async fn values_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
489        Self::snapshot_entries(jvm, this, SnapshotKind::Values).await
490    }
491
492    pub(super) async fn entries_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
493        Self::snapshot_entries(jvm, this, SnapshotKind::Entries).await
494    }
495
496    pub(super) async fn find_entry(
497        jvm: &Jvm,
498        this: &ClassInstanceRef<Self>,
499        key: &ClassInstanceRef<Object>,
500    ) -> Result<ClassInstanceRef<HashtableEntry>> {
501        let key_hash = Self::key_hash(jvm, key).await?;
502        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
503        let table_len = jvm.array_length(&table).await? as i32;
504        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
505
506        let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
507        while !entry.is_null() {
508            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
509            if entry_hash == key_hash {
510                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
511                let equals: bool = jvm
512                    .invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
513                    .await?;
514                if equals {
515                    return Ok(entry);
516                }
517            }
518
519            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
520        }
521
522        Ok(None.into())
523    }
524
525    async fn rehash(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
526        tracing::debug!("java.util.Hashtable::rehash({this:?})");
527        Self::rehash_table(jvm, &mut this).await
528    }
529
530    async fn rehash_table(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
531        let old_table = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
532        let old_capacity = jvm.array_length(&old_table).await?;
533        let new_capacity = old_capacity * 2 + 1;
534
535        let mut new_table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", new_capacity).await?;
536
537        for i in 0..old_capacity {
538            let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap();
539            while !entry.is_null() {
540                let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
541                let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
542                let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize;
543
544                let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap();
545                jvm.put_field(&mut entry, "next", "Ljava/util/Hashtable$Entry;", existing).await?;
546                jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;
547
548                entry = next;
549            }
550        }
551
552        jvm.put_field(this, "table", "[Ljava/util/Hashtable$Entry;", new_table).await?;
553        jvm.put_field(this, "threshold", "I", (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
554            .await?;
555
556        Ok(())
557    }
558
559    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
560        tracing::debug!("java.util.Hashtable::equals({this:?}, {other:?})");
561
562        if !other.is_null() && this.identity() == other.identity() {
563            return Ok(true);
564        }
565        if other.is_null() || !jvm.is_instance(other.as_ref(), "java/util/Map") {
566            return Ok(false);
567        }
568
569        let count: i32 = jvm.get_field(&this, "count", "I").await?;
570        let other_size: i32 = jvm.invoke_virtual(&other, &other.class_definition().name(), "size", "()I", ()).await?;
571        if count != other_size {
572            return Ok(false);
573        }
574
575        let comparison: Result<bool> = async {
576            let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
577            let table_len = jvm.array_length(&table).await?;
578            for bucket_index in 0..table_len {
579                let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
580                while !entry.is_null() {
581                    let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
582                    let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
583                    let other_value: ClassInstanceRef<Object> = jvm
584                        .invoke_virtual(
585                            &other,
586                            &other.class_definition().name(),
587                            "get",
588                            "(Ljava/lang/Object;)Ljava/lang/Object;",
589                            (key.clone(),),
590                        )
591                        .await?;
592                    if value.is_null() {
593                        if !other_value.is_null()
594                            || !jvm
595                                .invoke_virtual::<_, bool>(&other, &other.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,))
596                                .await?
597                        {
598                            return Ok(false);
599                        }
600                    } else if !jvm
601                        .invoke_virtual::<_, bool>(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other_value,))
602                        .await?
603                    {
604                        return Ok(false);
605                    }
606
607                    entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
608                }
609            }
610
611            Ok(true)
612        }
613        .await;
614        match comparison {
615            Err(JavaError::JavaException(exception))
616                if jvm.is_instance(exception.as_ref(), "java/lang/ClassCastException")
617                    || jvm.is_instance(exception.as_ref(), "java/lang/NullPointerException") =>
618            {
619                Ok(false)
620            }
621            result => result,
622        }
623    }
624
625    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
626        tracing::debug!("java.util.Hashtable::hashCode({this:?})");
627
628        let count: i32 = jvm.get_field(&this, "count", "I").await?;
629        let load_factor: f32 = jvm.get_field(&this, "loadFactor", "F").await?;
630        if count == 0 || load_factor < 0.0 {
631            return Ok(0);
632        }
633
634        jvm.put_field(&mut this, "loadFactor", "F", -load_factor).await?;
635        let result: Result<i32> = async {
636            let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
637            let table_len = jvm.array_length(&table).await?;
638            let mut hash = 0i32;
639            for bucket_index in 0..table_len {
640                let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
641                while !entry.is_null() {
642                    hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "java/lang/Object", "hashCode", "()I", ()).await?);
643                    entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
644                }
645            }
646
647            Ok(hash)
648        }
649        .await;
650        jvm.put_field(&mut this, "loadFactor", "F", load_factor).await?;
651        result
652    }
653
654    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
655        tracing::debug!("java.util.Hashtable::toString({this:?})");
656
657        let snapshot = Self::entries_snapshot(jvm, &this).await?;
658        let count = jvm.array_length(&snapshot).await?;
659        let entries: Vec<ClassInstanceRef<Object>> = jvm.load_array(&snapshot, 0, count).await?;
660        let mut result = RustString::from("{");
661        for (index, entry) in entries.into_iter().enumerate() {
662            if index > 0 {
663                result.push_str(", ");
664            }
665
666            let entry: ClassInstanceRef<HashtableEntry> = ClassInstanceRef::new(entry.instance);
667            let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
668            if key.instance.as_ref().unwrap().equals(&**this)? {
669                result.push_str("(this Map)");
670            } else {
671                let text: ClassInstanceRef<String> = jvm
672                    .invoke_virtual(&key, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
673                    .await?;
674                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
675            }
676            result.push('=');
677
678            let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
679            if value.instance.as_ref().unwrap().equals(&**this)? {
680                result.push_str("(this Map)");
681            } else {
682                let text: ClassInstanceRef<String> = jvm
683                    .invoke_virtual(&value, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
684                    .await?;
685                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
686            }
687        }
688        result.push('}');
689
690        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
691    }
692
693    async fn load_bucket(
694        jvm: &Jvm,
695        table: &ClassInstanceRef<Array<HashtableEntry>>,
696        bucket_index: usize,
697    ) -> Result<ClassInstanceRef<HashtableEntry>> {
698        Ok(jvm.load_array(table, bucket_index, 1).await?.remove(0))
699    }
700
701    async fn key_hash(jvm: &Jvm, key: &ClassInstanceRef<Object>) -> Result<i32> {
702        if key.is_null() {
703            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
704        }
705
706        jvm.invoke_virtual(key, "java/lang/Object", "hashCode", "()I", ()).await
707    }
708
709    async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
710        if left.is_null() {
711            return Ok(right.is_null());
712        }
713
714        if right.is_null() {
715            return Ok(false);
716        }
717
718        jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
719            .await
720    }
721
722    async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef<Self>, kind: SnapshotKind) -> Result<ClassInstanceRef<Array<Object>>> {
723        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
724        let table_len = jvm.array_length(&table).await?;
725        let count: i32 = jvm.get_field(this, "count", "I").await?;
726        let mut elements: Vec<ClassInstanceRef<Object>> = Vec::with_capacity(count as usize);
727
728        for bucket_index in 0..table_len {
729            let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
730            while !entry.is_null() {
731                let element = match kind {
732                    SnapshotKind::Keys => jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?,
733                    SnapshotKind::Values => jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?,
734                    SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance),
735                };
736                elements.push(element);
737
738                entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
739            }
740        }
741
742        let mut snapshot: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
743        if !elements.is_empty() {
744            jvm.store_array(&mut snapshot, 0, elements).await?;
745        }
746
747        Ok(snapshot)
748    }
749}
750
751#[derive(Copy, Clone)]
752enum SnapshotKind {
753    Keys,
754    Values,
755    Entries,
756}