array_object/convert/
from_integer.rs

1use crate::adaptor::*;
2use crate::convert::zigzag::Zigzag;
3use crate::error::ArrayObjectError;
4use crate::misc::Product;
5use crate::storage::*;
6
7macro_rules! from_unsigned_integer {
8    ($($ty:ty),*) => {
9        $(
10            impl From<$ty> for ArrayObject {
11                fn from(val: $ty) -> Self {
12                    let data = val.to_le_bytes().to_vec();
13                    Self {
14                        data,
15                        shape: vec![],
16                        datatype: DataType::UnsignedInteger,
17                    }
18                }
19            }
20            impl From<&$ty> for ArrayObject {
21                fn from(val: &$ty) -> Self {
22                    let data = val.to_le_bytes().to_vec();
23                    Self {
24                        data,
25                        shape: vec![],
26                        datatype: DataType::UnsignedInteger,
27                    }
28                }
29            }
30            impl From<Vec<$ty>> for ArrayObject {
31                fn from(val: Vec<$ty>) -> Self {
32                    let shape = vec![val.len() as u64];
33                    let mut data = Vec::<u8>::with_capacity(size_of::<$ty>() * val.len());
34                    for v in val {
35                        data.append(&mut v.to_le_bytes().to_vec());
36                    }
37                    Self {
38                        data,
39                        shape,
40                        datatype: DataType::UnsignedInteger,
41                    }
42                }
43            }
44            impl From<&Vec<$ty>> for ArrayObject {
45                fn from(val: &Vec<$ty>) -> Self {
46                    let shape = vec![val.len() as u64];
47                    let mut data = Vec::<u8>::with_capacity(size_of::<$ty>() * val.len());
48                    for v in val {
49                        data.append(&mut v.to_le_bytes().to_vec());
50                    }
51                    Self {
52                        data,
53                        shape,
54                        datatype: DataType::UnsignedInteger,
55                    }
56                }
57            }
58            impl<const N: usize> From<[$ty; N]> for ArrayObject {
59                fn from(val: [$ty; N]) -> Self {
60                    val.to_vec().into()
61                }
62            }
63            impl From<&[$ty]> for ArrayObject {
64                fn from(val: &[$ty]) -> Self {
65                    val.to_vec().into()
66                }
67            }
68            impl TryFrom<VecShape<$ty>> for ArrayObject {
69                type Error = ArrayObjectError;
70                fn try_from(VecShape(val, shape): VecShape<$ty>) -> Result<Self, Self::Error> {
71                    if val.len() != shape.product() as usize {
72                        return Err(ArrayObjectError::NumberOfElementsMismatch(val.len(), shape.product() as usize));
73                    }
74                    if shape.len() > 15 {
75                        return Err(ArrayObjectError::TooLargeDimension(shape.len()));
76                    }
77                    let mut temp: ArrayObject = val.into();
78                    temp.shape = shape;
79                    Ok(temp)
80                }
81            }
82        )*
83    };
84}
85
86from_unsigned_integer!(u8, u16, u32, u64, u128, usize);
87
88macro_rules! from_signed_integer {
89    ($($ty:ty),*) => {
90        $(
91            impl From<$ty> for ArrayObject {
92                fn from(val: $ty) -> Self {
93                    let data = val.zigzag().to_le_bytes().to_vec();
94                    Self {
95                        data,
96                        shape: vec![],
97                        datatype: DataType::SignedInteger,
98                    }
99                }
100            }
101            impl From<Vec<$ty>> for ArrayObject {
102                fn from(val: Vec<$ty>) -> Self {
103                    let shape = vec![val.len() as u64];
104                    let mut data = Vec::<u8>::with_capacity(size_of::<$ty>() * val.len());
105                    for v in val {
106                        data.append(&mut v.zigzag().to_le_bytes().to_vec());
107                    }
108                    Self {
109                        data,
110                        shape,
111                        datatype: DataType::SignedInteger,
112                    }
113                }
114            }
115            impl TryFrom<VecShape<$ty>> for ArrayObject {
116                type Error = ArrayObjectError;
117                fn try_from(VecShape(val, shape): VecShape<$ty>) -> Result<Self, Self::Error> {
118                    if val.len() != shape.product() as usize {
119                        return Err(ArrayObjectError::NumberOfElementsMismatch(val.len(), shape.product() as usize));
120                    }
121                    if shape.len() > 15 {
122                        return Err(ArrayObjectError::TooLargeDimension(shape.len()));
123                    }
124                    let mut temp: ArrayObject = val.into();
125                    temp.shape = shape;
126                    Ok(temp)
127                }
128            }
129        )*
130    };
131}
132
133from_signed_integer!(i8, i16, i32, i64, i128, isize);
array_object/convert/from_integer.rs

array_object/convert/
from_integer.rs
