Skip to main content

rustjava_runtime/classes/java/util/
stack.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::JavaMethodProto;
5use jvm_types::{ClassAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
8
9// class java.util.Stack
10pub struct Stack;
11
12impl Stack {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/util/Stack",
16            parent_class: Some("java/util/Vector"),
17            interfaces: vec![],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
20                JavaMethodProto::new("empty", "()Z", Self::empty, MethodAccessFlags::PUBLIC),
21                JavaMethodProto::new(
22                    "peek",
23                    "()Ljava/lang/Object;",
24                    Self::peek,
25                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
26                ),
27                JavaMethodProto::new(
28                    "pop",
29                    "()Ljava/lang/Object;",
30                    Self::pop,
31                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
32                ),
33                JavaMethodProto::new("push", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::push, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new(
35                    "search",
36                    "(Ljava/lang/Object;)I",
37                    Self::search,
38                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
39                ),
40            ],
41            fields: vec![],
42            access_flags: ClassAccessFlags::PUBLIC,
43        }
44    }
45
46    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
47        tracing::warn!("java.util.Stack::<init>({this:?})");
48
49        let _: () = jvm.invoke_special(&this, "java/util/Vector", "<init>", "()V", ()).await?;
50
51        Ok(())
52    }
53
54    async fn empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
55        tracing::warn!("java.util.Stack::size({this:?})");
56
57        let size: i32 = jvm.invoke_virtual(&this, "java/util/Stack", "size", "()I", ()).await?;
58        let is_empty = size == 0;
59
60        Ok(is_empty)
61    }
62
63    async fn peek(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
64        tracing::warn!("java.util.Stack::peek({this:?})");
65
66        let size: i32 = jvm.invoke_virtual(&this, "java/util/Stack", "size", "()I", ()).await?;
67        if size == 0 {
68            return Err(jvm.exception("java/util/EmptyStackException", "").await);
69        }
70
71        let element = jvm
72            .invoke_virtual(&this, "java/util/Stack", "elementAt", "(I)Ljava/lang/Object;", (size - 1,))
73            .await?;
74        Ok(element)
75    }
76
77    async fn pop(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
78        tracing::warn!("java.util.Stack::pop({this:?})");
79
80        let size: i32 = jvm.invoke_virtual(&this, "java/util/Stack", "size", "()I", ()).await?;
81        let element = jvm.invoke_virtual(&this, "java/util/Stack", "peek", "()Ljava/lang/Object;", ()).await?;
82        let _: () = jvm
83            .invoke_virtual(&this, "java/util/Stack", "removeElementAt", "(I)V", (size - 1,))
84            .await?;
85
86        Ok(element)
87    }
88
89    async fn push(
90        jvm: &Jvm,
91        _: &mut RuntimeContext,
92        this: ClassInstanceRef<Self>,
93        element: ClassInstanceRef<Object>,
94    ) -> Result<ClassInstanceRef<Object>> {
95        tracing::warn!("java.util.Stack::push({this:?}, {element:?})");
96
97        let _: () = jvm
98            .invoke_virtual(&this, "java/util/Stack", "addElement", "(Ljava/lang/Object;)V", (element.clone(),))
99            .await?;
100
101        Ok(element)
102    }
103
104    async fn search(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, element: ClassInstanceRef<Object>) -> Result<i32> {
105        tracing::warn!("java.util.Stack::search({this:?}, {element:?})");
106
107        let i: i32 = jvm
108            .invoke_virtual(&this, "java/util/Stack", "lastIndexOf", "(Ljava/lang/Object;)I", (element,))
109            .await?;
110
111        if i >= 0 {
112            let size: i32 = jvm.invoke_virtual(&this, "java/util/Stack", "size", "()I", ()).await?;
113            Ok(size - i)
114        } else {
115            Ok(-1)
116        }
117    }
118}