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
9pub 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, ¤t).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}