Skip to main content

rustjava_runtime/classes/java/io/
writer.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, JavaChar, 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::{CharSequence, Object, String},
10};
11
12// abstract class java.io.Writer
13pub struct Writer;
14
15impl Writer {
16    pub fn as_proto() -> RuntimeClassProto {
17        RuntimeClassProto {
18            name: "java/io/Writer",
19            parent_class: Some("java/lang/Object"),
20            interfaces: vec!["java/lang/Appendable", "java/io/Closeable", "java/io/Flushable"],
21            methods: vec![
22                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
23                JavaMethodProto::new("<init>", "(Ljava/lang/Object;)V", Self::init_with_lock, MethodAccessFlags::PROTECTED),
24                JavaMethodProto::new("write", "(I)V", Self::write_char, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("write", "([C)V", Self::write_chars, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new_abstract("write", "([CII)V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
27                JavaMethodProto::new("write", "(Ljava/lang/String;)V", Self::write_string, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("write", "(Ljava/lang/String;II)V", Self::write_string_offset, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new(
30                    "append",
31                    "(Ljava/lang/CharSequence;)Ljava/io/Writer;",
32                    Self::append_char_sequence,
33                    MethodAccessFlags::PUBLIC,
34                ),
35                JavaMethodProto::new(
36                    "append",
37                    "(Ljava/lang/CharSequence;II)Ljava/io/Writer;",
38                    Self::append_char_sequence_range,
39                    MethodAccessFlags::PUBLIC,
40                ),
41                JavaMethodProto::new("append", "(C)Ljava/io/Writer;", Self::append_char, MethodAccessFlags::PUBLIC),
42                JavaMethodProto::new(
43                    "append",
44                    "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
45                    Self::append_char_sequence,
46                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
47                ),
48                JavaMethodProto::new(
49                    "append",
50                    "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
51                    Self::append_char_sequence_range,
52                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
53                ),
54                JavaMethodProto::new(
55                    "append",
56                    "(C)Ljava/lang/Appendable;",
57                    Self::append_char,
58                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
59                ),
60                JavaMethodProto::new_abstract("flush", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
61                JavaMethodProto::new_abstract("close", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
62            ],
63            fields: vec![JavaFieldProto::new("lock", "Ljava/lang/Object;", FieldAccessFlags::PROTECTED)],
64            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
65        }
66    }
67
68    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
69        tracing::debug!("java.io.Writer::<init>({this:?})");
70
71        let _: () = jvm
72            .invoke_special(&this, "java/io/Writer", "<init>", "(Ljava/lang/Object;)V", (this.clone(),))
73            .await?;
74
75        Ok(())
76    }
77
78    async fn init_with_lock(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, lock: ClassInstanceRef<Object>) -> Result<()> {
79        tracing::debug!("java.io.Writer::<init>({this:?}, {lock:?})");
80
81        if lock.is_null() {
82            return Err(jvm.exception("java/lang/NullPointerException", "lock is null").await);
83        }
84
85        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
86        jvm.put_field(&mut this, "java/io/Writer", "lock", "Ljava/lang/Object;", lock).await?;
87
88        Ok(())
89    }
90
91    async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
92        tracing::debug!("java.io.Writer::write({this:?}, {value})");
93
94        let mut chars = jvm.instantiate_array("C", 1).await?;
95        jvm.store_array(&mut chars, 0, [value as JavaChar]).await?;
96        jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, 1)).await
97    }
98
99    async fn write_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, chars: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
100        tracing::debug!("java.io.Writer::write({this:?}, {chars:?})");
101        if chars.is_null() {
102            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
103        }
104
105        let length = jvm.array_length(&chars).await? as i32;
106        jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, length)).await
107    }
108
109    async fn write_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
110        tracing::debug!("java.io.Writer::write_string({this:?}, {string:?})");
111        if string.is_null() {
112            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
113        }
114
115        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&string, "java/lang/String", "toCharArray", "()[C", ()).await?;
116        let length = jvm.array_length(&chars).await?;
117
118        let _: () = jvm
119            .invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, length as i32))
120            .await?;
121
122        Ok(())
123    }
124
125    async fn write_string_offset(
126        jvm: &Jvm,
127        _: &mut RuntimeContext,
128        this: ClassInstanceRef<Self>,
129        string: ClassInstanceRef<String>,
130        off: i32,
131        len: i32,
132    ) -> Result<()> {
133        tracing::debug!("java.io.Writer::write({this:?}, {string:?}, {off}, {len})");
134        if string.is_null() {
135            return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
136        }
137
138        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&string, "java/lang/String", "toCharArray", "()[C", ()).await?;
139        jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, off, len)).await
140    }
141
142    async fn append_char_sequence(
143        jvm: &Jvm,
144        _: &mut RuntimeContext,
145        this: ClassInstanceRef<Self>,
146        sequence: ClassInstanceRef<CharSequence>,
147    ) -> Result<ClassInstanceRef<Self>> {
148        let string: ClassInstanceRef<String> = if sequence.is_null() {
149            JavaLangString::from_rust_string(jvm, "null").await?.into()
150        } else {
151            jvm.invoke_virtual(&sequence, &sequence.class_definition().name(), "toString", "()Ljava/lang/String;", ())
152                .await?
153        };
154        let _: () = jvm
155            .invoke_virtual(&this, "java/io/Writer", "write", "(Ljava/lang/String;)V", (string,))
156            .await?;
157        Ok(this)
158    }
159
160    async fn append_char_sequence_range(
161        jvm: &Jvm,
162        _: &mut RuntimeContext,
163        this: ClassInstanceRef<Self>,
164        sequence: ClassInstanceRef<CharSequence>,
165        start: i32,
166        end: i32,
167    ) -> Result<ClassInstanceRef<Self>> {
168        let sequence: ClassInstanceRef<CharSequence> = if sequence.is_null() {
169            JavaLangString::from_rust_string(jvm, "null").await?.into()
170        } else {
171            sequence
172        };
173        let subsequence: ClassInstanceRef<CharSequence> = jvm
174            .invoke_virtual(
175                &sequence,
176                &sequence.class_definition().name(),
177                "subSequence",
178                "(II)Ljava/lang/CharSequence;",
179                (start, end),
180            )
181            .await?;
182        let string: ClassInstanceRef<String> = jvm
183            .invoke_virtual(
184                &subsequence,
185                &subsequence.class_definition().name(),
186                "toString",
187                "()Ljava/lang/String;",
188                (),
189            )
190            .await?;
191        let _: () = jvm
192            .invoke_virtual(&this, "java/io/Writer", "write", "(Ljava/lang/String;)V", (string,))
193            .await?;
194        Ok(this)
195    }
196
197    async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, character: JavaChar) -> Result<ClassInstanceRef<Self>> {
198        let _: () = jvm.invoke_virtual(&this, "java/io/Writer", "write", "(I)V", (character as i32,)).await?;
199        Ok(this)
200    }
201}