Skip to main content

rustjava_runtime/classes/java/util/
timer_task_queue.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::util::TimerTask};
8
9// class java.util.Timer$TaskQueue
10pub struct TimerTaskQueue;
11
12impl TimerTaskQueue {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/Timer$TaskQueue",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec![],
18            methods: vec![JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::empty())],
19            fields: vec![
20                JavaFieldProto::new("queue", "[Ljava/util/TimerTask;", FieldAccessFlags::PRIVATE),
21                JavaFieldProto::new("size", "I", FieldAccessFlags::PRIVATE),
22            ],
23            access_flags: ClassAccessFlags::empty(),
24        }
25    }
26
27    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
28        tracing::debug!("java.util.Timer$TaskQueue::<init>({this:?})");
29
30        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
31        let queue = jvm.instantiate_array("Ljava/util/TimerTask;", 128).await?;
32        jvm.put_field(&mut this, "queue", "[Ljava/util/TimerTask;", queue).await?;
33        Ok(())
34    }
35
36    pub(crate) async fn add(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, task: ClassInstanceRef<TimerTask>) -> Result<bool> {
37        let size: i32 = jvm.get_field(this, "size", "I").await?;
38        let mut queue: ClassInstanceRef<Array<TimerTask>> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?;
39        if size as usize + 1 == jvm.array_length(&queue).await? {
40            let old_length = jvm.array_length(&queue).await?;
41            let mut expanded: ClassInstanceRef<Array<TimerTask>> = jvm.instantiate_array("Ljava/util/TimerTask;", old_length * 2).await?.into();
42            let tasks: Vec<ClassInstanceRef<TimerTask>> = jvm.load_array(&queue, 0, size as usize + 1).await?;
43            jvm.store_array(&mut expanded, 0, tasks).await?;
44            queue = expanded;
45            jvm.put_field(this, "queue", "[Ljava/util/TimerTask;", queue.clone()).await?;
46        }
47
48        let mut child = size as usize + 1;
49        while child > 1 {
50            let parent = child / 2;
51            let parent_task: ClassInstanceRef<TimerTask> = jvm.load_array(&queue, parent, 1).await?.remove(0);
52            let parent_time: i64 = jvm.get_field(&parent_task, "nextExecutionTime", "J").await?;
53            let task_time: i64 = jvm.get_field(&task, "nextExecutionTime", "J").await?;
54            if parent_time <= task_time {
55                break;
56            }
57            jvm.store_array(&mut queue, child, core::iter::once(parent_task)).await?;
58            child = parent;
59        }
60        jvm.store_array(&mut queue, child, core::iter::once(task)).await?;
61        jvm.put_field(this, "size", "I", size + 1).await?;
62        Ok(child == 1)
63    }
64
65    pub(crate) async fn remove_min(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
66        let size: i32 = jvm.get_field(this, "size", "I").await?;
67        if size == 0 {
68            return Ok(());
69        }
70
71        let mut queue: ClassInstanceRef<Array<TimerTask>> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?;
72        let last: ClassInstanceRef<TimerTask> = jvm.load_array(&queue, size as usize, 1).await?.remove(0);
73        let null: ClassInstanceRef<TimerTask> = None.into();
74        jvm.store_array(&mut queue, size as usize, core::iter::once(null)).await?;
75        let new_size = size - 1;
76        jvm.put_field(this, "size", "I", new_size).await?;
77        if new_size == 0 {
78            return Ok(());
79        }
80
81        let last_time: i64 = jvm.get_field(&last, "nextExecutionTime", "J").await?;
82        let mut parent = 1usize;
83        while parent * 2 <= new_size as usize {
84            let mut child = parent * 2;
85            let mut child_task: ClassInstanceRef<TimerTask> = jvm.load_array(&queue, child, 1).await?.remove(0);
86            let mut child_time: i64 = jvm.get_field(&child_task, "nextExecutionTime", "J").await?;
87            if child < new_size as usize {
88                let right: ClassInstanceRef<TimerTask> = jvm.load_array(&queue, child + 1, 1).await?.remove(0);
89                let right_time: i64 = jvm.get_field(&right, "nextExecutionTime", "J").await?;
90                if right_time < child_time {
91                    child += 1;
92                    child_task = right;
93                    child_time = right_time;
94                }
95            }
96            if last_time <= child_time {
97                break;
98            }
99            jvm.store_array(&mut queue, parent, core::iter::once(child_task)).await?;
100            parent = child;
101        }
102        jvm.store_array(&mut queue, parent, core::iter::once(last)).await
103    }
104
105    pub(crate) async fn reschedule_min(jvm: &Jvm, this: &mut ClassInstanceRef<Self>, new_time: i64) -> Result<()> {
106        let mut queue: ClassInstanceRef<Array<TimerTask>> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?;
107        let mut task: ClassInstanceRef<TimerTask> = jvm.load_array(&queue, 1, 1).await?.remove(0);
108        jvm.put_field(&mut task, "nextExecutionTime", "J", new_time).await?;
109
110        let size: i32 = jvm.get_field(this, "size", "I").await?;
111        let mut parent = 1usize;
112        while parent * 2 <= size as usize {
113            let mut child = parent * 2;
114            let mut child_task: ClassInstanceRef<TimerTask> = jvm.load_array(&queue, child, 1).await?.remove(0);
115            let mut child_time: i64 = jvm.get_field(&child_task, "nextExecutionTime", "J").await?;
116            if child < size as usize {
117                let right: ClassInstanceRef<TimerTask> = jvm.load_array(&queue, child + 1, 1).await?.remove(0);
118                let right_time: i64 = jvm.get_field(&right, "nextExecutionTime", "J").await?;
119                if right_time < child_time {
120                    child += 1;
121                    child_task = right;
122                    child_time = right_time;
123                }
124            }
125            if new_time <= child_time {
126                break;
127            }
128            jvm.store_array(&mut queue, parent, core::iter::once(child_task)).await?;
129            parent = child;
130        }
131        jvm.store_array(&mut queue, parent, core::iter::once(task)).await
132    }
133
134    pub(crate) async fn clear(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
135        let size: i32 = jvm.get_field(this, "size", "I").await?;
136        if size > 0 {
137            let mut queue: ClassInstanceRef<Array<TimerTask>> = jvm.get_field(this, "queue", "[Ljava/util/TimerTask;").await?;
138            let nulls = core::iter::repeat_with(|| ClassInstanceRef::<TimerTask>::from(None)).take(size as usize);
139            jvm.store_array(&mut queue, 1, nulls).await?;
140            jvm.put_field(this, "size", "I", 0i32).await?;
141        }
142        Ok(())
143    }
144}