Skip to main content

mirascript_vm/value/types/
array.rs

1use std::any::Any;
2
3use crate::{
4    MiraError, Result, Runtime, RuntimeErrorKind,
5    value::{MiraHandle, MiraManageable},
6};
7
8use super::MiraValue;
9
10impl MiraValue {
11    /// Create a `MiraValue` representing an array value.
12    #[inline]
13    pub fn array(value: MiraHandle<impl MiraArray>) -> Self {
14        Self::Array(value.erase_array())
15    }
16
17    /// Check whether this value is an array value.
18    #[inline]
19    pub const fn is_array(self) -> bool {
20        matches!(self, Self::Array(_))
21    }
22
23    /// Return the array handle, or `None` for another value type.
24    #[inline]
25    pub fn as_array(&self) -> Option<MiraHandle<dyn MiraArray>> {
26        match self {
27            Self::Array(value) => Some(*value),
28            _ => None,
29        }
30    }
31}
32
33/// A read-only MiraScript array view.
34pub trait MiraArray: Any {
35    /// Return the number of elements.
36    fn len(&self) -> usize;
37
38    /// Read one element by index.
39    fn get(
40        &self,
41        self_handle: MiraHandle<dyn MiraArray>,
42        runtime: &Runtime,
43        index: usize,
44    ) -> Result<MiraManageable>;
45
46    /// Return whether the array is empty.
47    fn is_empty(&self) -> bool {
48        self.len() == 0
49    }
50
51    #[doc(hidden)]
52    fn resolve<'a>(&self, runtime: &'a Runtime) -> Result<Option<&'a dyn MiraArray>> {
53        let _ = runtime;
54        Ok(None)
55    }
56}
57
58/// A fixed-shape array whose length is known from its Rust type.
59pub trait MiraShapedArray: Any + 'static {
60    /// Return the fixed number of elements.
61    fn len() -> usize;
62
63    /// Read one element by index.
64    fn get(
65        &self,
66        self_handle: MiraHandle<dyn MiraArray>,
67        runtime: &Runtime,
68        index: usize,
69    ) -> Result<MiraManageable>;
70}
71
72impl<T: MiraShapedArray> MiraArray for T {
73    fn len(&self) -> usize {
74        T::len()
75    }
76
77    fn get(
78        &self,
79        self_handle: MiraHandle<dyn MiraArray>,
80        runtime: &Runtime,
81        index: usize,
82    ) -> Result<MiraManageable> {
83        T::get(self, self_handle, runtime, index)
84    }
85}
86
87impl<T: Clone + Into<MiraManageable> + 'static> MiraArray for Vec<T> {
88    fn len(&self) -> usize {
89        Vec::len(self)
90    }
91
92    fn get(
93        &self,
94        _self_handle: MiraHandle<dyn MiraArray>,
95        _runtime: &Runtime,
96        index: usize,
97    ) -> Result<MiraManageable> {
98        self.as_slice()
99            .get(index)
100            .cloned()
101            .map(Into::into)
102            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
103    }
104}
105
106impl<T: Clone + Into<MiraManageable> + 'static> From<Vec<T>> for MiraManageable {
107    fn from(value: Vec<T>) -> Self {
108        Self::from_array(value)
109    }
110}
111
112impl<T: Clone + Into<MiraManageable> + 'static, const N: usize> MiraArray for [T; N] {
113    fn len(&self) -> usize {
114        N
115    }
116
117    fn get(
118        &self,
119        _self_handle: MiraHandle<dyn MiraArray>,
120        _runtime: &Runtime,
121        index: usize,
122    ) -> Result<MiraManageable> {
123        self.as_slice()
124            .get(index)
125            .cloned()
126            .map(Into::into)
127            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
128    }
129}
130
131impl<T: Clone + Into<MiraManageable> + 'static, const N: usize> From<[T; N]> for MiraManageable {
132    fn from(value: [T; N]) -> Self {
133        Self::from_array(value)
134    }
135}
136
137impl<T: Clone + Into<MiraManageable> + 'static> MiraArray for Box<[T]> {
138    fn len(&self) -> usize {
139        self.as_ref().len()
140    }
141
142    fn get(
143        &self,
144        _self_handle: MiraHandle<dyn MiraArray>,
145        _runtime: &Runtime,
146        index: usize,
147    ) -> Result<MiraManageable> {
148        self.as_ref()
149            .get(index)
150            .cloned()
151            .map(Into::into)
152            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
153    }
154}
155
156impl<T: Clone + Into<MiraManageable> + 'static> From<Box<[T]>> for MiraManageable {
157    fn from(value: Box<[T]>) -> Self {
158        Self::from_array(value)
159    }
160}