reflectx 0.0.1

tools for performing value/type reflection with zinq types.
Documentation
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Slice {
    pub(crate) ty: crate::SliceType,
    pub(crate) value: Vec<crate::Value>,
}

impl Slice {
    pub fn to_type(&self) -> crate::Type {
        return crate::Type::Slice(self.ty.clone());
    }

    pub fn len(&self) -> usize {
        return self.value.len();
    }

    pub fn iter(&self) -> std::slice::Iter<'_, crate::Value> {
        return self.value.iter();
    }
}

impl PartialEq<crate::Value> for Slice {
    fn eq(&self, other: &crate::Value) -> bool {
        return other.is_slice() && other.as_slice() == self;
    }
}

impl From<&[crate::Value]> for Slice {
    fn from(value: &[crate::Value]) -> Self {
        return Self {
            ty: crate::SliceType {
                ty: Box::new(value.first().unwrap().to_type()),
                capacity: None,
            },
            value: value.to_vec(),
        };
    }
}

impl std::fmt::Display for Slice {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[")?;

        for (i, value) in self.value.iter().enumerate() {
            write!(f, "{}", value)?;

            if i < self.value.len() - 1 {
                write!(f, ", ")?;
            }
        }

        return write!(f, "]");
    }
}

impl crate::ToType for Slice {
    fn to_type(&self) -> crate::Type {
        return crate::Type::Slice(self.ty.clone());
    }
}

impl crate::ToValue for Slice {
    fn to_value(self) -> crate::Value {
        return crate::Value::Slice(self.clone());
    }
}

impl crate::AsValue for Slice {
    fn as_value(&self) -> crate::Value {
        return crate::Value::Slice(self.clone());
    }
}

impl<T> crate::ToValue for &[T]
where
    T: Clone + crate::TypeOf + crate::ToValue,
{
    fn to_value(self) -> crate::Value {
        return crate::Value::Slice(Slice {
            ty: crate::SliceType {
                ty: Box::new(T::type_of()),
                capacity: None,
            },
            value: self.iter().map(|v| v.clone().to_value()).collect(),
        });
    }
}

impl<T> crate::AsValue for &[T]
where
    T: Clone + crate::TypeOf + crate::AsValue,
{
    fn as_value(&self) -> crate::Value {
        return crate::Value::Slice(Slice {
            ty: crate::SliceType {
                ty: Box::new(T::type_of()),
                capacity: None,
            },
            value: self.iter().map(|v| v.clone().as_value()).collect(),
        });
    }
}

impl<const N: usize, T> crate::ToValue for [T; N]
where
    T: Clone + crate::TypeOf + crate::ToValue,
{
    fn to_value(self) -> crate::Value {
        return crate::Value::Slice(Slice {
            ty: crate::SliceType {
                ty: Box::new(T::type_of()),
                capacity: Some(N),
            },
            value: self.iter().map(|v| v.clone().to_value()).collect(),
        });
    }
}

impl<const N: usize, T> crate::AsValue for [T; N]
where
    T: Clone + crate::TypeOf + crate::AsValue,
{
    fn as_value(&self) -> crate::Value {
        return crate::Value::Slice(Slice {
            ty: crate::SliceType {
                ty: Box::new(T::type_of()),
                capacity: Some(N),
            },
            value: self.iter().map(|v| v.clone().as_value()).collect(),
        });
    }
}

impl AsRef<[crate::Value]> for Slice {
    fn as_ref(&self) -> &[crate::Value] {
        return self.value.as_slice();
    }
}

impl AsMut<[crate::Value]> for Slice {
    fn as_mut(&mut self) -> &mut [crate::Value] {
        return self.value.as_mut_slice();
    }
}

impl std::ops::Deref for Slice {
    type Target = [crate::Value];

    fn deref(&self) -> &Self::Target {
        return self.value.as_slice();
    }
}

impl std::ops::DerefMut for Slice {
    fn deref_mut(&mut self) -> &mut Self::Target {
        return self.value.as_mut_slice();
    }
}

impl std::ops::Index<usize> for Slice {
    type Output = crate::Value;

    fn index(&self, index: usize) -> &Self::Output {
        return self.value.index(index);
    }
}

impl std::ops::IndexMut<usize> for Slice {
    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
        return self.value.index_mut(index);
    }
}

#[cfg(test)]
mod test {
    use crate::*;

    #[test]
    pub fn ok() {
        let value = value_of!([1, 2, 3]);

        assert!(value.is_slice());
        assert_eq!(value.len(), 3);
        assert_eq!(value.to_type().len(), 3);
        assert_eq!(value.to_type().id(), "[i32; 3]");

        for (i, value) in value.as_slice().iter().enumerate() {
            assert!(value.is_i32());
            assert_eq!(i + 1, value.to_i32() as usize);
        }
    }
}