Skip to main content

rustjava_runtime/classes/java/util/
string_tokenizer.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::lang::{Object, String},
10};
11
12// class java.util.StringTokenizer
13pub struct StringTokenizer;
14
15impl StringTokenizer {
16    pub fn as_proto() -> RuntimeClassProto {
17        RuntimeClassProto {
18            name: "java/util/StringTokenizer",
19            parent_class: Some("java/lang/Object"),
20            interfaces: vec!["java/util/Enumeration"],
21            methods: vec![
22                JavaMethodProto::new("<init>", "(Ljava/lang/String;)V", Self::init, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new(
24                    "<init>",
25                    "(Ljava/lang/String;Ljava/lang/String;)V",
26                    Self::init_with_delimiters,
27                    MethodAccessFlags::PUBLIC,
28                ),
29                JavaMethodProto::new(
30                    "<init>",
31                    "(Ljava/lang/String;Ljava/lang/String;Z)V",
32                    Self::init_with_delimiters_and_return,
33                    MethodAccessFlags::PUBLIC,
34                ),
35                JavaMethodProto::new("hasMoreTokens", "()Z", Self::has_more_tokens, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("nextToken", "()Ljava/lang/String;", Self::next_token, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new(
38                    "nextToken",
39                    "(Ljava/lang/String;)Ljava/lang/String;",
40                    Self::next_token_with_delimiters,
41                    MethodAccessFlags::PUBLIC,
42                ),
43                JavaMethodProto::new("countTokens", "()I", Self::count_tokens, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new("hasMoreElements", "()Z", Self::has_more_elements, MethodAccessFlags::PUBLIC),
45                JavaMethodProto::new("nextElement", "()Ljava/lang/Object;", Self::next_element, MethodAccessFlags::PUBLIC),
46            ],
47            fields: vec![
48                JavaFieldProto::new("str", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
49                JavaFieldProto::new("delimiters", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
50                JavaFieldProto::new("currentPosition", "I", FieldAccessFlags::PRIVATE),
51                JavaFieldProto::new("maxPosition", "I", FieldAccessFlags::PRIVATE),
52                JavaFieldProto::new("returnDelimiters", "Z", FieldAccessFlags::PRIVATE),
53            ],
54            access_flags: ClassAccessFlags::PUBLIC,
55        }
56    }
57
58    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
59        tracing::debug!("java.util.StringTokenizer::<init>({this:?}, {string:?})");
60
61        let delimiters = JavaLangString::from_rust_string(jvm, " \t\n\r\u{000c}").await?;
62        jvm.invoke_special(
63            &this,
64            "java/util/StringTokenizer",
65            "<init>",
66            "(Ljava/lang/String;Ljava/lang/String;Z)V",
67            (string, delimiters, false),
68        )
69        .await
70    }
71
72    async fn init_with_delimiters(
73        jvm: &Jvm,
74        _: &mut RuntimeContext,
75        this: ClassInstanceRef<Self>,
76        string: ClassInstanceRef<String>,
77        delimiters: ClassInstanceRef<String>,
78    ) -> Result<()> {
79        tracing::debug!("java.util.StringTokenizer::<init>({this:?}, {string:?}, {delimiters:?})");
80
81        jvm.invoke_special(
82            &this,
83            "java/util/StringTokenizer",
84            "<init>",
85            "(Ljava/lang/String;Ljava/lang/String;Z)V",
86            (string, delimiters, false),
87        )
88        .await
89    }
90
91    async fn init_with_delimiters_and_return(
92        jvm: &Jvm,
93        _: &mut RuntimeContext,
94        mut this: ClassInstanceRef<Self>,
95        string: ClassInstanceRef<String>,
96        delimiters: ClassInstanceRef<String>,
97        return_delimiters: bool,
98    ) -> Result<()> {
99        tracing::debug!("java.util.StringTokenizer::<init>({this:?}, {string:?}, {delimiters:?}, {return_delimiters:?})");
100
101        if string.is_null() {
102            return Err(jvm.exception("java/lang/NullPointerException", "str").await);
103        }
104
105        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
106        let max_position: i32 = jvm.invoke_virtual(&string, "java/lang/String", "length", "()I", ()).await?;
107        jvm.put_field(&mut this, "str", "Ljava/lang/String;", string).await?;
108        jvm.put_field(&mut this, "delimiters", "Ljava/lang/String;", delimiters).await?;
109        jvm.put_field(&mut this, "currentPosition", "I", 0).await?;
110        jvm.put_field(&mut this, "maxPosition", "I", max_position).await?;
111        jvm.put_field(&mut this, "returnDelimiters", "Z", return_delimiters).await
112    }
113
114    async fn has_more_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
115        tracing::debug!("java.util.StringTokenizer::hasMoreTokens({this:?})");
116
117        let string: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
118        let delimiters: ClassInstanceRef<String> = jvm.get_field(&this, "delimiters", "Ljava/lang/String;").await?;
119        let position: i32 = jvm.get_field(&this, "currentPosition", "I").await?;
120        let max_position: i32 = jvm.get_field(&this, "maxPosition", "I").await?;
121        let return_delimiters: bool = jvm.get_field(&this, "returnDelimiters", "Z").await?;
122        Ok(
123            Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters)
124                .await?
125                .is_some(),
126        )
127    }
128
129    async fn next_token(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
130        tracing::debug!("java.util.StringTokenizer::nextToken({this:?})");
131
132        let string: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
133        let delimiters: ClassInstanceRef<String> = jvm.get_field(&this, "delimiters", "Ljava/lang/String;").await?;
134        let position: i32 = jvm.get_field(&this, "currentPosition", "I").await?;
135        let max_position: i32 = jvm.get_field(&this, "maxPosition", "I").await?;
136        let return_delimiters: bool = jvm.get_field(&this, "returnDelimiters", "Z").await?;
137        let Some((start, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await?
138        else {
139            return Err(jvm.exception("java/util/NoSuchElementException", "StringTokenizer exhausted").await);
140        };
141
142        let token: ClassInstanceRef<String> = jvm
143            .invoke_virtual(
144                &string,
145                "java/lang/String",
146                "substring",
147                "(II)Ljava/lang/String;",
148                (start as i32, end as i32),
149            )
150            .await?;
151        jvm.put_field(&mut this, "currentPosition", "I", end as i32).await?;
152        Ok(token)
153    }
154
155    async fn next_token_with_delimiters(
156        jvm: &Jvm,
157        _: &mut RuntimeContext,
158        mut this: ClassInstanceRef<Self>,
159        delimiters: ClassInstanceRef<String>,
160    ) -> Result<ClassInstanceRef<String>> {
161        tracing::debug!("java.util.StringTokenizer::nextToken({this:?}, {delimiters:?})");
162
163        jvm.put_field(&mut this, "delimiters", "Ljava/lang/String;", delimiters).await?;
164        jvm.invoke_virtual(&this, "java/util/StringTokenizer", "nextToken", "()Ljava/lang/String;", ())
165            .await
166    }
167
168    async fn count_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
169        tracing::debug!("java.util.StringTokenizer::countTokens({this:?})");
170
171        let string: ClassInstanceRef<String> = jvm.get_field(&this, "str", "Ljava/lang/String;").await?;
172        let delimiters: ClassInstanceRef<String> = jvm.get_field(&this, "delimiters", "Ljava/lang/String;").await?;
173        let mut position: i32 = jvm.get_field(&this, "currentPosition", "I").await?;
174        let max_position: i32 = jvm.get_field(&this, "maxPosition", "I").await?;
175        let return_delimiters: bool = jvm.get_field(&this, "returnDelimiters", "Z").await?;
176        let mut count = 0;
177        while let Some((_, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await? {
178            count += 1;
179            position = end as i32;
180        }
181        Ok(count)
182    }
183
184    async fn has_more_elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
185        jvm.invoke_virtual(&this, "java/util/StringTokenizer", "hasMoreTokens", "()Z", ()).await
186    }
187
188    async fn next_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
189        let token: ClassInstanceRef<String> = jvm
190            .invoke_virtual(&this, "java/util/StringTokenizer", "nextToken", "()Ljava/lang/String;", ())
191            .await?;
192        Ok(ClassInstanceRef::new(token.instance))
193    }
194
195    async fn token_bounds(
196        jvm: &Jvm,
197        string: &ClassInstanceRef<String>,
198        delimiters: &ClassInstanceRef<String>,
199        mut position: usize,
200        max_position: usize,
201        return_delimiters: bool,
202    ) -> Result<Option<(usize, usize)>> {
203        if delimiters.is_null() {
204            return Err(jvm.exception("java/lang/NullPointerException", "delimiters").await);
205        }
206
207        let string_chars = JavaLangString::to_utf16(jvm, string).await?;
208        let delimiter_chars = JavaLangString::to_utf16(jvm, delimiters).await?;
209        let max_position = max_position.min(string_chars.len());
210
211        if !return_delimiters {
212            while position < max_position && delimiter_chars.contains(&string_chars[position]) {
213                position += 1;
214            }
215        }
216        if position >= max_position {
217            return Ok(None);
218        }
219
220        let start = position;
221        if return_delimiters && delimiter_chars.contains(&string_chars[position]) {
222            return Ok(Some((start, start + 1)));
223        }
224        while position < max_position && !delimiter_chars.contains(&string_chars[position]) {
225            position += 1;
226        }
227        Ok(Some((start, position)))
228    }
229}