Skip to main content

rustjava_runtime/classes/java/io/
reader.rs

1use alloc::vec;
2
3use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
8
9// abstract class java.io.Reader
10pub struct Reader;
11
12impl Reader {
13    pub fn as_proto() -> RuntimeClassProto {
14        RuntimeClassProto {
15            name: "java/io/Reader",
16            parent_class: Some("java/lang/Object"),
17            interfaces: vec![],
18            methods: vec![
19                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
20                JavaMethodProto::new("<init>", "(Ljava/lang/Object;)V", Self::init_with_lock, MethodAccessFlags::PROTECTED),
21                JavaMethodProto::new("read", "()I", Self::read_char, MethodAccessFlags::PUBLIC),
22                JavaMethodProto::new("read", "([C)I", Self::read, MethodAccessFlags::PUBLIC),
23                JavaMethodProto::new_abstract("read", "([CII)I", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
24                JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC),
25                JavaMethodProto::new("ready", "()Z", Self::ready, MethodAccessFlags::PUBLIC),
26                JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
27                JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
28                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
29                JavaMethodProto::new_abstract("close", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
30            ],
31            fields: vec![JavaFieldProto::new("lock", "Ljava/lang/Object;", FieldAccessFlags::PROTECTED)],
32            access_flags: ClassAccessFlags::ABSTRACT,
33        }
34    }
35
36    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
37        tracing::debug!("java.io.Reader::<init>({this:?})");
38
39        let _: () = jvm
40            .invoke_special(&this, "java/io/Reader", "<init>", "(Ljava/lang/Object;)V", (this.clone(),))
41            .await?;
42
43        Ok(())
44    }
45
46    async fn init_with_lock(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, lock: ClassInstanceRef<Object>) -> Result<()> {
47        tracing::debug!("java.io.Reader::<init>({this:?}, {lock:?})");
48
49        if lock.is_null() {
50            return Err(jvm.exception("java/lang/NullPointerException", "lock is null").await);
51        }
52
53        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
54        jvm.put_field(&mut this, "java/io/Reader", "lock", "Ljava/lang/Object;", lock).await?;
55
56        Ok(())
57    }
58
59    async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
60        tracing::debug!("java.io.Reader::read({this:?})");
61
62        let chars = jvm.instantiate_array("C", 1).await?;
63        let read: i32 = jvm
64            .invoke_virtual(&this, "java/io/Reader", "read", "([CII)I", (chars.clone(), 0, 1))
65            .await?;
66        if read == -1 {
67            return Ok(-1);
68        }
69
70        let value: JavaChar = jvm.load_array(&chars, 0, 1).await?[0];
71        Ok(value as i32)
72    }
73
74    async fn read(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, buf: ClassInstanceRef<Array<JavaChar>>) -> Result<i32> {
75        tracing::debug!("java.io.Reader::read({this:?}, {buf:?})");
76
77        let len = jvm.array_length(&buf).await? as i32;
78        let result = jvm.invoke_virtual(&this, "java/io/Reader", "read", "([CII)I", (buf, 0, len)).await?;
79
80        Ok(result)
81    }
82
83    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
84        tracing::debug!("java.io.Reader::skip({this:?}, {n})");
85
86        if n < 0 {
87            return Err(jvm.exception("java/lang/IllegalArgumentException", "skip value is negative").await);
88        }
89
90        let buffer_size = n.min(8192) as usize;
91        let buffer = jvm.instantiate_array("C", buffer_size).await?;
92        let mut remaining = n;
93        while remaining > 0 {
94            let read: i32 = jvm
95                .invoke_virtual(
96                    &this,
97                    "java/io/Reader",
98                    "read",
99                    "([CII)I",
100                    (buffer.clone(), 0, remaining.min(buffer_size as i64) as i32),
101                )
102                .await?;
103            if read == -1 {
104                break;
105            }
106            remaining -= read as i64;
107        }
108
109        Ok(n - remaining)
110    }
111
112    async fn ready(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
113        tracing::debug!("java.io.Reader::ready({this:?})");
114        Ok(false)
115    }
116
117    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
118        tracing::debug!("java.io.Reader::markSupported({this:?})");
119        Ok(false)
120    }
121
122    async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, read_ahead_limit: i32) -> Result<()> {
123        tracing::debug!("java.io.Reader::mark({this:?}, {read_ahead_limit})");
124        Err(jvm.exception("java/io/IOException", "mark not supported").await)
125    }
126
127    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
128        tracing::debug!("java.io.Reader::reset({this:?})");
129        Err(jvm.exception("java/io/IOException", "reset not supported").await)
130    }
131}