use alloc::{string::String as RustString, vec, vec::Vec};
use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::{
RuntimeClassProto, RuntimeContext,
classes::java::lang::{Object, String},
};
use super::HashtableEntry;
const DEFAULT_INITIAL_CAPACITY: i32 = 11;
const DEFAULT_LOAD_FACTOR: f32 = 0.75;
pub struct Hashtable;
impl Hashtable {
pub fn as_proto() -> RuntimeClassProto {
RuntimeClassProto {
name: "java/util/Hashtable",
parent_class: Some("java/util/Dictionary"),
interfaces: vec!["java/util/Map", "java/lang/Cloneable", "java/io/Serializable"],
methods: vec![
JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("<init>", "(Ljava/util/Map;)V", Self::init_from_map, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("size", "()I", Self::size, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
JavaMethodProto::new(
"isEmpty",
"()Z",
Self::is_empty,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"contains",
"(Ljava/lang/Object;)Z",
Self::contains,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"containsKey",
"(Ljava/lang/Object;)Z",
Self::contains_key,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, MethodAccessFlags::PUBLIC),
JavaMethodProto::new(
"keys",
"()Ljava/util/Enumeration;",
Self::keys,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"elements",
"()Ljava/util/Enumeration;",
Self::elements,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
Self::put,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"putAll",
"(Ljava/util/Map;)V",
Self::put_all,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"get",
"(Ljava/lang/Object;)Ljava/lang/Object;",
Self::get,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"remove",
"(Ljava/lang/Object;)Ljava/lang/Object;",
Self::remove,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
JavaMethodProto::new("keySet", "()Ljava/util/Set;", Self::key_set, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("values", "()Ljava/util/Collection;", Self::values, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("entrySet", "()Ljava/util/Set;", Self::entry_set, MethodAccessFlags::PUBLIC),
JavaMethodProto::new("rehash", "()V", Self::rehash, MethodAccessFlags::PROTECTED),
JavaMethodProto::new(
"equals",
"(Ljava/lang/Object;)Z",
Self::equals,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"hashCode",
"()I",
Self::hash_code,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
JavaMethodProto::new(
"toString",
"()Ljava/lang/String;",
Self::to_string,
MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
),
],
fields: vec![
JavaFieldProto::new(
"table",
"[Ljava/util/Hashtable$Entry;",
FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT,
),
JavaFieldProto::new("count", "I", FieldAccessFlags::PRIVATE | FieldAccessFlags::TRANSIENT),
JavaFieldProto::new("threshold", "I", FieldAccessFlags::PRIVATE),
JavaFieldProto::new("loadFactor", "F", FieldAccessFlags::PRIVATE),
],
access_flags: ClassAccessFlags::PUBLIC,
}
}
async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.util.Hashtable::<init>({this:?})");
jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (DEFAULT_INITIAL_CAPACITY,))
.await
}
async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, initial_capacity: i32) -> Result<()> {
tracing::debug!("java.util.Hashtable::<init>({this:?}, {initial_capacity:?})");
if initial_capacity < 0 {
return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal Capacity").await);
}
let _: () = jvm.invoke_special(&this, "java/util/Dictionary", "<init>", "()V", ()).await?;
let initial_capacity = initial_capacity.max(1);
let table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", initial_capacity as usize).await?;
jvm.put_field(&mut this, "table", "[Ljava/util/Hashtable$Entry;", table).await?;
jvm.put_field(&mut this, "count", "I", 0).await?;
jvm.put_field(&mut this, "threshold", "I", (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
.await?;
jvm.put_field(&mut this, "loadFactor", "F", DEFAULT_LOAD_FACTOR).await?;
Ok(())
}
async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
tracing::debug!("java.util.Hashtable::<init>({this:?}, {map:?})");
if map.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "map").await);
}
let size: i32 = jvm.invoke_virtual(&map, &map.class_definition().name(), "size", "()I", ()).await?;
let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (capacity,)).await?;
let _: () = jvm
.invoke_virtual(&this, "java/util/Hashtable", "putAll", "(Ljava/util/Map;)V", (map,))
.await?;
Ok(())
}
async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
tracing::debug!("java.util.Hashtable::contains({this:?}, {value:?})");
jvm.invoke_virtual(&this, "java/util/Hashtable", "containsValue", "(Ljava/lang/Object;)Z", (value,))
.await
}
async fn keys(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::keys({this:?})");
let snapshot = Self::keys_snapshot(jvm, &this).await?;
Ok(jvm
.new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
.await?
.into())
}
async fn elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::elements({this:?})");
let snapshot = Self::values_snapshot(jvm, &this).await?;
Ok(jvm
.new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
.await?
.into())
}
async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
tracing::debug!("java.util.Hashtable::size({this:?})");
jvm.get_field(&this, "count", "I").await
}
async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
tracing::debug!("java.util.Hashtable::isEmpty({this:?})");
let count: i32 = jvm.get_field(&this, "count", "I").await?;
Ok(count == 0)
}
async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})");
let key_hash = Self::key_hash(jvm, &key).await?;
let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await? as i32;
let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
while !entry.is_null() {
let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
if entry_hash == key_hash {
let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
let equals: bool = jvm
.invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
.await?;
if equals {
return Ok(true);
}
}
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
Ok(false)
}
async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
tracing::debug!("java.util.Hashtable::containsValue({this:?}, {value:?})");
if value.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
}
let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await?;
for bucket_index in 0..table_len {
let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
while !entry.is_null() {
let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
if Self::object_equals(jvm, &value, &entry_value).await? {
return Ok(true);
}
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
}
Ok(false)
}
async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})");
let key_hash = Self::key_hash(jvm, &key).await?;
let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await? as i32;
let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
while !entry.is_null() {
let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
if entry_hash == key_hash {
let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
let equals: bool = jvm
.invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
.await?;
if equals {
return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
}
}
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
Ok(None.into())
}
async fn remove(
jvm: &Jvm,
_: &mut RuntimeContext,
mut this: ClassInstanceRef<Self>,
key: ClassInstanceRef<Object>,
) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})");
let key_hash = Self::key_hash(jvm, &key).await?;
let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await? as i32;
let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
let mut prev: ClassInstanceRef<HashtableEntry> = None.into();
let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
while !entry.is_null() {
let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
if entry_hash == key_hash {
let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
let equals: bool = jvm
.invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
.await?;
if equals {
let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
if prev.is_null() {
jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?;
} else {
jvm.put_field(&mut prev, "next", "Ljava/util/Hashtable$Entry;", next).await?;
}
let count: i32 = jvm.get_field(&this, "count", "I").await?;
jvm.put_field(&mut this, "count", "I", count - 1).await?;
return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
}
}
prev = entry;
entry = jvm.get_field(&prev, "next", "Ljava/util/Hashtable$Entry;").await?;
}
Ok(None.into())
}
async fn put(
jvm: &Jvm,
_: &mut RuntimeContext,
mut this: ClassInstanceRef<Self>,
key: ClassInstanceRef<Object>,
value: ClassInstanceRef<Object>,
) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::put({this:?}, {key:?}, {value:?})");
if value.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
}
let key_hash = Self::key_hash(jvm, &key).await?;
let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await? as i32;
let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
while !entry.is_null() {
let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
if entry_hash == key_hash {
let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
let equals: bool = jvm
.invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
.await?;
if equals {
let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?;
return Ok(old_value);
}
}
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
let count: i32 = jvm.get_field(&this, "count", "I").await?;
let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?;
if count >= threshold {
Self::rehash_table(jvm, &mut this).await?;
table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let new_table_len = jvm.array_length(&table).await? as i32;
let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize;
let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, new_bucket_index, 1).await?.into_iter().next().unwrap();
let new_entry = jvm
.new_class(
"java/util/Hashtable$Entry",
"(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
(key_hash, key, value, existing),
)
.await?;
jvm.store_array(&mut table, new_bucket_index, core::iter::once(new_entry)).await?;
} else {
let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
let new_entry = jvm
.new_class(
"java/util/Hashtable$Entry",
"(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
(key_hash, key, value, existing),
)
.await?;
jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?;
}
jvm.put_field(&mut this, "count", "I", count + 1).await?;
Ok(None.into())
}
async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
tracing::debug!("java.util.Hashtable::putAll({this:?}, {map:?})");
if map.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "map").await);
}
if this.identity() == map.identity() {
return Ok(());
}
let entry_set: ClassInstanceRef<Object> = jvm
.invoke_virtual(&map, &map.class_definition().name(), "entrySet", "()Ljava/util/Set;", ())
.await?;
let entries: ClassInstanceRef<Array<Object>> = jvm
.invoke_virtual(&entry_set, &entry_set.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
.await?;
let count = jvm.array_length(&entries).await?;
let mut validated = Vec::with_capacity(count);
for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
let key: ClassInstanceRef<Object> = jvm
.invoke_virtual(&entry, &entry.class_definition().name(), "getKey", "()Ljava/lang/Object;", ())
.await?;
let value: ClassInstanceRef<Object> = jvm
.invoke_virtual(&entry, &entry.class_definition().name(), "getValue", "()Ljava/lang/Object;", ())
.await?;
if key.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
}
if value.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
}
validated.push((key, value));
}
for (key, value) in validated {
let _: ClassInstanceRef<Object> = jvm
.invoke_virtual(
&this,
"java/util/Hashtable",
"put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
(key, value),
)
.await?;
}
Ok(())
}
async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.util.Hashtable::clear({this:?})");
let mut table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await?;
if table_len > 0 {
let nulls: Vec<ClassInstanceRef<HashtableEntry>> = (0..table_len).map(|_| None.into()).collect();
jvm.store_array(&mut table, 0, nulls).await?;
}
jvm.put_field(&mut this, "count", "I", 0).await?;
Ok(())
}
async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::keySet({this:?})");
let key_set = jvm.new_class("java/util/Hashtable$KeySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
Ok(key_set.into())
}
async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::values({this:?})");
let values = jvm.new_class("java/util/Hashtable$Values", "(Ljava/util/Hashtable;)V", (this,)).await?;
Ok(values.into())
}
async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
tracing::debug!("java.util.Hashtable::entrySet({this:?})");
let entry_set = jvm.new_class("java/util/Hashtable$EntrySet", "(Ljava/util/Hashtable;)V", (this,)).await?;
Ok(entry_set.into())
}
pub(super) async fn keys_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
Self::snapshot_entries(jvm, this, SnapshotKind::Keys).await
}
pub(super) async fn values_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
Self::snapshot_entries(jvm, this, SnapshotKind::Values).await
}
pub(super) async fn entries_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
Self::snapshot_entries(jvm, this, SnapshotKind::Entries).await
}
pub(super) async fn find_entry(
jvm: &Jvm,
this: &ClassInstanceRef<Self>,
key: &ClassInstanceRef<Object>,
) -> Result<ClassInstanceRef<HashtableEntry>> {
let key_hash = Self::key_hash(jvm, key).await?;
let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await? as i32;
let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
while !entry.is_null() {
let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
if entry_hash == key_hash {
let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
let equals: bool = jvm
.invoke_virtual(&entry_key, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (key.clone(),))
.await?;
if equals {
return Ok(entry);
}
}
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
Ok(None.into())
}
async fn rehash(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
tracing::debug!("java.util.Hashtable::rehash({this:?})");
Self::rehash_table(jvm, &mut this).await
}
async fn rehash_table(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
let old_table = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let old_capacity = jvm.array_length(&old_table).await?;
let new_capacity = old_capacity * 2 + 1;
let mut new_table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", new_capacity).await?;
for i in 0..old_capacity {
let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap();
while !entry.is_null() {
let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize;
let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap();
jvm.put_field(&mut entry, "next", "Ljava/util/Hashtable$Entry;", existing).await?;
jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;
entry = next;
}
}
jvm.put_field(this, "table", "[Ljava/util/Hashtable$Entry;", new_table).await?;
jvm.put_field(this, "threshold", "I", (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
.await?;
Ok(())
}
async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
tracing::debug!("java.util.Hashtable::equals({this:?}, {other:?})");
if !other.is_null() && this.identity() == other.identity() {
return Ok(true);
}
if other.is_null() || !jvm.is_instance(other.as_ref(), "java/util/Map") {
return Ok(false);
}
let count: i32 = jvm.get_field(&this, "count", "I").await?;
let other_size: i32 = jvm.invoke_virtual(&other, &other.class_definition().name(), "size", "()I", ()).await?;
if count != other_size {
return Ok(false);
}
let comparison: Result<bool> = async {
let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await?;
for bucket_index in 0..table_len {
let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
while !entry.is_null() {
let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
let other_value: ClassInstanceRef<Object> = jvm
.invoke_virtual(
&other,
&other.class_definition().name(),
"get",
"(Ljava/lang/Object;)Ljava/lang/Object;",
(key.clone(),),
)
.await?;
if value.is_null() {
if !other_value.is_null()
|| !jvm
.invoke_virtual::<_, bool>(&other, &other.class_definition().name(), "containsKey", "(Ljava/lang/Object;)Z", (key,))
.await?
{
return Ok(false);
}
} else if !jvm
.invoke_virtual::<_, bool>(&value, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (other_value,))
.await?
{
return Ok(false);
}
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
}
Ok(true)
}
.await;
match comparison {
Err(JavaError::JavaException(exception))
if jvm.is_instance(exception.as_ref(), "java/lang/ClassCastException")
|| jvm.is_instance(exception.as_ref(), "java/lang/NullPointerException") =>
{
Ok(false)
}
result => result,
}
}
async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
tracing::debug!("java.util.Hashtable::hashCode({this:?})");
let count: i32 = jvm.get_field(&this, "count", "I").await?;
let load_factor: f32 = jvm.get_field(&this, "loadFactor", "F").await?;
if count == 0 || load_factor < 0.0 {
return Ok(0);
}
jvm.put_field(&mut this, "loadFactor", "F", -load_factor).await?;
let result: Result<i32> = async {
let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await?;
let mut hash = 0i32;
for bucket_index in 0..table_len {
let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
while !entry.is_null() {
hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "java/lang/Object", "hashCode", "()I", ()).await?);
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
}
Ok(hash)
}
.await;
jvm.put_field(&mut this, "loadFactor", "F", load_factor).await?;
result
}
async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
tracing::debug!("java.util.Hashtable::toString({this:?})");
let snapshot = Self::entries_snapshot(jvm, &this).await?;
let count = jvm.array_length(&snapshot).await?;
let entries: Vec<ClassInstanceRef<Object>> = jvm.load_array(&snapshot, 0, count).await?;
let mut result = RustString::from("{");
for (index, entry) in entries.into_iter().enumerate() {
if index > 0 {
result.push_str(", ");
}
let entry: ClassInstanceRef<HashtableEntry> = ClassInstanceRef::new(entry.instance);
let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
if key.instance.as_ref().unwrap().equals(&**this)? {
result.push_str("(this Map)");
} else {
let text: ClassInstanceRef<String> = jvm
.invoke_virtual(&key, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
.await?;
result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
}
result.push('=');
let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
if value.instance.as_ref().unwrap().equals(&**this)? {
result.push_str("(this Map)");
} else {
let text: ClassInstanceRef<String> = jvm
.invoke_virtual(&value, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
.await?;
result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
}
}
result.push('}');
Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
}
async fn load_bucket(
jvm: &Jvm,
table: &ClassInstanceRef<Array<HashtableEntry>>,
bucket_index: usize,
) -> Result<ClassInstanceRef<HashtableEntry>> {
Ok(jvm.load_array(table, bucket_index, 1).await?.remove(0))
}
async fn key_hash(jvm: &Jvm, key: &ClassInstanceRef<Object>) -> Result<i32> {
if key.is_null() {
return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
}
jvm.invoke_virtual(key, "java/lang/Object", "hashCode", "()I", ()).await
}
async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
if left.is_null() {
return Ok(right.is_null());
}
if right.is_null() {
return Ok(false);
}
jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
.await
}
async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef<Self>, kind: SnapshotKind) -> Result<ClassInstanceRef<Array<Object>>> {
let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
let table_len = jvm.array_length(&table).await?;
let count: i32 = jvm.get_field(this, "count", "I").await?;
let mut elements: Vec<ClassInstanceRef<Object>> = Vec::with_capacity(count as usize);
for bucket_index in 0..table_len {
let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
while !entry.is_null() {
let element = match kind {
SnapshotKind::Keys => jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?,
SnapshotKind::Values => jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?,
SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance),
};
elements.push(element);
entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
}
}
let mut snapshot: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
if !elements.is_empty() {
jvm.store_array(&mut snapshot, 0, elements).await?;
}
Ok(snapshot)
}
}
#[derive(Copy, Clone)]
enum SnapshotKind {
Keys,
Values,
Entries,
}