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, "java/util/StringTokenizer", "str", "Ljava/lang/String;", string)
108            .await?;
109        jvm.put_field(&mut this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;", delimiters)
110            .await?;
111        jvm.put_field(&mut this, "java/util/StringTokenizer", "currentPosition", "I", 0).await?;
112        jvm.put_field(&mut this, "java/util/StringTokenizer", "maxPosition", "I", max_position)
113            .await?;
114        jvm.put_field(&mut this, "java/util/StringTokenizer", "returnDelimiters", "Z", return_delimiters)
115            .await
116    }
117
118    async fn has_more_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
119        tracing::debug!("java.util.StringTokenizer::hasMoreTokens({this:?})");
120
121        let string: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?;
122        let delimiters: ClassInstanceRef<String> = jvm
123            .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;")
124            .await?;
125        let position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?;
126        let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?;
127        let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?;
128        Ok(
129            Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters)
130                .await?
131                .is_some(),
132        )
133    }
134
135    async fn next_token(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
136        tracing::debug!("java.util.StringTokenizer::nextToken({this:?})");
137
138        let string: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?;
139        let delimiters: ClassInstanceRef<String> = jvm
140            .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;")
141            .await?;
142        let position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?;
143        let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?;
144        let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?;
145        let Some((start, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await?
146        else {
147            return Err(jvm.exception("java/util/NoSuchElementException", "StringTokenizer exhausted").await);
148        };
149
150        let token: ClassInstanceRef<String> = jvm
151            .invoke_virtual(
152                &string,
153                "java/lang/String",
154                "substring",
155                "(II)Ljava/lang/String;",
156                (start as i32, end as i32),
157            )
158            .await?;
159        jvm.put_field(&mut this, "java/util/StringTokenizer", "currentPosition", "I", end as i32)
160            .await?;
161        Ok(token)
162    }
163
164    async fn next_token_with_delimiters(
165        jvm: &Jvm,
166        _: &mut RuntimeContext,
167        mut this: ClassInstanceRef<Self>,
168        delimiters: ClassInstanceRef<String>,
169    ) -> Result<ClassInstanceRef<String>> {
170        tracing::debug!("java.util.StringTokenizer::nextToken({this:?}, {delimiters:?})");
171
172        jvm.put_field(&mut this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;", delimiters)
173            .await?;
174        jvm.invoke_virtual(&this, "java/util/StringTokenizer", "nextToken", "()Ljava/lang/String;", ())
175            .await
176    }
177
178    async fn count_tokens(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
179        tracing::debug!("java.util.StringTokenizer::countTokens({this:?})");
180
181        let string: ClassInstanceRef<String> = jvm.get_field(&this, "java/util/StringTokenizer", "str", "Ljava/lang/String;").await?;
182        let delimiters: ClassInstanceRef<String> = jvm
183            .get_field(&this, "java/util/StringTokenizer", "delimiters", "Ljava/lang/String;")
184            .await?;
185        let mut position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "currentPosition", "I").await?;
186        let max_position: i32 = jvm.get_field(&this, "java/util/StringTokenizer", "maxPosition", "I").await?;
187        let return_delimiters: bool = jvm.get_field(&this, "java/util/StringTokenizer", "returnDelimiters", "Z").await?;
188        let mut count = 0;
189        while let Some((_, end)) = Self::token_bounds(jvm, &string, &delimiters, position as usize, max_position as usize, return_delimiters).await? {
190            count += 1;
191            position = end as i32;
192        }
193        Ok(count)
194    }
195
196    async fn has_more_elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
197        jvm.invoke_virtual(&this, "java/util/StringTokenizer", "hasMoreTokens", "()Z", ()).await
198    }
199
200    async fn next_element(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
201        let token: ClassInstanceRef<String> = jvm
202            .invoke_virtual(&this, "java/util/StringTokenizer", "nextToken", "()Ljava/lang/String;", ())
203            .await?;
204        Ok(ClassInstanceRef::new(token.instance))
205    }
206
207    async fn token_bounds(
208        jvm: &Jvm,
209        string: &ClassInstanceRef<String>,
210        delimiters: &ClassInstanceRef<String>,
211        mut position: usize,
212        max_position: usize,
213        return_delimiters: bool,
214    ) -> Result<Option<(usize, usize)>> {
215        if delimiters.is_null() {
216            return Err(jvm.exception("java/lang/NullPointerException", "delimiters").await);
217        }
218
219        let string_chars = JavaLangString::to_utf16(jvm, string).await?;
220        let delimiter_chars = JavaLangString::to_utf16(jvm, delimiters).await?;
221        let max_position = max_position.min(string_chars.len());
222
223        if !return_delimiters {
224            while position < max_position && delimiter_chars.contains(&string_chars[position]) {
225                position += 1;
226            }
227        }
228        if position >= max_position {
229            return Ok(None);
230        }
231
232        let start = position;
233        if return_delimiters && delimiter_chars.contains(&string_chars[position]) {
234            return Ok(Some((start, start + 1)));
235        }
236        while position < max_position && !delimiter_chars.contains(&string_chars[position]) {
237            position += 1;
238        }
239        Ok(Some((start, position)))
240    }
241}