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_definition = destination.class_definition();
141            let class_name = class_definition.name();
142            let component_descriptor = class_name.strip_prefix('[').unwrap();
143            ClassInstanceRef::from(jvm.instantiate_array(component_descriptor, size).await?)
144        } else {
145            destination
146        };
147
148        for (index, element) in elements.into_iter().enumerate() {
149            if !element.is_null() && !jvm.array_store_allowed(result.as_class_instance(), element.as_class_instance()) {
150                return Err(jvm.exception("java/lang/ArrayStoreException", &element.class_definition().name()).await);
151            }
152            jvm.store_array(&mut result, index, core::iter::once(element)).await?;
153        }
154        if destination_length > size {
155            let null: ClassInstanceRef<Object> = None.into();
156            jvm.store_array(&mut result, size, core::iter::once(null)).await?;
157        }
158
159        Ok(result)
160    }
161
162    async fn add(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
163        tracing::debug!("java.util.AbstractCollection::add({this:?}, {element:?})");
164
165        Err(jvm.exception("java/lang/UnsupportedOperationException", "AbstractCollection.add").await)
166    }
167
168    async fn remove(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<bool> {
169        tracing::debug!("java.util.AbstractCollection::remove({this:?}, {element:?})");
170
171        Err(jvm
172            .exception("java/lang/UnsupportedOperationException", "AbstractCollection.remove")
173            .await)
174    }
175
176    async fn contains_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
177        tracing::debug!("java.util.AbstractCollection::containsAll({this:?}, {collection:?})");
178
179        if collection.is_null() {
180            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
181        }
182
183        let elements: ClassInstanceRef<Array<Object>> = jvm
184            .invoke_virtual(&collection, &collection.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
185            .await?;
186        let size = jvm.array_length(&elements).await?;
187        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
188            let contains: bool = jvm
189                .invoke_virtual(&this, "java/util/AbstractCollection", "contains", "(Ljava/lang/Object;)Z", (element,))
190                .await?;
191            if !contains {
192                return Ok(false);
193            }
194        }
195
196        Ok(true)
197    }
198
199    async fn add_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
200        tracing::debug!("java.util.AbstractCollection::addAll({this:?}, {collection:?})");
201
202        if collection.is_null() {
203            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
204        }
205
206        let elements: ClassInstanceRef<Array<Object>> = jvm
207            .invoke_virtual(&collection, &collection.class_definition().name(), "toArray", "()[Ljava/lang/Object;", ())
208            .await?;
209        let size = jvm.array_length(&elements).await?;
210        let mut modified = false;
211        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
212            modified |= jvm
213                .invoke_virtual::<_, bool>(&this, "java/util/AbstractCollection", "add", "(Ljava/lang/Object;)Z", (element,))
214                .await?;
215        }
216
217        Ok(modified)
218    }
219
220    async fn remove_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
221        tracing::debug!("java.util.AbstractCollection::removeAll({this:?}, {collection:?})");
222
223        if collection.is_null() {
224            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
225        }
226
227        let elements: ClassInstanceRef<Array<Object>> = jvm
228            .invoke_virtual(&this, "java/util/AbstractCollection", "toArray", "()[Ljava/lang/Object;", ())
229            .await?;
230        let size = jvm.array_length(&elements).await?;
231        let same_collection = this.identity() == collection.identity();
232        let mut modified = false;
233        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
234            let remove = if same_collection {
235                true
236            } else {
237                jvm.invoke_virtual(
238                    &collection,
239                    &collection.class_definition().name(),
240                    "contains",
241                    "(Ljava/lang/Object;)Z",
242                    (element.clone(),),
243                )
244                .await?
245            };
246            if remove {
247                while jvm
248                    .invoke_virtual::<_, bool>(
249                        &this,
250                        "java/util/AbstractCollection",
251                        "remove",
252                        "(Ljava/lang/Object;)Z",
253                        (element.clone(),),
254                    )
255                    .await?
256                {
257                    modified = true;
258                }
259            }
260        }
261
262        Ok(modified)
263    }
264
265    async fn retain_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, collection: ClassInstanceRef<Object>) -> Result<bool> {
266        tracing::debug!("java.util.AbstractCollection::retainAll({this:?}, {collection:?})");
267
268        if collection.is_null() {
269            return Err(jvm.exception("java/lang/NullPointerException", "collection").await);
270        }
271        if this.identity() == collection.identity() {
272            return Ok(false);
273        }
274
275        let elements: ClassInstanceRef<Array<Object>> = jvm
276            .invoke_virtual(&this, "java/util/AbstractCollection", "toArray", "()[Ljava/lang/Object;", ())
277            .await?;
278        let size = jvm.array_length(&elements).await?;
279        let mut modified = false;
280        for element in jvm.load_array::<ClassInstanceRef<Object>>(&elements, 0, size).await? {
281            let retain: bool = jvm
282                .invoke_virtual(
283                    &collection,
284                    &collection.class_definition().name(),
285                    "contains",
286                    "(Ljava/lang/Object;)Z",
287                    (element.clone(),),
288                )
289                .await?;
290            if !retain {
291                while jvm
292                    .invoke_virtual::<_, bool>(
293                        &this,
294                        "java/util/AbstractCollection",
295                        "remove",
296                        "(Ljava/lang/Object;)Z",
297                        (element.clone(),),
298                    )
299                    .await?
300                {
301                    modified = true;
302                }
303            }
304        }
305
306        Ok(modified)
307    }
308
309    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
310        tracing::debug!("java.util.AbstractCollection::clear({this:?})");
311
312        Err(jvm.exception("java/lang/UnsupportedOperationException", "AbstractCollection.clear").await)
313    }
314
315    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
316        let buffer: ClassInstanceRef<Object> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
317        let open = JavaLangString::from_rust_string(jvm, "[").await?;
318        let _: ClassInstanceRef<Object> = jvm
319            .invoke_virtual(
320                &buffer,
321                "java/lang/StringBuffer",
322                "append",
323                "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
324                (open,),
325            )
326            .await?;
327        let iterator: ClassInstanceRef<Object> = jvm
328            .invoke_virtual(&this, "java/util/AbstractCollection", "iterator", "()Ljava/util/Iterator;", ())
329            .await?;
330        let mut first = true;
331        while jvm
332            .invoke_virtual::<_, bool>(&iterator, &iterator.class_definition().name(), "hasNext", "()Z", ())
333            .await?
334        {
335            if first {
336                first = false;
337            } else {
338                let separator = JavaLangString::from_rust_string(jvm, ", ").await?;
339                let _: ClassInstanceRef<Object> = jvm
340                    .invoke_virtual(
341                        &buffer,
342                        "java/lang/StringBuffer",
343                        "append",
344                        "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
345                        (separator,),
346                    )
347                    .await?;
348            }
349            let element: ClassInstanceRef<Object> = jvm
350                .invoke_virtual(&iterator, &iterator.class_definition().name(), "next", "()Ljava/lang/Object;", ())
351                .await?;
352            if !element.is_null() && element.identity() == this.identity() {
353                let recursive = JavaLangString::from_rust_string(jvm, "(this Collection)").await?;
354                let _: ClassInstanceRef<Object> = jvm
355                    .invoke_virtual(
356                        &buffer,
357                        "java/lang/StringBuffer",
358                        "append",
359                        "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
360                        (recursive,),
361                    )
362                    .await?;
363            } else {
364                let _: ClassInstanceRef<Object> = jvm
365                    .invoke_virtual(
366                        &buffer,
367                        "java/lang/StringBuffer",
368                        "append",
369                        "(Ljava/lang/Object;)Ljava/lang/StringBuffer;",
370                        (element,),
371                    )
372                    .await?;
373            }
374        }
375        let close = JavaLangString::from_rust_string(jvm, "]").await?;
376        let _: ClassInstanceRef<Object> = jvm
377            .invoke_virtual(
378                &buffer,
379                "java/lang/StringBuffer",
380                "append",
381                "(Ljava/lang/String;)Ljava/lang/StringBuffer;",
382                (close,),
383            )
384            .await?;
385        jvm.invoke_virtual(&buffer, "java/lang/Object", "toString", "()Ljava/lang/String;", ())
386            .await
387    }
388
389    async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
390        if left.is_null() {
391            return Ok(right.is_null());
392        }
393
394        if right.is_null() {
395            return Ok(false);
396        }
397
398        jvm.invoke_virtual(left, "java/lang/Object", "equals", "(Ljava/lang/Object;)Z", (right.clone(),))
399            .await
400    }
401}