Add CDC text formatting APIs

java_runtime/src/classes/java.rs

@@ -1,4 +1,5 @@
 pub mod io;
 pub mod lang;
 pub mod net;
+pub mod text;
 pub mod util;

java_runtime/src/classes/java/text.rs

@@ -0,0 +1,13 @@
+mod date_format;
+mod decimal_format;
+mod field_position;
+mod format;
+mod number_format;
+mod parse_exception;
+mod parse_position;
+mod simple_date_format;
+
+pub use self::{
+    date_format::DateFormat, decimal_format::DecimalFormat, field_position::FieldPosition, format::Format, number_format::NumberFormat,
+    parse_exception::ParseException, parse_position::ParsePosition, simple_date_format::SimpleDateFormat,
+};

java_runtime/src/classes/java/text/field_position.rs

@@ -0,0 +1,101 @@
+use alloc::{format, vec};
+
+use java_class_proto::{JavaFieldProto, JavaMethodProto};
+use java_constants::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
+use jvm::{ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
+
+use crate::{
+    RuntimeClassProto, RuntimeContext,
+    classes::java::lang::{Object, String},
+};
+
+// public class java.text.FieldPosition
+pub struct FieldPosition;
+
+impl FieldPosition {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/text/FieldPosition",
+            parent_class: Some("java/lang/Object"),
+            interfaces: vec![],
+            methods: vec![
+                JavaMethodProto::new("<init>", "(I)V", Self::init, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("getField", "()I", Self::get_field, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("getBeginIndex", "()I", Self::get_begin_index, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("getEndIndex", "()I", Self::get_end_index, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("setBeginIndex", "(I)V", Self::set_begin_index, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("setEndIndex", "(I)V", Self::set_end_index, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("equals", "(Ljava/lang/Object;)Z", Self::equals, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("hashCode", "()I", Self::hash_code, MethodAccessFlags::PUBLIC),
+                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, MethodAccessFlags::PUBLIC),
+            ],
+            fields: vec![
+                JavaFieldProto::new("field", "I", FieldAccessFlags::PRIVATE),
+                JavaFieldProto::new("beginIndex", "I", FieldAccessFlags::PRIVATE),
+                JavaFieldProto::new("endIndex", "I", FieldAccessFlags::PRIVATE),
+            ],
+            access_flags: ClassAccessFlags::PUBLIC,
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, field: i32) -> Result<()> {
+        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
+        jvm.put_field(&mut this, "field", "I", field).await?;
+        jvm.put_field(&mut this, "beginIndex", "I", 0).await?;
+        jvm.put_field(&mut this, "endIndex", "I", 0).await
+    }
+
+    async fn get_field(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
+        jvm.get_field(&this, "field", "I").await
+    }
+
+    async fn get_begin_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
+        jvm.get_field(&this, "beginIndex", "I").await
+    }
+
+    async fn get_end_index(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
+        jvm.get_field(&this, "endIndex", "I").await
+    }
+
+    async fn set_begin_index(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
+        jvm.put_field(&mut this, "beginIndex", "I", value).await
+    }
+
+    async fn set_end_index(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
+        jvm.put_field(&mut this, "endIndex", "I", value).await
+    }
+
+    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
+        if other.is_null() || !jvm.is_instance(&**other, "java/text/FieldPosition") {
+            return Ok(false);
+        }
+
+        let other: ClassInstanceRef<Self> = ClassInstanceRef::new(other.instance);
+        let field: i32 = jvm.get_field(&this, "field", "I").await?;
+        let other_field: i32 = jvm.get_field(&other, "field", "I").await?;
+        let begin_index: i32 = jvm.get_field(&this, "beginIndex", "I").await?;
+        let other_begin_index: i32 = jvm.get_field(&other, "beginIndex", "I").await?;
+        let end_index: i32 = jvm.get_field(&this, "endIndex", "I").await?;
+        let other_end_index: i32 = jvm.get_field(&other, "endIndex", "I").await?;
+        Ok(field == other_field && begin_index == other_begin_index && end_index == other_end_index)
+    }
+
+    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
+        let field: i32 = jvm.get_field(&this, "field", "I").await?;
+        let begin_index: i32 = jvm.get_field(&this, "beginIndex", "I").await?;
+        let end_index: i32 = jvm.get_field(&this, "endIndex", "I").await?;
+        Ok(field ^ begin_index.rotate_left(11) ^ end_index.rotate_left(22))
+    }
+
+    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
+        let field: i32 = jvm.get_field(&this, "field", "I").await?;
+        let begin_index: i32 = jvm.get_field(&this, "beginIndex", "I").await?;
+        let end_index: i32 = jvm.get_field(&this, "endIndex", "I").await?;
+        Ok(JavaLangString::from_rust_string(
+            jvm,
+            &format!("java.text.FieldPosition[field={field},beginIndex={begin_index},endIndex={end_index}]"),
+        )
+        .await?
+        .into())
+    }
+}

java_runtime/src/classes/java/text/format.rs

@@ -0,0 +1,113 @@
+use alloc::vec;
+
+use java_class_proto::JavaMethodProto;
+use java_constants::{ClassAccessFlags, MethodAccessFlags};
+use jvm::{ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};
+
+use crate::{
+    RuntimeClassProto, RuntimeContext,
+    classes::java::{
+        lang::{Object, String, StringBuffer},
+        text::{FieldPosition, ParseException, ParsePosition},
+    },
+};
+
+// public abstract class java.text.Format
+pub struct Format;
+
+impl Format {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/text/Format",
+            parent_class: Some("java/lang/Object"),
+            interfaces: vec!["java/io/Serializable", "java/lang/Cloneable"],
+            methods: vec![
+                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
+                JavaMethodProto::new(
+                    "format",
+                    "(Ljava/lang/Object;)Ljava/lang/String;",
+                    Self::format,
+                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
+                ),
+                JavaMethodProto::new_abstract(
+                    "format",
+                    "(Ljava/lang/Object;Ljava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
+                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
+                ),
+                JavaMethodProto::new(
+                    "parseObject",
+                    "(Ljava/lang/String;)Ljava/lang/Object;",
+                    Self::parse_object,
+                    MethodAccessFlags::PUBLIC,
+                ),
+                JavaMethodProto::new_abstract(
+                    "parseObject",
+                    "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Object;",
+                    MethodAccessFlags::PUBLIC | MethodAccessFlags::ABSTRACT,
+                ),
+                JavaMethodProto::new("clone", "()Ljava/lang/Object;", Self::clone, MethodAccessFlags::PUBLIC),
+            ],
+            fields: vec![],
+            access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::ABSTRACT,
+        }
+    }
+
+    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
+        jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await
+    }
+
+    async fn format(
+        jvm: &Jvm,
+        _: &mut RuntimeContext,
+        this: ClassInstanceRef<Self>,
+        object: ClassInstanceRef<Object>,
+    ) -> Result<ClassInstanceRef<String>> {
+        let buffer: ClassInstanceRef<StringBuffer> = jvm.new_class("java/lang/StringBuffer", "()V", ()).await?.into();
+        let position: ClassInstanceRef<FieldPosition> = jvm.new_class("java/text/FieldPosition", "(I)V", (0,)).await?.into();
+        let buffer: ClassInstanceRef<StringBuffer> = jvm
+            .invoke_virtual(
+                &this,
+                "format",
+                "(Ljava/lang/Object;Ljava/lang/StringBuffer;Ljava/text/FieldPosition;)Ljava/lang/StringBuffer;",
+                (object, buffer, position),
+            )
+            .await?;
+        jvm.invoke_virtual(&buffer, "toString", "()Ljava/lang/String;", ()).await
+    }
+
+    async fn parse_object(
+        jvm: &Jvm,
+        _: &mut RuntimeContext,
+        this: ClassInstanceRef<Self>,
+        source: ClassInstanceRef<String>,
+    ) -> Result<ClassInstanceRef<Object>> {
+        if source.is_null() {
+            return Err(jvm.exception("java/lang/NullPointerException", "source").await);
+        }
+
+        let position: ClassInstanceRef<ParsePosition> = jvm.new_class("java/text/ParsePosition", "(I)V", (0,)).await?.into();
+        let result: ClassInstanceRef<Object> = jvm
+            .invoke_virtual(
+                &this,
+                "parseObject",
+                "(Ljava/lang/String;Ljava/text/ParsePosition;)Ljava/lang/Object;",
+                (source, position.clone()),
+            )
+            .await?;
+        let index: i32 = jvm.invoke_virtual(&position, "getIndex", "()I", ()).await?;
+        if index == 0 {
+            let error_index: i32 = jvm.invoke_virtual(&position, "getErrorIndex", "()I", ()).await?;
+            let message = JavaLangString::from_rust_string(jvm, "Format.parseObject(String) failed").await?;
+            let exception: ClassInstanceRef<ParseException> = jvm
+                .new_class("java/text/ParseException", "(Ljava/lang/String;I)V", (message, error_index))
+                .await?
+                .into();
+            return Err(JavaError::JavaException(exception.into()));
+        }
+        Ok(result)
+    }
+
+    async fn clone(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
+        Ok(jvm.shallow_clone(&this)?.into())
+    }
+}