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
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}