Skip to main content

rustjava_runtime/classes/java/util/
abstract_collection.rs

1use alloc::vec;
2
3use jvm::{Array, AsClassInstance, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
8
9// abstract class java.util.AbstractCollection
10pub struct AbstractCollection;
11
12impl AbstractCollection {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/AbstractCollection",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec!["java/util/Collection"],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
20                JavaMethodProto::new_abstract("size", "()I", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
21                JavaMethodProto::new("isEmpty", "()Z", Self::is_empty, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("contains", "(Ljava/lang/Object;)Z", Self::contains, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new_abstract(
24                    "iterator",
25                    "()Ljava/util/Iterator;",
26                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
27                ),
28                JavaMethodProto::new("toArray", "()[Ljava/lang/Object;", Self::to_array, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new(
30                    "toArray",
31                    "([Ljava/lang/Object;)[Ljava/lang/Object;",
32                    Self::to_typed_array,
33                    MethodAccessFlags::PUBLIC,
34                ),
35                JavaMethodProto::new("add", "(Ljava/lang/Object;)Z", Self::add, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("remove", "(Ljava/lang/Object;)Z", Self::remove, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new("containsAll", "(Ljava/util/Collection;)Z", Self::contains_all, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new("addAll", "(Ljava/util/Collection;)Z", Self::add_all, MethodAccessFlags::PUBLIC),
39                JavaMethodProto::new("removeAll", "(Ljava/util/Collection;)Z", Self::remove_all, MethodAccessFlags::PUBLIC),
40                JavaMethodProto::new("retainAll", "(Ljava/util/Collection;)Z", Self::retain_all, MethodAccessFlags::PUBLIC),
41                JavaMethodProto::new("clear", "()V", Self::clear, MethodAccessFlags::PUBLIC),
42                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
43            ],
44            fields: vec![],
45            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
46        }
47    }
48
49    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
50        tracing::debug!("java.util.AbstractCollection::<init>({this:?})");
51
52        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
53
54        Ok(())
55    }
56
57    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
58        tracing::debug!("java.util.AbstractCollection::isEmpty({this:?})");
59
60        let size: i32 = jvm.invoke_virtual(&this, "java/util/AbstractCollection", "size", "()I", ()).await?;
61
62        Ok(size == 0)
63    }
64
65    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
66        tracing::debug!("java.util.AbstractCollection::contains({this:?}, {element:?})");
67
68        let iterator: ClassInstanceRef<Object> = jvm
69            .invoke_virtual(&this, "java/util/AbstractCollection", "iterator", "()Ljava/util/Iterator;", ())
70            .await?;
71        loop {
72            let has_next: bool = jvm
73                .invoke_virtual(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
74                .await?;
75            if !has_next {
76                return Ok(false);
77            }
78
79            let current: ClassInstanceRef<Object> = jvm
80                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
81                .await?;
82            if Self::object_equals(jvm, &element, &current).await? {
83                return Ok(true);
84            }
85        }
86    }
87
88    async fn to_array(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
89        tracing::debug!("java.util.AbstractCollection::toArray({this:?})");
90
91        let iterator: ClassInstanceRef<Object> = jvm
92            .invoke_virtual(&this, "java/util/AbstractCollection", "iterator", "()Ljava/util/Iterator;", ())
93            .await?;
94        let mut elements = vec![];
95        loop {
96            let has_next: bool = jvm
97                .invoke_virtual(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
98                .await?;
99            if !has_next {
100                break;
101            }
102
103            let current: ClassInstanceRef<Object> = jvm
104                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
105                .await?;
106            elements.push(current);
107        }
108
109        let mut array: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
110        if !elements.is_empty() {
111            jvm.store_array(&mut array, 0, elements).await?;
112        }
113
114        Ok(array)
115    }
116
117    async fn to_typed_array(
118        jvm: &Jvm,
119        _: &mut RuntimeContext,
120        this: ClassInstanceRef<Self>,
121        destination: ClassInstanceRef<Array<Object>>,
122    ) -> Result<ClassInstanceRef<Array<Object>>> {
123        tracing::debug!("java.util.AbstractCollection::toArray({this:?}, {destination:?})");
124
125        if destination.is_null() {
126            return Err(jvm.exception("java/lang/NullPointerException", "array").await);
127        }
128
129        let snapshot: ClassInstanceRef<Array<Object>> = jvm
130            .invoke_virtual(&this, "java/util/AbstractCollection", "toArray", "()[Ljava/lang/Object;", ())
131            .await?;
132        let size = jvm.array_length(&snapshot).await?;
133        let elements: alloc::vec::Vec<ClassInstanceRef<Object>> = if size == 0 {
134            alloc::vec::Vec::new()
135        } else {
136            jvm.load_array(&snapshot, 0, size).await?
137        };
138        let destination_length = jvm.array_length(&destination).await?;
139        let mut result = if destination_length < size {
140            let class_name = destination.class_definition().name();
141            let component_descriptor = class_name.strip_prefix('[').unwrap();
142            ClassInstanceRef::from(jvm.instantiate_array(component_descriptor, size).await?)
143        } else {
144            destination
145        };
146
147        for (index, element) in elements.into_iter().enumerate() {
148            if !element.is_null() && !jvm.array_store_allowed(result.as_class_instance(), element.as_class_instance()) {
149                return Err(jvm.exception("java/lang/ArrayStoreException", &element.class_definition().name()).await);
150            }
151            jvm.store_array(&mut result, index, core::iter::once(element)).await?;
152        }
153        if destination_length > size {
154            let null: ClassInstanceRef<Object> = None.into();
155            jvm.store_array(&mut result, size, core::iter::once(null)).await?;
156        }
157
158        Ok(result)
159    }
160
161    async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
162        tracing::debug!("java.util.AbstractCollection::add({this:?}, {element:?})");
163
164        Err(jvm.exception("java/lang/UnsupportedOperationException", "AbstractCollection.add").await)
165    }
166
167    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
168        tracing::debug!("java.util.AbstractCollection::remove({this:?}, {element:?})");
169
170        Err(jvm
171            .exception("java/lang/UnsupportedOperationException", "AbstractCollection.remove")
172            .await)
173    }
174
175    async fn contains_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
176        tracing::debug!("java.util.AbstractCollection::containsAll({this:?}, {collection:?})");
177
178        if collection.is_null() {
179            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
180        }
181
182        let elements: ClassInstanceRef<Array<Object>> = jvm
183            .invoke_virtual(&collection, &collection.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
184            .await?;
185        let size = jvm.array_length(&elements).await?;
186        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
187            let contains: bool = jvm
188                .invoke_virtual(&this, "java/util/AbstractCollection", "contains", "(Ljava/lang/Object;)Z", (element,))
189                .await?;
190            if !contains {
191                return Ok(false);
192            }
193        }
194
195        Ok(true)
196    }
197
198    async fn add_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
199        tracing::debug!("java.util.AbstractCollection::addAll({this:?}, {collection:?})");
200
201        if collection.is_null() {
202            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
203        }
204
205        let elements: ClassInstanceRef<Array<Object>> = jvm
206            .invoke_virtual(&collection, &collection.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
207            .await?;
208        let size = jvm.array_length(&elements).await?;
209        let mut modified = false;
210        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
211            modified |= jvm
212                .invoke_virtual::<_, bool>(&this, "java/util/AbstractCollection", "add", "(Ljava/lang/Object;)Z", (element,))
213                .await?;
214        }
215
216        Ok(modified)
217    }
218
219    async fn remove_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
220        tracing::debug!("java.util.AbstractCollection::removeAll({this:?}, {collection:?})");
221
222        if collection.is_null() {
223            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
224        }
225
226        let elements: ClassInstanceRef<Array<Object>> = jvm
227            .invoke_virtual(&this, "java/util/AbstractCollection", "toArray", "()[Ljava/lang/Object;", ())
228            .await?;
229        let size = jvm.array_length(&elements).await?;
230        let same_collection = this.identity() == collection.identity();
231        let mut modified = false;
232        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
233            let remove = if same_collection {
234                true
235            } else {
236                jvm.invoke_virtual(
237                    &collection,
238                    &collection.class_definition().name(),
239                    "contains",
240                    "(Ljava/lang/Object;)Z",
241                    (element.clone(),),
242                )
243                .await?
244            };
245            if remove {
246                while jvm
247                    .invoke_virtual::<_, bool>(
248                        &this,
249                        "java/util/AbstractCollection",
250                        "remove",
251                        "(Ljava/lang/Object;)Z",
252                        (element.clone(),),
253                    )
254                    .await?
255                {
256                    modified = true;
257                }
258            }
259        }
260
261        Ok(modified)
262    }
263
264    async fn retain_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
265        tracing::debug!("java.util.AbstractCollection::retainAll({this:?}, {collection:?})");
266
267        if collection.is_null() {
268            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
269        }
270        if this.identity() == collection.identity() {
271            return Ok(false);
272        }
273
274        let elements: ClassInstanceRef<Array<Object>> = jvm
275            .invoke_virtual(&this, "java/util/AbstractCollection", "toArray", "()[Ljava/lang/Object;", ())
276            .await?;
277        let size = jvm.array_length(&elements).await?;
278        let mut modified = false;
279        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
280            let retain: bool = jvm
281                .invoke_virtual(
282                    &collection,
283                    &collection.class_definition().name(),
284                    "contains",
285                    "(Ljava/lang/Object;)Z",
286                    (element.clone(),),
287                )
288                .await?;
289            if !retain {
290                while jvm
291                    .invoke_virtual::<_, bool>(
292                        &this,
293                        "java/util/AbstractCollection",
294                        "remove",
295                        "(Ljava/lang/Object;)Z",
296                        (element.clone(),),
297                    )
298                    .await?
299                {
300                    modified = true;
301                }
302            }
303        }
304
305        Ok(modified)
306    }
307
308    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
309        tracing::debug!("java.util.AbstractCollection::clear({this:?})");
310
311        Err(jvm.exception("java/lang/UnsupportedOperationException", "AbstractCollection.clear").await)
312    }
313
314    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
315        let buffer: ClassInstanceRef<Object> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
316        let open = JavaLangString::from_rust_string(jvm, "[").await?;
317        let _: ClassInstanceRef<Object> = jvm
318            .invoke_virtual(
319                &buffer,
320                "java/lang/StringBuffer",
321                "append",
322                "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
323                (open,),
324            )
325            .await?;
326        let iterator: ClassInstanceRef<Object> = jvm
327            .invoke_virtual(&this, "java/util/AbstractCollection", "iterator", "()Ljava/util/Iterator;", ())
328            .await?;
329        let mut first = true;
330        while jvm
331            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
332            .await?
333        {
334            if first {
335                first = false;
336            } else {
337                let separator = JavaLangString::from_rust_string(jvm, ", ").await?;
338                let _: ClassInstanceRef<Object> = jvm
339                    .invoke_virtual(
340                        &buffer,
341                        "java/lang/StringBuffer",
342                        "append",
343                        "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
344                        (separator,),
345                    )
346                    .await?;
347            }
348            let element: ClassInstanceRef<Object> = jvm
349                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
350                .await?;
351            if !element.is_null() && element.identity() == this.identity() {
352                let recursive = JavaLangString::from_rust_string(jvm, "(this Collection)").await?;
353                let _: ClassInstanceRef<Object> = jvm
354                    .invoke_virtual(
355                        &buffer,
356                        "java/lang/StringBuffer",
357                        "append",
358                        "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
359                        (recursive,),
360                    )
361                    .await?;
362            } else {
363                let _: ClassInstanceRef<Object> = jvm
364                    .invoke_virtual(
365                        &buffer,
366                        "java/lang/StringBuffer",
367                        "append",
368                        "(Ljava/lang/Object;)Ljava/lang/StringBuffer;",
369                        (element,),
370                    )
371                    .await?;
372            }
373        }
374        let close = JavaLangString::from_rust_string(jvm, "]").await?;
375        let _: ClassInstanceRef<Object> = jvm
376            .invoke_virtual(
377                &buffer,
378                "java/lang/StringBuffer",
379                "append",
380                "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
381                (close,),
382            )
383            .await?;
384        jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
385            .await
386    }
387
388    async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
389        if left.is_null() {
390            return Ok(right.is_null());
391        }
392
393        if right.is_null() {
394            return Ok(false);
395        }
396
397        jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
398            .await
399    }
400}