use std::cell::UnsafeCell;
use std::fmt::Debug;
use std::marker::PhantomData;
use std::ops::{Bound, RangeBounds};
use std::ptr;
use crate::any::TryFromTemp;
use crate::collections::map::element_view;
use crate::derive::Object;
use crate::object::{Object, ObjectArc};
use crate::type_traits::ContainerElement;
use crate::{Any, AnyCompatible, AnyView, Error, ObjectRefCore, Result};
use tvm_ffi_sys::TVMFFITypeIndex as TypeIndex;
use tvm_ffi_sys::{TVMFFIAny, TVMFFIObject};
#[repr(C)]
#[derive(Object)]
#[object(type_key = "ffi.List", unsafe type_index = TypeIndex::kTVMFFIList)]
pub struct ListObj {
pub(crate) object: Object,
data: UnsafeCell<*mut core::ffi::c_void>,
size: UnsafeCell<i64>,
capacity: UnsafeCell<i64>,
pub data_deleter: Option<unsafe extern "C" fn(*mut core::ffi::c_void)>,
}
impl ListObj {
#[inline]
pub fn len(&self) -> usize {
unsafe { *self.size.get() as usize }
}
#[inline]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
#[inline]
pub fn capacity(&self) -> usize {
unsafe { *self.capacity.get() as usize }
}
#[inline]
unsafe fn cell(this: *mut ListObj, index: usize) -> *mut TVMFFIAny {
unsafe { ((*(*this).data.get()) as *mut TVMFFIAny).add(index) }
}
unsafe fn truncate(this: *mut ListObj, len: usize) {
while unsafe { (*(*this).size.get()) as usize } > len {
unsafe { (*(*this).size.get()) -= 1 };
unsafe { drop(take_cell(Self::cell(this, (*(*this).size.get()) as usize))) };
}
}
}
#[inline]
unsafe fn take_cell(cell: *mut TVMFFIAny) -> Any {
unsafe { Any::from_raw_ffi_any(ptr::read(cell)) }
}
#[inline]
unsafe fn write_cell<T: ContainerElement>(cell: *mut TVMFFIAny, value: T) {
let mut raw = TVMFFIAny::new();
unsafe { T::container_move_to_any(value, &mut raw) };
unsafe { ptr::write(cell, raw) };
}
const MAX_CAPACITY: usize = isize::MAX as usize / std::mem::size_of::<TVMFFIAny>();
#[cold]
#[inline(never)]
fn index_error<T>(what: &str) -> Result<T> {
crate::bail!(
crate::error::INDEX_ERROR,
"List {} index out of bound",
what
)
}
#[cold]
#[inline(never)]
fn type_error<T: ContainerElement>(index: usize) -> Result<T> {
crate::bail!(
crate::error::TYPE_ERROR,
"Failed to cast element at {} to {}",
index,
T::container_type_str()
)
}
#[repr(C)]
pub struct List<T> {
data: ObjectArc<ListObj>,
_marker: PhantomData<T>,
}
impl<T> Clone for List<T> {
fn clone(&self) -> Self {
Self {
data: self.data.clone(),
_marker: PhantomData,
}
}
}
impl<T: ContainerElement> From<List<T>> for crate::object::ObjectRef {
#[inline]
fn from(value: List<T>) -> Self {
crate::object::into_root_object_ref(value)
}
}
impl<T: ContainerElement> TryFrom<crate::object::ObjectRef> for List<T> {
type Error = crate::error::Error;
#[inline]
fn try_from(value: crate::object::ObjectRef) -> crate::error::Result<Self> {
crate::object::root_try_into(value)
}
}
impl<T: ContainerElement> TryFrom<&crate::object::ObjectRef> for List<T> {
type Error = crate::error::Error;
#[inline]
fn try_from(value: &crate::object::ObjectRef) -> crate::error::Result<Self> {
crate::object::root_try_into_ref(value)
}
}
unsafe impl<T: ContainerElement> ObjectRefCore for List<T> {
type ContainerType = ListObj;
fn data(this: &Self) -> &ObjectArc<ListObj> {
&this.data
}
fn into_data(this: Self) -> ObjectArc<ListObj> {
this.data
}
unsafe fn from_data(data: ObjectArc<ListObj>) -> Self {
Self {
data,
_marker: PhantomData,
}
}
}
pub(crate) unsafe fn seq_cells(data: &TVMFFIAny) -> &[TVMFFIAny] {
let seq = unsafe { &*(data.data_union.v_obj as *const ListObj) };
unsafe {
crate::util::slice_from_nullable_raw_parts(
*seq.data.get() as *const TVMFFIAny,
*seq.size.get() as usize,
)
}
}
impl<T: ContainerElement> List<T> {
pub fn new() -> Self {
Self::from_items(&[]).expect("ffi.List() failed to construct an empty list")
}
fn from_items(items: &[T]) -> Result<Self> {
let args: Vec<AnyView<'_>> = items.iter().map(element_view).collect();
let result = crate::cached_global_func!("ffi.List").call_packed(&args)?;
unsafe {
debug_assert_eq!(
result.as_raw_ffi_any().type_index,
TypeIndex::kTVMFFIList as i32
);
let mut result = std::mem::ManuallyDrop::new(result);
Ok(Self::move_from_any_after_check(
&mut *result.as_raw_ffi_any_mut(),
))
}
}
#[inline]
fn obj(&self) -> *mut ListObj {
ObjectArc::as_ptr(&self.data) as *mut ListObj
}
#[inline]
pub fn len(&self) -> usize {
unsafe { *self.data.size.get() as usize }
}
#[inline]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn capacity(&self) -> usize {
unsafe { *self.data.capacity.get() as usize }
}
#[inline]
pub fn get(&self, index: usize) -> Result<T> {
let obj = self.obj();
unsafe {
if index >= (*(*obj).size.get()) as usize {
return index_error("get");
}
match T::container_try_cast_from_any_view(&*ListObj::cell(obj, index)) {
Ok(value) => Ok(value),
Err(()) => type_error(index),
}
}
}
#[inline]
pub fn set(&self, index: usize, value: T) {
let obj = self.obj();
unsafe {
let size = (*(*obj).size.get()) as usize;
if index >= size {
panic!("Index out of bounds: the len is {size} but the index is {index}");
}
let cell = ListObj::cell(obj, index);
let old = take_cell(cell);
write_cell(cell, value);
drop(old);
}
}
#[inline]
pub fn push(&self, value: T) -> Result<()> {
self.reserve_for(1)?;
let obj = self.obj();
unsafe {
write_cell(ListObj::cell(obj, (*(*obj).size.get()) as usize), value);
(*(*obj).size.get()) += 1;
}
Ok(())
}
pub fn insert(&self, index: usize, value: T) -> Result<()> {
let size = self.len();
if index > size {
return index_error("insert");
}
self.reserve_for(1)?;
let obj = self.obj();
unsafe {
let cell = ListObj::cell(obj, index);
ptr::copy(cell, cell.add(1), size - index);
write_cell(cell, value);
(*(*obj).size.get()) += 1;
}
Ok(())
}
#[inline]
pub fn remove(&self, index: usize) -> Result<T> {
let obj = self.obj();
unsafe {
let size = (*(*obj).size.get()) as usize;
if index >= size {
return index_error("remove");
}
let cell = ListObj::cell(obj, index);
let (value, old) = if T::container_check_any_strict(&*cell) {
let mut raw = ptr::read(cell);
(T::container_move_from_any_after_check(&mut raw), None)
} else {
match T::container_try_cast_from_any_view(&*cell) {
Ok(value) => (value, Some(take_cell(cell))),
Err(()) => return type_error(index),
}
};
if index + 1 < size {
ptr::copy(cell.add(1), cell, size - index - 1);
}
(*(*obj).size.get()) -= 1;
drop(old);
Ok(value)
}
}
#[inline]
pub fn clear(&self) {
unsafe { ListObj::truncate(self.obj(), 0) }
}
pub fn first(&self) -> Result<Option<T>> {
match self.len() {
0 => Ok(None),
_ => self.get(0).map(Some),
}
}
pub fn last(&self) -> Result<Option<T>> {
match self.len() {
0 => Ok(None),
len => self.get(len - 1).map(Some),
}
}
pub fn pop(&self) -> Result<Option<T>> {
match self.len() {
0 => Ok(None),
len => self.remove(len - 1).map(Some),
}
}
pub fn truncate(&self, len: usize) {
unsafe { ListObj::truncate(self.obj(), len) }
}
pub fn remove_range(&self, range: impl RangeBounds<usize>) {
let obj = self.obj();
unsafe {
let size = (*(*obj).size.get()) as usize;
let start = match range.start_bound() {
Bound::Included(&start) => start,
Bound::Excluded(&start) => start
.checked_add(1)
.expect("attempted to index slice from after maximum usize"),
Bound::Unbounded => 0,
};
let end = match range.end_bound() {
Bound::Included(&end) => end
.checked_add(1)
.expect("attempted to index slice up to maximum usize"),
Bound::Excluded(&end) => end,
Bound::Unbounded => size,
};
if start > end {
panic!("slice index starts at {start} but ends at {end}");
}
if end > size {
panic!("range end index {end} out of range for slice of length {size}");
}
if start == end {
return;
}
std::slice::from_raw_parts_mut(ListObj::cell(obj, start), size - start)
.rotate_left(end - start);
ListObj::truncate(obj, size - (end - start));
}
}
pub fn insert_many<I: IntoIterator<Item = T>>(&self, index: usize, iter: I) -> Result<()> {
let items: Vec<T> = iter.into_iter().collect();
let size = self.len();
if index > size {
return index_error("insert_many");
}
let count = items.len();
if count == 0 {
return Ok(());
}
self.reserve_for(count)?;
let obj = self.obj();
unsafe {
let cell = ListObj::cell(obj, index);
ptr::copy(cell, cell.add(count), size - index);
for (offset, item) in items.into_iter().enumerate() {
write_cell(cell.add(offset), item);
}
(*(*obj).size.get()) += count as i64;
}
Ok(())
}
pub fn reserve(&self, additional: usize) -> Result<()> {
let total = self.len().saturating_add(additional);
if total > self.capacity() {
self.grow_to(total)?;
}
Ok(())
}
#[inline]
fn reserve_for(&self, extra: usize) -> Result<()> {
let (size, capacity) = (self.len(), self.capacity());
let needed = size.saturating_add(extra);
if needed > capacity {
self.grow_to((capacity * 2).min(MAX_CAPACITY).max(needed))?;
}
Ok(())
}
#[cold]
#[inline(never)]
fn grow_to(&self, capacity: usize) -> Result<()> {
if capacity > MAX_CAPACITY {
crate::bail!(
crate::error::VALUE_ERROR,
"List capacity {} exceeds the maximum {}",
capacity,
MAX_CAPACITY
);
}
crate::cached_global_func!("ffi.ListReserve")
.call_packed(&[AnyView::from(self), AnyView::from(&(capacity as i64))])?;
Ok(())
}
pub fn extend<I: IntoIterator<Item = T>>(&self, iter: I) -> Result<()> {
let items: Vec<T> = iter.into_iter().collect();
self.insert_many(self.len(), items)
}
pub fn resize(&self, new_len: usize, value: T) -> Result<()>
where
T: Clone,
{
let len = self.len();
if new_len <= len {
self.truncate(new_len);
return Ok(());
}
self.extend(std::iter::repeat_n(value, new_len - len))
}
pub fn reverse(&self) {
let obj = self.obj();
unsafe {
let size = (*(*obj).size.get()) as usize;
if size > 1 {
std::slice::from_raw_parts_mut(ListObj::cell(obj, 0), size).reverse();
}
}
}
pub fn iter(&self) -> Iter<'_, T> {
Iter {
list: self,
index: 0,
back: usize::MAX,
}
}
}
impl<T: ContainerElement> Default for List<T> {
fn default() -> Self {
Self::new()
}
}
impl<T> Debug for List<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let full_name = std::any::type_name::<T>();
let short_name = full_name.split("::").last().unwrap_or(full_name);
write!(f, "List<{}>[{}]", short_name, unsafe {
*self.data.size.get()
})
}
}
impl<T: ContainerElement> std::fmt::Display for List<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Display::fmt(&AnyView::from_object(&**ObjectRefCore::data(self)), f)
}
}
impl<T: ContainerElement> FromIterator<T> for List<T> {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let items: Vec<T> = iter.into_iter().collect();
Self::from_items(&items).expect("ffi.List() failed to construct a list")
}
}
pub struct Iter<'a, T> {
list: &'a List<T>,
index: usize,
back: usize,
}
impl<T: ContainerElement> Iter<'_, T> {
#[inline]
fn end(&self) -> usize {
self.back.min(self.list.len())
}
#[inline]
unsafe fn read(&self, index: usize) -> Result<T> {
match unsafe {
T::container_try_cast_from_any_view(&*ListObj::cell(self.list.obj(), index))
} {
Ok(value) => Ok(value),
Err(()) => type_error(index),
}
}
}
impl<T: ContainerElement> Iterator for Iter<'_, T> {
type Item = Result<T>;
#[inline]
fn next(&mut self) -> Option<Result<T>> {
if self.index >= self.end() {
return None;
}
let index = self.index;
self.index += 1;
Some(unsafe { self.read(index) })
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.end().saturating_sub(self.index)))
}
}
impl<T: ContainerElement> DoubleEndedIterator for Iter<'_, T> {
#[inline]
fn next_back(&mut self) -> Option<Result<T>> {
let end = self.end();
if end <= self.index {
return None;
}
self.back = end - 1;
Some(unsafe { self.read(end - 1) })
}
}
impl<'a, T: ContainerElement> IntoIterator for &'a List<T> {
type Item = Result<T>;
type IntoIter = Iter<'a, T>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
unsafe impl<T: ContainerElement> AnyCompatible for List<T> {
#[inline]
unsafe fn is_undefined(field: *const Self) -> bool {
unsafe { ObjectArc::is_null(std::ptr::addr_of!((*field).data)) }
}
fn type_str() -> String {
format!("List<{}>", T::container_type_str())
}
fn type_schema() -> String {
crate::type_traits::type_schema(
<ListObj as crate::ObjectCore>::TYPE_KEY,
&[T::container_type_schema()],
)
}
unsafe fn check_any_strict(data: &TVMFFIAny) -> bool {
unsafe {
data.type_index == TypeIndex::kTVMFFIList as i32
&& seq_cells(data)
.iter()
.all(|cell| T::container_check_any_strict(cell))
}
}
unsafe fn match_constraints(data: &TVMFFIAny) -> bool {
unsafe {
seq_cells(data)
.iter()
.all(|cell| T::container_match_constraints(cell))
}
}
unsafe fn copy_to_any_view(src: &Self, data: &mut TVMFFIAny) {
data.type_index = TypeIndex::kTVMFFIList as i32;
data.data_union.v_obj = ObjectArc::as_ptr(Self::data(src)) as *mut TVMFFIObject;
data.small_str_len = 0;
}
unsafe fn move_to_any(src: Self, data: &mut TVMFFIAny) {
data.type_index = TypeIndex::kTVMFFIList as i32;
data.data_union.v_obj = ObjectArc::into_raw(Self::into_data(src)) as *mut TVMFFIObject;
data.small_str_len = 0;
}
unsafe fn copy_from_any_view_after_check(data: &TVMFFIAny) -> Self {
let ptr = unsafe { data.data_union.v_obj as *const ListObj };
unsafe { crate::object::unsafe_::inc_ref(ptr as *mut TVMFFIObject) };
unsafe { Self::from_data(ObjectArc::from_raw(ptr)) }
}
unsafe fn move_from_any_after_check(data: &mut TVMFFIAny) -> Self {
let ptr = unsafe { data.data_union.v_obj as *const ListObj };
let obj = unsafe { Self::from_data(ObjectArc::from_raw(ptr)) };
data.type_index = TypeIndex::kTVMFFINone as i32;
data.data_union.v_int64 = 0;
obj
}
unsafe fn try_cast_from_any_view(data: &TVMFFIAny) -> Result<Self, ()> {
if data.type_index != TypeIndex::kTVMFFIList as i32
&& data.type_index != TypeIndex::kTVMFFIArray as i32
{
return Err(());
}
if unsafe { <Self as AnyCompatible>::check_any_strict(data) } {
return Ok(unsafe { <Self as AnyCompatible>::copy_from_any_view_after_check(data) });
}
let mut items = Vec::new();
for cell in unsafe { seq_cells(data) } {
unsafe { items.push(T::container_try_cast_from_any_view(cell)?) };
}
Self::from_items(&items).map_err(|_| ())
}
}
unsafe impl<T> crate::type_traits::RefFromAnyUnchecked for List<T>
where
T: ContainerElement,
{
#[inline(always)]
unsafe fn ref_from_any_unchecked(cell: &TVMFFIAny) -> &Self {
unsafe { &*(core::ptr::addr_of!(cell.data_union) as *const Self) }
}
}
unsafe impl<T> crate::type_traits::DowncastRefFromAny for List<T>
where
T: ContainerElement,
{
#[inline(always)]
unsafe fn downcast_ref_from_any(cell: &TVMFFIAny) -> Option<&Self> {
unsafe { crate::type_traits::downcast_ref_from_any_in_place::<Self>(cell) }
}
}
unsafe impl<T> crate::type_traits::DowncastRefFromObject for List<T>
where
T: ContainerElement,
{
#[inline(always)]
unsafe fn downcast_ref_from_object(place: &*mut TVMFFIObject) -> Option<&Self> {
unsafe { crate::type_traits::downcast_ref_from_object_in_place::<Self>(place) }
}
}
crate::impl_into_arg!(impl[T: ContainerElement] List<T>);
impl<'b, T: ContainerElement> TryFrom<&'b Any> for List<T> {
type Error = Error;
fn try_from(value: &'b Any) -> Result<Self> {
let temp: TryFromTemp<Self> = TryFromTemp::try_from(value)?;
Ok(TryFromTemp::into_value(temp))
}
}
impl<T: ContainerElement> TryFrom<Any> for List<T> {
type Error = Error;
fn try_from(value: Any) -> Result<Self> {
let temp: TryFromTemp<Self> = TryFromTemp::try_from(value)?;
Ok(TryFromTemp::into_value(temp))
}
}
impl<'a, T: ContainerElement> TryFrom<AnyView<'a>> for List<T> {
type Error = Error;
fn try_from(value: AnyView<'a>) -> Result<Self> {
let temp: TryFromTemp<Self> = TryFromTemp::try_from(value)?;
Ok(TryFromTemp::into_value(temp))
}
}