Skip to main content

rustjava_runtime/classes/java/util/
hash_map_hash_iterator.rs

1use alloc::{vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
8
9use super::{HashMap, HashMapEntry};
10
11// abstract class java.util.HashMap$HashIterator
12pub struct HashMapHashIterator;
13
14impl HashMapHashIterator {
15    pub fn as_proto() -> RuntimeClassProto {
16        RuntimeClassProto {
17            name: "java/util/HashMap$HashIterator",
18            parent_class: Some("java/lang/Object"),
19            interfaces: vec!["java/util/Iterator"],
20            methods: vec![
21                JavaMethodProto::new(
22                    "<init>",
23                    "(Ljava/util/HashMap;[Ljava/lang/Object;)V",
24                    Self::init,
25                    MethodAccessFlags::empty(),
26                ),
27                JavaMethodProto::new("hasNext", "()Z", Self::has_next, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
28                JavaMethodProto::new("next", "()Ljava/lang/Object;", Self::next, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new("remove", "()V", Self::remove, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
30            ],
31            fields: vec![
32                JavaFieldProto::new("map", "Ljava/util/HashMap;", FieldAccessFlags::PRIVATE),
33                JavaFieldProto::new("lastReturned", "Ljava/util/HashMap$Entry;", FieldAccessFlags::PRIVATE),
34                JavaFieldProto::new("elements", "[Ljava/lang/Object;", FieldAccessFlags::PRIVATE),
35                JavaFieldProto::new("index", "I", FieldAccessFlags::empty()),
36            ],
37            access_flags: ClassAccessFlags::ABSTRACT,
38        }
39    }
40
41    async fn init(
42        jvm: &Jvm,
43        _: &mut RuntimeContext,
44        mut this: ClassInstanceRef<Self>,
45        map: ClassInstanceRef<HashMap>,
46        elements: ClassInstanceRef<Array<Object>>,
47    ) -> Result<()> {
48        tracing::debug!("java.util.HashMap$HashIterator::<init>({this:?}, {elements:?})");
49
50        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
51
52        jvm.put_field(&mut this, "java/util/HashMap$HashIterator", "map", "Ljava/util/HashMap;", map)
53            .await?;
54        jvm.put_field(&mut this, "java/util/HashMap$HashIterator", "elements", "[Ljava/lang/Object;", elements)
55            .await?;
56        jvm.put_field(&mut this, "java/util/HashMap$HashIterator", "index", "I", 0).await?;
57
58        Ok(())
59    }
60
61    async fn has_next(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
62        tracing::debug!("java.util.HashMap$HashIterator::hasNext({this:?})");
63
64        let elements: ClassInstanceRef<Array<Object>> = jvm
65            .get_field(&this, "java/util/HashMap$HashIterator", "elements", "[Ljava/lang/Object;")
66            .await?;
67        let index: i32 = jvm.get_field(&this, "java/util/HashMap$HashIterator", "index", "I").await?;
68        if index < 0 {
69            return Ok(false);
70        }
71
72        Ok((index as usize) < jvm.array_length(&elements).await?)
73    }
74
75    async fn next(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
76        tracing::debug!("java.util.HashMap$HashIterator::next({this:?})");
77
78        let elements: ClassInstanceRef<Array<Object>> = jvm
79            .get_field(&this, "java/util/HashMap$HashIterator", "elements", "[Ljava/lang/Object;")
80            .await?;
81        let index: i32 = jvm.get_field(&this, "java/util/HashMap$HashIterator", "index", "I").await?;
82        if index < 0 || index as usize >= jvm.array_length(&elements).await? {
83            return Err(jvm.exception("java/util/NoSuchElementException", "HashMap iterator exhausted").await);
84        }
85
86        let mut values: Vec<ClassInstanceRef<Object>> = jvm.load_array(&elements, index as usize, 1).await?;
87        let Some(element) = values.pop() else {
88            return Err(jvm.exception("java/util/NoSuchElementException", "HashMap iterator exhausted").await);
89        };
90        jvm.put_field(&mut this, "java/util/HashMap$HashIterator", "index", "I", index + 1)
91            .await?;
92        jvm.put_field(
93            &mut this,
94            "java/util/HashMap$HashIterator",
95            "lastReturned",
96            "Ljava/util/HashMap$Entry;",
97            element.clone(),
98        )
99        .await?;
100
101        Ok(element)
102    }
103
104    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
105        tracing::debug!("java.util.HashMap$HashIterator::remove({this:?})");
106
107        let entry: ClassInstanceRef<HashMapEntry> = jvm
108            .get_field(&this, "java/util/HashMap$HashIterator", "lastReturned", "Ljava/util/HashMap$Entry;")
109            .await?;
110        if entry.is_null() {
111            return Err(jvm.exception("java/lang/IllegalStateException", "No entry to remove").await);
112        }
113        let map = jvm
114            .get_field(&this, "java/util/HashMap$HashIterator", "map", "Ljava/util/HashMap;")
115            .await?;
116        let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "java/util/HashMap$Entry", "key", "Ljava/lang/Object;").await?;
117        let _: ClassInstanceRef<Object> = jvm
118            .invoke_virtual(&map, "java/util/HashMap", "remove", "(Ljava/lang/Object;)Ljava/lang/Object;", (key,))
119            .await?;
120        let null_entry: ClassInstanceRef<HashMapEntry> = None.into();
121        jvm.put_field(
122            &mut this,
123            "java/util/HashMap$HashIterator",
124            "lastReturned",
125            "Ljava/util/HashMap$Entry;",
126            null_entry,
127        )
128        .await
129    }
130}