pub(crate) shape: Shape,

pub(crate) data: CowSlice<T>,

pub(crate) meta: Option<Arc<ArrayMeta>>,

/// The label

#[serde(default, skip_serializing_if = "Option::is_none")]

pub label: Option<EcoString>,

/// Flags for the array

#[serde(default, skip_serializing_if = "ArrayFlags::is_empty")]

pub flags: ArrayFlags,

/// The keys of a map array

#[serde(default, skip_serializing_if = "Option::is_none")]

pub map_keys: Option<MapKeys>,

/// The pointer value for FFI

#[serde(skip)]

pub pointer: Option<MetaPtr>,

/// The kind of system handle

#[serde(skip)]

pub handle_kind: Option<HandleKind>,

/// Take the persistent metadata

pub fn take_per_meta(&mut self) -> PersistentMeta {

let label = self.label.take();

let map_keys = self.map_keys.take();

PersistentMeta { label, map_keys }

}

/// Set the persistent metadata

pub fn set_per_meta(&mut self, per_meta: PersistentMeta) {

self.label = per_meta.label;

self.map_keys = per_meta.map_keys;

}

/// Reset the flags

pub fn reset_flags(&mut self) {

self.flags.reset();

}

/// Combine the metadata with another

pub fn combine(&mut self, other: &Self) {

self.flags &= other.flags;

self.map_keys = None;

if self.handle_kind != other.handle_kind {

self.handle_kind = None;

}

}

/// Check if the metadata is the default

pub fn is_default(&self) -> bool {

self.label.is_none()

&& self.map_keys.is_none()

&& self.handle_kind.is_none()

&& self.pointer.is_none()

&& self.flags.is_empty()

}

/// The pointer value

pub ptr: usize,

/// Whether the pointer should prevent the array's value from being shown

pub raw: bool,

/// Get a null metadata pointer

pub const fn null() -> Self {

Self { ptr: 0, raw: true }

}

/// Create a new metadata pointer

pub fn new<T: ?Sized>(ptr: *const T, raw: bool) -> Self {

Self {

ptr: ptr as *const () as usize,

raw,

}

}

/// Get the pointer as a raw pointer

pub fn get<T>(&self) -> *const T {

self.ptr as *const T

}

/// Get the pointer as a raw pointer

pub fn get_mut<T>(&self) -> *mut T {

self.ptr as *mut T

}

fn eq(&self, other: &Self) -> bool {

self.ptr == other.ptr

}

/// Check if the array is boolean

pub fn is_boolean(self) -> bool {

self.contains(Self::BOOLEAN)

}

/// Reset all flags

pub fn reset(&mut self) {

*self = Self::NONE;

}

/// XOR this metadata with another

pub fn xor(self, other: Self) -> Self {

Self {

label: self.label.xor(other.label),

map_keys: self.map_keys.xor(other.map_keys),

}

}

/// XOR several metadatas

pub fn xor_all(metas: impl IntoIterator<Item = Self>) -> Self {

let mut label = None;

let mut map_keys = None;

let mut set_label = false;

let mut set_map_keys = false;

for meta in metas {

if let Some(l) = meta.label {

if set_label {

label = None;

} else {

label = Some(l);

set_label = true;

}

}

if let Some(keys) = meta.map_keys {

if set_map_keys {

map_keys = None;

} else {

map_keys = Some(keys);

set_map_keys = true;

}

}

}

Self { label, map_keys }

}

fn default() -> Self {

Self {

shape: 0.into(),

data: CowSlice::new(),

meta: None,

}

}

Array<T>: GridFmt,

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

write!(f, "{}", self.grid_string(true))

}

Array<T>: GridFmt,

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self.rank() {

0 => write!(f, "{}", self.data[0]),

1 => {

let (start, end) = T::format_delims();

write!(f, "{}", start)?;

for (i, x) in self.data.iter().enumerate() {

if i > 0 {

write!(f, "{}", T::format_sep())?;

}

write!(f, "{x}")?;

}

write!(f, "{}", end)

}

_ => {

write!(f, "\n{}", self.grid_string(false))

}

}

}

let elems = if shape.contains(&0) {

0

} else {

shape.iter().product()

};

debug_assert_eq!(

elems, len,

"shape {shape:?} does not match data length {}",

len

);

#[track_caller]

/// Create an array from a shape and data

///

/// # Panics

/// Panics in debug mode if the shape does not match the data length

pub fn new(shape: impl Into<Shape>, data: impl Into<CowSlice<T>>) -> Self {

let shape = shape.into();

let data = data.into();

validate_shape(&shape, data.len());

Self {

shape,

data,

meta: None,

}

}

#[track_caller]

#[inline(always)]

/// Debug-only function to validate that the shape matches the data length

pub(crate) fn validate_shape(&self) {

validate_shape(&self.shape, self.data.len());

}

/// Get the number of rows in the array

pub fn row_count(&self) -> usize {

self.shape.first().copied().unwrap_or(1)

}

/// Get the number of elements in the array

pub fn element_count(&self) -> usize {

self.data.len()

}

/// Get the number of elements in a row

pub fn row_len(&self) -> usize {

self.shape.iter().skip(1).product()

}

/// Get the rank of the array

pub fn rank(&self) -> usize {

self.shape.len()

}

/// Get the shape of the array

pub fn shape(&self) -> &Shape {

&self.shape

}

/// Get a mutable reference to the shape of the array

pub fn shape_mut(&mut self) -> &mut Shape {

&mut self.shape

}

/// Iterate over the elements of the array

pub fn elements(&self) -> impl ExactDoubleIterator<Item = &T> {

self.data.iter()

}

/// Get the metadata of the array

pub fn meta(&self) -> &ArrayMeta {

self.meta.as_deref().unwrap_or(&DEFAULT_META)

}

pub(crate) fn meta_mut_impl(meta: &mut Option<Arc<ArrayMeta>>) -> &mut ArrayMeta {

let meta = meta.get_or_insert_with(Default::default);

Arc::make_mut(meta)

}

/// Get a mutable reference to the metadata of the array if it exists

pub fn get_meta_mut(&mut self) -> Option<&mut ArrayMeta> {

self.meta.as_mut().map(Arc::make_mut)

}

/// Get a mutable reference to the metadata of the array

pub fn meta_mut(&mut self) -> &mut ArrayMeta {

Self::meta_mut_impl(&mut self.meta)

}

/// Take the label from the metadata

pub fn take_label(&mut self) -> Option<EcoString> {

self.get_meta_mut().and_then(|meta| meta.label.take())

}

/// Take the map keys from the metadata

pub fn take_map_keys(&mut self) -> Option<MapKeys> {

self.get_meta_mut().and_then(|meta| meta.map_keys.take())

}

/// The the persistent metadata of the array

pub fn take_per_meta(&mut self) -> PersistentMeta {

self.get_meta_mut()

.map(ArrayMeta::take_per_meta)

.unwrap_or_default()

}

/// Set the map keys in the metadata

pub fn set_per_meta(&mut self, per_meta: PersistentMeta) {

if self.meta().map_keys.is_some() != per_meta.map_keys.is_some() {

self.meta_mut().map_keys = per_meta.map_keys;

}

if self.meta().label.is_some() != per_meta.label.is_some() {

self.meta_mut().label = per_meta.label;

}

}

/// Get a reference to the map keys

pub fn map_keys(&self) -> Option<&MapKeys> {

self.meta().map_keys.as_ref()

}

/// Get a mutable reference to the map keys

pub fn map_keys_mut(&mut self) -> Option<&mut MapKeys> {

self.get_meta_mut().and_then(|meta| meta.map_keys.as_mut())

}

/// Reset all metadata flags

pub fn reset_meta_flags(&mut self) {

self.get_meta_mut().map(ArrayMeta::reset_flags);

}

/// Get an iterator over the row slices of the array

pub fn row_slices(

&self,

) -> impl ExactSizeIterator<Item = &[T]> + DoubleEndedIterator + Clone + Send + Sync

where

T: Send + Sync,

{

(0..self.row_count()).map(move |row| self.row_slice(row))

}

/// Get a slice of a row

#[track_caller]

pub fn row_slice(&self, row: usize) -> &[T] {

let row_len = self.row_len();

&self.data[row * row_len..(row + 1) * row_len]

}

/// Combine the metadata of two arrays

///

/// This combines:

/// - flags

/// - map keys

/// - handle kind

///

/// Notably, this does not combine the label, as label

/// combination should be more nuanced.

pub fn combine_meta(&mut self, other: &ArrayMeta) {

if !(self.meta.is_none() && other.is_default()) {

self.meta_mut().combine(other);

}

}

/// Create a scalar array

pub fn scalar(data: T) -> Self {

Self::new(Shape::SCALAR, cowslice![data])

}

/// Attempt to convert the array into a scalar

pub fn into_scalar(self) -> Result<T, Self> {

if self.shape.is_empty() {

Ok(self.data.into_iter().next().unwrap())

} else {

Err(self)

}

}

/// Attempt to get a reference to the scalar value

pub fn as_scalar(&self) -> Option<&T> {

if self.shape.is_empty() {

Some(&self.data[0])

} else {

None

}

}

/// Attempt to get a mutable reference to the scalar value

pub fn as_scalar_mut(&mut self) -> Option<&mut T> {

if self.shape.is_empty() {

Some(&mut self.data.as_mut_slice()[0])

} else {

None

}

}

/// Get an iterator over the row arrays of the array

pub fn rows(&self) -> impl ExactSizeIterator<Item = Self> + DoubleEndedIterator + '_ {

(0..self.row_count()).map(|row| self.row(row))

}

pub(crate) fn row_shaped_slice(&self, index: usize, row_shape: Shape) -> Self {

let row_len = row_shape.elements();

let start = index * row_len;

let end = start + row_len;

Self::new(row_shape, self.data.slice(start..end))

}

/// Get an iterator over the row arrays of the array that have the given shape

pub fn row_shaped_slices(

&self,

row_shape: Shape,

) -> impl ExactSizeIterator<Item = Self> + DoubleEndedIterator + '_ {

let row_len = row_shape.elements();

let row_count = self.element_count() / row_len;

(0..row_count).map(move |i| {

let start = i * row_len;

let end = start + row_len;

Self::new(row_shape.clone(), self.data.slice(start..end))

})

}

/// Get an iterator over the row arrays of the array that have the given shape

pub fn into_row_shaped_slices(self, row_shape: Shape) -> impl DoubleEndedIterator<Item = Self> {

let row_len = row_shape.elements();

let zero_count = if row_len == 0 { self.row_count() } else { 0 };

let row_sh = row_shape.clone();

let nonzero = self

.data

.into_slices(row_len)

.map(move |data| Self::new(row_sh.clone(), data));

let zero = (0..zero_count).map(move |_| Self::new(row_shape.clone(), CowSlice::new()));

nonzero.chain(zero)

}

/// Get a row array

#[track_caller]

pub fn row(&self, row: usize) -> Self {

if self.rank() == 0 {

let mut row = self.clone();

row.take_map_keys();

row.take_label();

return row;

}

let row_count = self.row_count();

if row >= row_count {

panic!("row index out of bounds: {} >= {}", row, row_count);

}

let row_len = self.row_len();

let start = row * row_len;

let end = start + row_len;

let mut row = Self::new(&self.shape[1..], self.data.slice(start..end));

if self.meta().flags != ArrayFlags::NONE {

row.meta_mut().flags = self.meta().flags;

}

row

}

#[track_caller]

pub(crate) fn depth_row(&self, depth: usize, row: usize) -> Self {

if self.rank() <= depth {

let mut row = self.clone();

row.take_map_keys();

row.take_label();

return row;

}

let row_count: usize = self.shape[..depth + 1].iter().product();

if row >= row_count {

panic!("row index out of bounds: {} >= {}", row, row_count);

}

let row_len: usize = self.shape[depth + 1..].iter().product();

let start = row * row_len;

let end = start + row_len;

Self::new(&self.shape[depth + 1..], self.data.slice(start..end))

}

#[track_caller]

/// Create an array that is a slice of this array's rows

///

/// Generally doesn't allocate

///

/// - `start` must be <= `end`

/// - `start` must be < `self.row_count()`

/// - `end` must be <= `self.row_count()`

pub fn slice_rows(&self, start: usize, end: usize) -> Self {

assert!(start <= end);

assert!(start < self.row_count());

assert!(end <= self.row_count());

let row_len = self.row_len();

let mut shape = self.shape.clone();

shape[0] = end - start;

let start = start * row_len;

let end = end * row_len;

Self::new(shape, self.data.slice(start..end))

}

/// Consume the array and get an iterator over its rows

pub fn into_rows(self) -> impl ExactSizeIterator<Item = Self> + DoubleEndedIterator {

(0..self.row_count()).map(move |i| self.row(i))

}

pub(crate) fn first_dim_zero(&self) -> Self {

if self.rank() == 0 {

return self.clone();

}

let mut shape = self.shape.clone();

shape[0] = 0;

Array::new(shape, CowSlice::new())

}

/// Get a pretty-printed string representing the array

///

/// This is what is printed by the `&s` function

pub fn show(&self) -> String {

self.grid_string(true)

}

pub(crate) fn pop_row(&mut self) -> Option<Self> {

if self.row_count() == 0 {

return None;

}

let data = self.data.split_off(self.data.len() - self.row_len());

self.shape[0] -= 1;

let shape: Shape = self.shape[1..].into();

self.validate_shape();

Some(Self::new(shape, data))

}

/// Get a mutable slice of a row

#[track_caller]

pub fn row_slice_mut(&mut self, row: usize) -> &mut [T] {

let row_len = self.row_len();

&mut self.data.as_mut_slice()[row * row_len..(row + 1) * row_len]

}

/// Convert the elements of the array

#[inline(always)]

pub fn convert<U>(self) -> Array<U>

where

T: Into<U> + 'static,

U: Clone + 'static,

{

if TypeId::of::<T>() == TypeId::of::<U>() {

unsafe { std::mem::transmute::<Array<T>, Array<U>>(self) }

} else {

self.convert_with(Into::into)

}

}

/// Convert the elements of the array with a function

pub fn convert_with<U: Clone>(self, f: impl FnMut(T) -> U) -> Array<U> {

Array {

shape: self.shape,

data: self.data.into_iter().map(f).collect(),

meta: self.meta,

}

}

/// Convert the elements of the array with a fallible function

pub fn try_convert_with<U: Clone, E>(

self,

f: impl FnMut(T) -> Result<U, E>,

) -> Result<Array<U>, E> {

Ok(Array {

shape: self.shape,

data: self.data.into_iter().map(f).collect::<Result<_, _>>()?,

meta: self.meta,

})

}

/// Convert the elements of the array without consuming it

pub fn convert_ref<U>(&self) -> Array<U>

where

T: Into<U>,

U: Clone,

{

self.convert_ref_with(Into::into)

}

/// Convert the elements of the array with a function without consuming it

pub fn convert_ref_with<U: Clone>(&self, f: impl FnMut(T) -> U) -> Array<U> {

Array {

shape: self.shape.clone(),

data: self.data.iter().cloned().map(f).collect(),

meta: self.meta.clone(),

}

}

pub(crate) fn json_bool(b: bool) -> Self {

let mut arr = Self::from(b);

arr.meta_mut().flags |= ArrayFlags::BOOLEAN_LITERAL;

arr

}

/// Attempt to unbox a scalar box array

pub fn into_unboxed(self) -> Result<Value, Self> {

match self.into_scalar() {

Ok(v) => Ok(v.0),

Err(a) => Err(a),

}

}

/// Attempt to unbox a scalar box array

pub fn as_unboxed(&self) -> Option<&Value> {

self.as_scalar().map(|v| &v.0)

}

/// Attempt to unbox a scalar box array

pub fn as_unboxed_mut(&mut self) -> Option<&mut Value> {

self.as_scalar_mut().map(|v| &mut v.0)

}

fn eq(&self, other: &Array<U>) -> bool {

if self.shape() != other.shape() {

return false;

}

if self.map_keys() != other.map_keys() {

return false;

}

self.data

.iter()

.zip(&other.data)

.all(|(a, b)| a.array_eq(b))

}

fn partial_cmp(&self, other: &Array<U>) -> Option<Ordering> {

let rank_cmp = self.rank().cmp(&other.rank());

if rank_cmp != Ordering::Equal {

return Some(rank_cmp);

}

let cmp = self

.data

.iter()

.zip(&other.data)

.map(|(a, b)| a.array_cmp(b))

.find(|o| o != &Ordering::Equal)

.unwrap_or_else(|| self.shape.cmp(&other.shape));

Some(cmp)

}

fn cmp(&self, other: &Self) -> Ordering {

self.partial_cmp(other).unwrap()

}

fn hash<H: Hasher>(&self, hasher: &mut H) {

if let Some(keys) = self.map_keys() {

keys.hash(hasher);

}

T::TYPE_ID.hash(hasher);

if let Some(scalar) = self.as_scalar() {

if let Some(value) = scalar.nested_value() {

value.hash(hasher);

return;

}

}

self.shape.hash(hasher);

self.data.iter().for_each(|x| x.array_hash(hasher));

}

fn from(data: T) -> Self {

Self::scalar(data)

}

fn from(data: EcoVec<T>) -> Self {

Self::new(data.len(), data)

}

fn from(data: CowSlice<T>) -> Self {

Self::new(data.len(), data)

}

fn from(data: &'a [T]) -> Self {

Self::new(data.len(), data)

}

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {

Self::from(iter.into_iter().collect::<CowSlice<T>>())

}

fn from(s: String) -> Self {

Self::new(s.len(), s.chars().collect::<CowSlice<_>>())

}

fn from(data: Vec<bool>) -> Self {

Self::new(

data.len(),

data.into_iter().map(u8::from).collect::<CowSlice<_>>(),

)

}

fn from(data: bool) -> Self {

let mut arr = Self::new(Shape::SCALAR, cowslice![u8::from(data)]);