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_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}