rustjava_runtime/classes/java/io/
reader.rs1use 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
9pub 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 if buf.is_null() {
77 return Err(jvm.exception("java/lang/NullPointerException", "argument is null").await);
78 }
79
80 let len = jvm.array_length(&buf).await? as i32;
81 let result = jvm.invoke_virtual(&this, "java/io/Reader", "read", "([CII)I", (buf, 0, len)).await?;
82
83 Ok(result)
84 }
85
86 async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, n: i64) -> Result<i64> {
87 tracing::debug!("java.io.Reader::skip({this:?}, {n})");
88
89 if n < 0 {
90 return Err(jvm.exception("java/lang/IllegalArgumentException", "skip value is negative").await);
91 }
92
93 let buffer_size = n.min(8192) as usize;
94 let buffer = jvm.instantiate_array("C", buffer_size).await?;
95 let mut remaining = n;
96 while remaining > 0 {
97 let read: i32 = jvm
98 .invoke_virtual(
99 &this,
100 "java/io/Reader",
101 "read",
102 "([CII)I",
103 (buffer.clone(), 0, remaining.min(buffer_size as i64) as i32),
104 )
105 .await?;
106 if read == -1 {
107 break;
108 }
109 remaining -= read as i64;
110 }
111
112 Ok(n - remaining)
113 }
114
115 async fn ready(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
116 tracing::debug!("java.io.Reader::ready({this:?})");
117 Ok(false)
118 }
119
120 async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
121 tracing::debug!("java.io.Reader::markSupported({this:?})");
122 Ok(false)
123 }
124
125 async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, read_ahead_limit: i32) -> Result<()> {
126 tracing::debug!("java.io.Reader::mark({this:?}, {read_ahead_limit})");
127 Err(jvm.exception("java/io/IOException", "mark not supported").await)
128 }
129
130 async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
131 tracing::debug!("java.io.Reader::reset({this:?})");
132 Err(jvm.exception("java/io/IOException", "reset not supported").await)
133 }
134}