use alloc::{boxed::Box, sync::Arc, vec, vec::Vec};
use core::{
fmt::{self, Debug, Formatter},
hash::{Hash, Hasher},
};
use parking_lot::RwLock;
use jvm::{
ArrayClassDefinition, ArrayClassInstance, ArrayRawBuffer, ArrayRawBufferMut, ClassDefinition, ClassInstance, Field, JavaType, JavaValue, Result,
};
use crate::array_class_definition::ArrayClassDefinitionImpl;
#[derive(Clone)]
enum ArrayElements {
Primitive(Vec<u8>),
NonPrimitive(Vec<JavaValue>),
}
struct ArrayClassInstanceInner {
class: Box<dyn ClassDefinition>,
length: usize,
element_type: JavaType,
elements: RwLock<ArrayElements>,
}
#[derive(Clone)]
pub struct ArrayClassInstanceImpl {
inner: Arc<ArrayClassInstanceInner>,
}
impl ArrayClassInstanceImpl {
pub fn new(class: &ArrayClassDefinitionImpl, length: usize) -> Self {
let element_type = JavaType::parse(&class.element_type_name());
let elements = if matches!(element_type, JavaType::Class(_) | JavaType::Array(_)) {
let default_value = element_type.default();
ArrayElements::NonPrimitive(vec![default_value; length])
} else {
let element_size = Self::primitive_element_size(&element_type);
ArrayElements::Primitive(vec![0; length * element_size])
};
Self {
inner: Arc::new(ArrayClassInstanceInner {
class: Box::new(class.clone()),
length,
element_type,
elements: RwLock::new(elements),
}),
}
}
fn primitive_element_size(element_type: &JavaType) -> usize {
match element_type {
JavaType::Boolean => 1,
JavaType::Byte => 1,
JavaType::Char => 2,
JavaType::Short => 2,
JavaType::Int => 4,
JavaType::Long => 8,
JavaType::Float => 4,
JavaType::Double => 8,
_ => unreachable!(),
}
}
fn convert_values_to_primitive(&self, values: Box<[JavaValue]>) -> Vec<u8> {
match self.inner.element_type {
JavaType::Boolean => values.into_vec().into_iter().map(|x| bool::from(x) as u8).collect::<Vec<_>>(),
JavaType::Byte => values.into_vec().into_iter().map(|x| i8::from(x) as u8).collect::<Vec<_>>(),
JavaType::Char => values.into_vec().into_iter().flat_map(|x| u16::from(x).to_le_bytes()).collect::<Vec<_>>(),
JavaType::Short => values.into_vec().into_iter().flat_map(|x| i16::from(x).to_le_bytes()).collect::<Vec<_>>(),
JavaType::Int => values.into_vec().into_iter().flat_map(|x| i32::from(x).to_le_bytes()).collect::<Vec<_>>(),
JavaType::Long => values.into_vec().into_iter().flat_map(|x| i64::from(x).to_le_bytes()).collect::<Vec<_>>(),
JavaType::Float => values.into_vec().into_iter().flat_map(|x| f32::from(x).to_le_bytes()).collect::<Vec<_>>(),
JavaType::Double => values.into_vec().into_iter().flat_map(|x| f64::from(x).to_le_bytes()).collect::<Vec<_>>(),
_ => unreachable!(),
}
}
fn convert_primitive_to_values(&self, values_raw: &[u8]) -> Vec<JavaValue> {
match self.inner.element_type {
JavaType::Boolean => values_raw.iter().map(|&x| JavaValue::Boolean(x != 0)).collect::<Vec<_>>(),
JavaType::Byte => values_raw.iter().map(|&x| JavaValue::Byte(x as i8)).collect::<Vec<_>>(),
JavaType::Char => values_raw
.chunks(2)
.map(|x| JavaValue::Char(u16::from_le_bytes(x.try_into().unwrap())))
.collect::<Vec<_>>(),
JavaType::Short => values_raw
.chunks(2)
.map(|x| JavaValue::Short(i16::from_le_bytes(x.try_into().unwrap())))
.collect::<Vec<_>>(),
JavaType::Int => values_raw
.chunks(4)
.map(|x| JavaValue::Int(i32::from_le_bytes(x.try_into().unwrap())))
.collect::<Vec<_>>(),
JavaType::Long => values_raw
.chunks(8)
.map(|x| JavaValue::Long(i64::from_le_bytes(x.try_into().unwrap())))
.collect::<Vec<_>>(),
JavaType::Float => values_raw
.chunks(4)
.map(|x| JavaValue::Float(f32::from_le_bytes(x.try_into().unwrap())))
.collect::<Vec<_>>(),
JavaType::Double => values_raw
.chunks(8)
.map(|x| JavaValue::Double(f64::from_le_bytes(x.try_into().unwrap())))
.collect::<Vec<_>>(),
_ => unreachable!(),
}
}
}
#[async_trait::async_trait]
impl ClassInstance for ArrayClassInstanceImpl {
fn destroy(self: Box<Self>) {}
fn identity(&self) -> usize {
Arc::as_ptr(&self.inner) as usize
}
fn shallow_clone(&self) -> Result<Box<dyn ClassInstance>> {
Ok(Box::new(Self {
inner: Arc::new(ArrayClassInstanceInner {
class: self.inner.class.clone(),
length: self.inner.length,
element_type: self.inner.element_type.clone(),
elements: RwLock::new(self.inner.elements.read().clone()),
}),
}))
}
fn class_definition(&self) -> Box<dyn ClassDefinition> {
self.inner.class.clone()
}
fn equals(&self, other: &dyn ClassInstance) -> Result<bool> {
let other = other.as_any().downcast_ref::<ArrayClassInstanceImpl>();
if other.is_none() {
return Ok(false);
}
let other = other.unwrap();
Ok(Arc::ptr_eq(&self.inner, &other.inner))
}
fn as_array_instance(&self) -> Option<&dyn ArrayClassInstance> {
Some(self)
}
fn as_array_instance_mut(&mut self) -> Option<&mut dyn ArrayClassInstance> {
Some(self)
}
fn get_field(&self, _field: &dyn Field) -> Result<JavaValue> {
panic!("Array classes do not have fields")
}
fn put_field(&mut self, _field: &dyn Field, _value: JavaValue) -> Result<()> {
panic!("Array classes do not have fields")
}
}
impl ArrayClassInstance for ArrayClassInstanceImpl {
fn store(&mut self, offset: usize, values: Box<[JavaValue]>) -> Result<()> {
match &mut *self.inner.elements.write() {
ArrayElements::Primitive(x) => {
let element_size = Self::primitive_element_size(&self.inner.element_type);
let values_raw = self.convert_values_to_primitive(values);
x.splice(offset * element_size..offset * element_size + values_raw.len(), values_raw);
}
ArrayElements::NonPrimitive(x) => {
x.splice(offset..offset + values.len(), values.into_vec());
}
}
Ok(())
}
fn load(&self, offset: usize, length: usize) -> Result<Vec<JavaValue>> {
Ok(match &*self.inner.elements.read() {
ArrayElements::Primitive(x) => {
let element_size = Self::primitive_element_size(&self.inner.element_type);
let values_raw = &x[offset * element_size..offset * element_size + length * element_size];
self.convert_primitive_to_values(values_raw)
}
ArrayElements::NonPrimitive(x) => x[offset..offset + length].to_vec(),
})
}
fn raw_buffer(&self) -> Result<Box<dyn ArrayRawBuffer>> {
Ok(Box::new(ArrayRawBufferImpl { inner: self.inner.clone() }))
}
fn raw_buffer_mut(&mut self) -> Result<Box<dyn ArrayRawBufferMut>> {
Ok(Box::new(ArrayRawBufferImpl { inner: self.inner.clone() }))
}
fn length(&self) -> usize {
self.inner.length
}
}
impl Hash for ArrayClassInstanceImpl {
fn hash<H: Hasher>(&self, state: &mut H) {
Arc::as_ptr(&self.inner).hash(state);
}
}
impl Debug for ArrayClassInstanceImpl {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "ArrayClassInstance({})", self.inner.class.name())
}
}
struct ArrayRawBufferImpl {
inner: Arc<ArrayClassInstanceInner>,
}
impl ArrayRawBuffer for ArrayRawBufferImpl {
fn read(&self, offset: usize, buffer: &mut [u8]) -> Result<()> {
match &*self.inner.elements.read() {
ArrayElements::Primitive(x) => {
let element_size = ArrayClassInstanceImpl::primitive_element_size(&self.inner.element_type);
let values_raw = &x[offset * element_size..offset * element_size + buffer.len() * element_size];
buffer.copy_from_slice(values_raw);
}
ArrayElements::NonPrimitive(_) => {
panic!("Expected primitive array");
}
}
Ok(())
}
}
impl ArrayRawBufferMut for ArrayRawBufferImpl {
fn write(&mut self, offset: usize, buffer: &[u8]) -> Result<()> {
if let ArrayElements::Primitive(x) = &mut *self.inner.elements.write() {
let element_size = ArrayClassInstanceImpl::primitive_element_size(&self.inner.element_type);
x[offset * element_size..offset * element_size + buffer.len() * element_size].copy_from_slice(buffer);
} else {
panic!("Expected primitive array");
}
Ok(())
}
}