Skip to main content

rustjava_runtime/classes/java/util/logging/
handler.rs

1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        io::OutputStreamWriter,
11        lang::{Exception, String},
12    },
13};
14
15use super::{Filter, Formatter, Level, LogRecord};
16
17// public abstract class java.util.logging.Handler
18pub struct Handler;
19
20impl Handler {
21    pub fn as_proto() -> RuntimeClassProto {
22        RuntimeClassProto {
23            name: "java/util/logging/Handler",
24            parent_class: Some("java/lang/Object"),
25            interfaces: vec![],
26            methods: vec![
27                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
28                JavaMethodProto::new_abstract("close", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
29                JavaMethodProto::new_abstract("flush", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
30                JavaMethodProto::new_abstract(
31                    "publish",
32                    "(Ljava/util/logging/LogRecord;)V",
33                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
34                ),
35                JavaMethodProto::new("getEncoding", "()Ljava/lang/String;", Self::get_encoding, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("getFilter", "()Ljava/util/logging/Filter;", Self::get_filter, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new(
38                    "getFormatter",
39                    "()Ljava/util/logging/Formatter;",
40                    Self::get_formatter,
41                    MethodAccessFlags::PUBLIC,
42                ),
43                JavaMethodProto::new("getLevel", "()Ljava/util/logging/Level;", Self::get_level, MethodAccessFlags::PUBLIC),
44                JavaMethodProto::new(
45                    "isLoggable",
46                    "(Ljava/util/logging/LogRecord;)Z",
47                    Self::is_loggable,
48                    MethodAccessFlags::PUBLIC,
49                ),
50                JavaMethodProto::new(
51                    "reportError",
52                    "(Ljava/lang/String;Ljava/lang/Exception;I)V",
53                    Self::report_error,
54                    MethodAccessFlags::PROTECTED,
55                ),
56                JavaMethodProto::new("setEncoding", "(Ljava/lang/String;)V", Self::set_encoding, MethodAccessFlags::PUBLIC),
57                JavaMethodProto::new("setFilter", "(Ljava/util/logging/Filter;)V", Self::set_filter, MethodAccessFlags::PUBLIC),
58                JavaMethodProto::new(
59                    "setFormatter",
60                    "(Ljava/util/logging/Formatter;)V",
61                    Self::set_formatter,
62                    MethodAccessFlags::PUBLIC,
63                ),
64                JavaMethodProto::new("setLevel", "(Ljava/util/logging/Level;)V", Self::set_level, MethodAccessFlags::PUBLIC),
65            ],
66            fields: vec![
67                JavaFieldProto::new("level", "Ljava/util/logging/Level;", FieldAccessFlags::PRIVATE),
68                JavaFieldProto::new("filter", "Ljava/util/logging/Filter;", FieldAccessFlags::PRIVATE),
69                JavaFieldProto::new("formatter", "Ljava/util/logging/Formatter;", FieldAccessFlags::PRIVATE),
70                JavaFieldProto::new("encoding", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
71            ],
72            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
73        }
74    }
75
76    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
77        tracing::debug!("java.util.logging.Handler::<init>({this:?})");
78
79        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
80        let level: ClassInstanceRef<Level> = jvm
81            .get_static_field("java/util/logging/Level", "ALL", "Ljava/util/logging/Level;")
82            .await?;
83        jvm.put_field(&mut this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;", level)
84            .await
85    }
86
87    async fn get_encoding(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
88        tracing::debug!("java.util.logging.Handler::getEncoding({this:?})");
89
90        jvm.get_field(&this, "java/util/logging/Handler", "encoding", "Ljava/lang/String;").await
91    }
92
93    async fn get_filter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Filter>> {
94        tracing::debug!("java.util.logging.Handler::getFilter({this:?})");
95
96        jvm.get_field(&this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;")
97            .await
98    }
99
100    async fn get_formatter(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Formatter>> {
101        tracing::debug!("java.util.logging.Handler::getFormatter({this:?})");
102
103        jvm.get_field(&this, "java/util/logging/Handler", "formatter", "Ljava/util/logging/Formatter;")
104            .await
105    }
106
107    async fn get_level(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Level>> {
108        tracing::debug!("java.util.logging.Handler::getLevel({this:?})");
109
110        jvm.get_field(&this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;")
111            .await
112    }
113
114    async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<bool> {
115        tracing::debug!("java.util.logging.Handler::isLoggable({this:?}, {record:?})");
116
117        if record.is_null() {
118            return Ok(false);
119        }
120
121        let record_level: ClassInstanceRef<Level> = jvm
122            .invoke_virtual(&record, "java/util/logging/LogRecord", "getLevel", "()Ljava/util/logging/Level;", ())
123            .await?;
124        let handler_level: ClassInstanceRef<Level> = jvm
125            .get_field(&this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;")
126            .await?;
127        let record_value: i32 = jvm
128            .invoke_virtual(&record_level, "java/util/logging/Level", "intValue", "()I", ())
129            .await?;
130        let handler_value: i32 = jvm
131            .invoke_virtual(&handler_level, "java/util/logging/Level", "intValue", "()I", ())
132            .await?;
133        if handler_value == i32::MAX || record_value < handler_value {
134            return Ok(false);
135        }
136
137        let filter: ClassInstanceRef<Filter> = jvm
138            .get_field(&this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;")
139            .await?;
140        if filter.is_null() {
141            return Ok(true);
142        }
143
144        jvm.invoke_virtual(
145            &filter,
146            &filter.class_definition().name(),
147            "isLoggable",
148            "(Ljava/util/logging/LogRecord;)Z",
149            (record,),
150        )
151        .await
152    }
153
154    async fn report_error(
155        _: &Jvm,
156        _: &mut RuntimeContext,
157        this: ClassInstanceRef<Self>,
158        _: ClassInstanceRef<String>,
159        _: ClassInstanceRef<Exception>,
160        _: i32,
161    ) -> Result<()> {
162        tracing::debug!("java.util.logging.Handler::reportError({this:?})");
163
164        Ok(())
165    }
166
167    async fn set_encoding(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, encoding: ClassInstanceRef<String>) -> Result<()> {
168        tracing::debug!("java.util.logging.Handler::setEncoding({this:?}, {encoding:?})");
169
170        if !encoding.is_null() {
171            OutputStreamWriter::validate_encoding(jvm, &encoding).await?;
172        }
173        jvm.put_field(&mut this, "java/util/logging/Handler", "encoding", "Ljava/lang/String;", encoding)
174            .await
175    }
176
177    async fn set_filter(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, filter: ClassInstanceRef<Filter>) -> Result<()> {
178        tracing::debug!("java.util.logging.Handler::setFilter({this:?}, {filter:?})");
179
180        jvm.put_field(&mut this, "java/util/logging/Handler", "filter", "Ljava/util/logging/Filter;", filter)
181            .await
182    }
183
184    async fn set_formatter(
185        jvm: &Jvm,
186        _: &mut RuntimeContext,
187        mut this: ClassInstanceRef<Self>,
188        formatter: ClassInstanceRef<Formatter>,
189    ) -> Result<()> {
190        tracing::debug!("java.util.logging.Handler::setFormatter({this:?}, {formatter:?})");
191
192        if formatter.is_null() {
193            return Err(jvm.exception("java/lang/NullPointerException", "formatter").await);
194        }
195        jvm.put_field(
196            &mut this,
197            "java/util/logging/Handler",
198            "formatter",
199            "Ljava/util/logging/Formatter;",
200            formatter,
201        )
202        .await
203    }
204
205    async fn set_level(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, level: ClassInstanceRef<Level>) -> Result<()> {
206        tracing::debug!("java.util.logging.Handler::setLevel({this:?}, {level:?})");
207
208        if level.is_null() {
209            return Err(jvm.exception("java/lang/NullPointerException", "level").await);
210        }
211        jvm.put_field(&mut this, "java/util/logging/Handler", "level", "Ljava/util/logging/Level;", level)
212            .await
213    }
214}