rustjava-runtime 0.3.3

A Java standard library implementation for RustJava
Documentation
use alloc::vec;

use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};

use crate::{
    RuntimeClassProto, RuntimeContext,
    classes::java::lang::{CharSequence, Object, String},
};

// abstract class java.io.Writer
pub struct Writer;

impl Writer {
    pub fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "java/io/Writer",
            parent_class: Some("java/lang/Object"),
            interfaces: vec!["java/lang/Appendable", "java/io/Closeable", "java/io/Flushable"],
            methods: vec![
                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
                JavaMethodProto::new("<init>", "(Ljava/lang/Object;)V", Self::init_with_lock, MethodAccessFlags::PROTECTED),
                JavaMethodProto::new("write", "(I)V", Self::write_char, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("write", "([C)V", Self::write_chars, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new_abstract("write", "([CII)V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
                JavaMethodProto::new("write", "(Ljava/lang/String;)V", Self::write_string, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("write", "(Ljava/lang/String;II)V", Self::write_string_offset, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new(
                    "append",
                    "(Ljava/lang/CharSequence;)Ljava/io/Writer;",
                    Self::append_char_sequence,
                    MethodAccessFlags::PUBLIC,
                ),
                JavaMethodProto::new(
                    "append",
                    "(Ljava/lang/CharSequence;II)Ljava/io/Writer;",
                    Self::append_char_sequence_range,
                    MethodAccessFlags::PUBLIC,
                ),
                JavaMethodProto::new("append", "(C)Ljava/io/Writer;", Self::append_char, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new(
                    "append",
                    "(Ljava/lang/CharSequence;)Ljava/lang/Appendable;",
                    Self::append_char_sequence,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
                ),
                JavaMethodProto::new(
                    "append",
                    "(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;",
                    Self::append_char_sequence_range,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
                ),
                JavaMethodProto::new(
                    "append",
                    "(C)Ljava/lang/Appendable;",
                    Self::append_char,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::BRIDGE | MethodAccessFlags::SYNTHETIC,
                ),
                JavaMethodProto::new_abstract("flush", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
                JavaMethodProto::new_abstract("close", "()V", MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT),
            ],
            fields: vec![JavaFieldProto::new("lock", "Ljava/lang/Object;", FieldAccessFlags::PROTECTED)],
            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
        }
    }

    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
        tracing::debug!("java.io.Writer::<init>({this:?})");

        let _: () = jvm
            .invoke_special(&this, "java/io/Writer", "<init>", "(Ljava/lang/Object;)V", (this.clone(),))
            .await?;

        Ok(())
    }

    async fn init_with_lock(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, lock: ClassInstanceRef<Object>) -> Result<()> {
        tracing::debug!("java.io.Writer::<init>({this:?}, {lock:?})");

        if lock.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "lock is null").await);
        }

        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
        jvm.put_field(&mut this, "java/io/Writer", "lock", "Ljava/lang/Object;", lock).await?;

        Ok(())
    }

    async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
        tracing::debug!("java.io.Writer::write({this:?}, {value})");

        let mut chars = jvm.instantiate_array("C", 1).await?;
        jvm.store_array(&mut chars, 0, [value as JavaChar]).await?;
        jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, 1)).await
    }

    async fn write_chars(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, chars: ClassInstanceRef<Array<JavaChar>>) -> Result<()> {
        tracing::debug!("java.io.Writer::write({this:?}, {chars:?})");

        let length = jvm.array_length(&chars).await? as i32;
        jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, length)).await
    }

    async fn write_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, string: ClassInstanceRef<String>) -> Result<()> {
        tracing::debug!("java.io.Writer::write_string({this:?}, {string:?})");

        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&string, "java/lang/String", "toCharArray", "()[C", ()).await?;
        let length = jvm.array_length(&chars).await?;

        let _: () = jvm
            .invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, 0, length as i32))
            .await?;

        Ok(())
    }

    async fn write_string_offset(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        string: ClassInstanceRef<String>,
        off: i32,
        len: i32,
    ) -> Result<()> {
        tracing::debug!("java.io.Writer::write({this:?}, {string:?}, {off}, {len})");

        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&string, "java/lang/String", "toCharArray", "()[C", ()).await?;
        jvm.invoke_virtual(&this, "java/io/Writer", "write", "([CII)V", (chars, off, len)).await
    }

    async fn append_char_sequence(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        sequence: ClassInstanceRef<CharSequence>,
    ) -> Result<ClassInstanceRef<Self>> {
        let string: ClassInstanceRef<String> = if sequence.is_null() {
            JavaLangString::from_rust_string(jvm, "null").await?.into()
        } else {
            jvm.invoke_virtual(&sequence, &sequence.class_definition().name(), "toString", "()Ljava/lang/String;", ())
                .await?
        };
        let _: () = jvm
            .invoke_virtual(&this, "java/io/Writer", "write", "(Ljava/lang/String;)V", (string,))
            .await?;
        Ok(this)
    }

    async fn append_char_sequence_range(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        sequence: ClassInstanceRef<CharSequence>,
        start: i32,
        end: i32,
    ) -> Result<ClassInstanceRef<Self>> {
        let sequence: ClassInstanceRef<CharSequence> = if sequence.is_null() {
            JavaLangString::from_rust_string(jvm, "null").await?.into()
        } else {
            sequence
        };
        let subsequence: ClassInstanceRef<CharSequence> = jvm
            .invoke_virtual(
                &sequence,
                &sequence.class_definition().name(),
                "subSequence",
                "(II)Ljava/lang/CharSequence;",
                (start, end),
            )
            .await?;
        let string: ClassInstanceRef<String> = jvm
            .invoke_virtual(
                &subsequence,
                &subsequence.class_definition().name(),
                "toString",
                "()Ljava/lang/String;",
                (),
            )
            .await?;
        let _: () = jvm
            .invoke_virtual(&this, "java/io/Writer", "write", "(Ljava/lang/String;)V", (string,))
            .await?;
        Ok(this)
    }

    async fn append_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, character: JavaChar) -> Result<ClassInstanceRef<Self>> {
        let _: () = jvm.invoke_virtual(&this, "java/io/Writer", "write", "(I)V", (character as i32,)).await?;
        Ok(this)
    }
}