add java 1.2 collections framework

Author: dlunch

java_runtime/src/classes/java/util.rs

@@ -3,29 +3,59 @@ pub mod zip;
 
 mod abstract_collection;
 mod abstract_list;
+mod abstract_map;
+mod abstract_set;
+mod array_list;
+mod array_list_itr;
 mod calendar;
+mod collection;
 mod date;
 mod dictionary;
 mod empty_stack_exception;
 mod enumeration;
 mod gregorian_calendar;
+mod hash_map;
+mod hash_map_entry;
+mod hash_map_entry_iterator;
+mod hash_map_entry_set;
+mod hash_map_hash_iterator;
+mod hash_map_key_iterator;
+mod hash_map_key_set;
+mod hash_map_value_iterator;
+mod hash_map_values;
+mod hash_set;
 mod hashtable;
 mod hashtable_entry;
+mod hashtable_entry_set;
+mod hashtable_enumerator;
+mod hashtable_key_set;
+mod hashtable_values;
+mod iterator;
+mod list;
+mod map;
+mod map_entry;
 mod no_such_element_exception;
 mod properties;
 mod random;
+mod set;
 mod simple_time_zone;
 mod stack;
 mod time_zone;
 mod timer;
 mod timer_task;
 mod timer_thread;
 mod vector;
+mod vector_itr;
 
 pub use self::{
-    abstract_collection::AbstractCollection, abstract_list::AbstractList, calendar::Calendar, date::Date, dictionary::Dictionary,
-    empty_stack_exception::EmptyStackException, enumeration::Enumeration, gregorian_calendar::GregorianCalendar, hashtable::Hashtable,
-    hashtable_entry::HashtableEntry, no_such_element_exception::NoSuchElementException, properties::Properties, random::Random,
-    simple_time_zone::SimpleTimeZone, stack::Stack, time_zone::TimeZone, timer::Timer, timer_task::TimerTask, timer_thread::TimerThread,
-    vector::Vector,
+    abstract_collection::AbstractCollection, abstract_list::AbstractList, abstract_map::AbstractMap, abstract_set::AbstractSet,
+    array_list::ArrayList, array_list_itr::ArrayListItr, calendar::Calendar, collection::Collection, date::Date, dictionary::Dictionary,
+    empty_stack_exception::EmptyStackException, enumeration::Enumeration, gregorian_calendar::GregorianCalendar, hash_map::HashMap,
+    hash_map_entry::HashMapEntry, hash_map_entry_iterator::HashMapEntryIterator, hash_map_entry_set::HashMapEntrySet,
+    hash_map_hash_iterator::HashMapHashIterator, hash_map_key_iterator::HashMapKeyIterator, hash_map_key_set::HashMapKeySet,
+    hash_map_value_iterator::HashMapValueIterator, hash_map_values::HashMapValues, hash_set::HashSet, hashtable::Hashtable,
+    hashtable_entry::HashtableEntry, hashtable_entry_set::HashtableEntrySet, hashtable_enumerator::HashtableEnumerator,
+    hashtable_key_set::HashtableKeySet, hashtable_values::HashtableValues, iterator::Iterator, list::List, map::Map, map_entry::MapEntry,
+    no_such_element_exception::NoSuchElementException, properties::Properties, random::Random, set::Set, simple_time_zone::SimpleTimeZone,
+    stack::Stack, time_zone::TimeZone, timer::Timer, timer_task::TimerTask, timer_thread::TimerThread, vector::Vector, vector_itr::VectorItr,
 };

java_runtime/src/classes/java/util/abstract_collection.rs

@@ -2,9 +2,9 @@ use alloc::vec;
 
 use java_class_proto::JavaMethodProto;
 use java_constants::ClassAccessFlags;
-use jvm::{ClassInstanceRef, Jvm, Result};
+use jvm::{Array, ClassInstanceRef, Jvm, Result};
 
-use crate::{RuntimeClassProto, RuntimeContext};
+use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
 
 // abstract class java.util.AbstractCollection
 pub struct AbstractCollection;
@@ -14,8 +14,18 @@ impl AbstractCollection {
         RuntimeClassProto {
             name: "java/util/AbstractCollection",
             parent_class: Some("java/lang/Object"),
-            interfaces: vec![],
-            methods: vec![JavaMethodProto::new("<init>", "()V", Self::init, Default::default())],
+            interfaces: vec!["java/util/Collection"],
+            methods: vec![
+                JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
+                JavaMethodProto::new_abstract("size", "()I", Default::default()),
+                JavaMethodProto::new("isEmpty", "()Z", Self::is_empty, Default::default()),
+                JavaMethodProto::new("contains", "(Ljava/lang/Object;)Z", Self::contains, Default::default()),
+                JavaMethodProto::new_abstract("iterator", "()Ljava/util/Iterator;", Default::default()),
+                JavaMethodProto::new("toArray", "()[Ljava/lang/Object;", Self::to_array, Default::default()),
+                JavaMethodProto::new("add", "(Ljava/lang/Object;)Z", Self::add, Default::default()),
+                JavaMethodProto::new("remove", "(Ljava/lang/Object;)Z", Self::remove, Default::default()),
+                JavaMethodProto::new("clear", "()V", Self::clear, Default::default()),
+            ],
             fields: vec![],
             access_flags: ClassAccessFlags::ABSTRACT,
         }
@@ -28,4 +38,84 @@ impl AbstractCollection {
 
         Ok(())
     }
+
+    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
+        tracing::debug!("java.util.AbstractCollection::isEmpty({this:?})");
+
+        let size: i32 = jvm.invoke_virtual(&this, "size", "()I", ()).await?;
+
+        Ok(size == 0)
+    }
+
+    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
+        tracing::debug!("java.util.AbstractCollection::contains({this:?}, {element:?})");
+
+        let iterator: ClassInstanceRef<Object> = jvm.invoke_virtual(&this, "iterator", "()Ljava/util/Iterator;", ()).await?;
+        loop {
+            let has_next: bool = jvm.invoke_virtual(&iterator, "hasNext", "()Z", ()).await?;
+            if !has_next {
+                return Ok(false);
+            }
+
+            let current: ClassInstanceRef<Object> = jvm.invoke_virtual(&iterator, "next", "()Ljava/lang/Object;", ()).await?;
+            if Self::object_equals(jvm, &element, &current).await? {
+                return Ok(true);
+            }
+        }
+    }
+
+    async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
+        tracing::debug!("java.util.AbstractCollection::toArray({this:?})");
+
+        let iterator: ClassInstanceRef<Object> = jvm.invoke_virtual(&this, "iterator", "()Ljava/util/Iterator;", ()).await?;
+        let mut elements = vec![];
+        loop {
+            let has_next: bool = jvm.invoke_virtual(&iterator, "hasNext", "()Z", ()).await?;
+            if !has_next {
+                break;
+            }
+
+            let current: ClassInstanceRef<Object> = jvm.invoke_virtual(&iterator, "next", "()Ljava/lang/Object;", ()).await?;
+            elements.push(current);
+        }
+
+        let mut array: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
+        if !elements.is_empty() {
+            jvm.store_array(&mut array, 0, elements).await?;
+        }
+
+        Ok(array)
+    }
+
+    async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
+        tracing::debug!("java.util.AbstractCollection::add({this:?}, {element:?})");
+
+        Err(jvm.exception("java/lang/UnsupportedOperationException", "AbstractCollection.add").await)
+    }
+
+    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
+        tracing::debug!("java.util.AbstractCollection::remove({this:?}, {element:?})");
+
+        Err(jvm
+            .exception("java/lang/UnsupportedOperationException", "AbstractCollection.remove")
+            .await)
+    }
+
+    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        tracing::debug!("java.util.AbstractCollection::clear({this:?})");
+
+        Err(jvm.exception("java/lang/UnsupportedOperationException", "AbstractCollection.clear").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, "equals", "(Ljava/lang/Object;)Z", (right.clone(),)).await
+    }
 }

java_runtime/src/classes/java/util/abstract_list.rs

@@ -14,7 +14,7 @@ impl AbstractList {
         RuntimeClassProto {
             name: "java/util/AbstractList",
             parent_class: Some("java/util/AbstractCollection"),
-            interfaces: vec![],
+            interfaces: vec!["java/util/List"],
             methods: vec![JavaMethodProto::new("<init>", "()V", Self::init, Default::default())],
             fields: vec![],
             access_flags: ClassAccessFlags::ABSTRACT,

java_runtime/src/classes/java/util/abstract_map.rs

@@ -0,0 +1,43 @@
+use alloc::vec;
+
+use java_class_proto::JavaMethodProto;
+use java_constants::ClassAccessFlags;
+use jvm::{ClassInstanceRef, Jvm, Result};
+
+use crate::{RuntimeClassProto, RuntimeContext};
+
+// abstract class java.util.AbstractMap
+pub struct AbstractMap;
+
+impl AbstractMap {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/util/AbstractMap",
+            parent_class: Some("java/lang/Object"),
+            interfaces: vec!["java/util/Map"],
+            methods: vec![
+                JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
+                JavaMethodProto::new_abstract("size", "()I", Default::default()),
+                JavaMethodProto::new("isEmpty", "()Z", Self::is_empty, Default::default()),
+            ],
+            fields: vec![],
+            access_flags: ClassAccessFlags::ABSTRACT,
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        tracing::debug!("java.util.AbstractMap::<init>({this:?})");
+
+        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
+
+        Ok(())
+    }
+
+    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
+        tracing::debug!("java.util.AbstractMap::isEmpty({this:?})");
+
+        let size: i32 = jvm.invoke_virtual(&this, "size", "()I", ()).await?;
+
+        Ok(size == 0)
+    }
+}

java_runtime/src/classes/java/util/abstract_set.rs

@@ -0,0 +1,31 @@
+use alloc::vec;
+
+use java_class_proto::JavaMethodProto;
+use java_constants::ClassAccessFlags;
+use jvm::{ClassInstanceRef, Jvm, Result};
+
+use crate::{RuntimeClassProto, RuntimeContext};
+
+// abstract class java.util.AbstractSet
+pub struct AbstractSet;
+
+impl AbstractSet {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/util/AbstractSet",
+            parent_class: Some("java/util/AbstractCollection"),
+            interfaces: vec!["java/util/Set"],
+            methods: vec![JavaMethodProto::new("<init>", "()V", Self::init, Default::default())],
+            fields: vec![],
+            access_flags: ClassAccessFlags::ABSTRACT,
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        tracing::debug!("java.util.AbstractSet::<init>({this:?})");
+
+        let _: () = jvm.invoke_special(&this, "java/util/AbstractCollection", "<init>", "()V", ()).await?;
+
+        Ok(())
+    }
+}