1use std::marker::PhantomData;
  2
  3use crate::{
  4    alloc_aligned,
  5    layouts::{Backend, Data, DataMut, DataRef, DataView, DataViewMut, ZnxInfos, ZnxView},
  6    oep::CnvPVecBytesOfImpl,
  7};
  8
  9pub struct CnvPVecR<D: Data, BE: Backend> {
 10    data: D,
 11    n: usize,
 12    size: usize,
 13    cols: usize,
 14    _phantom: PhantomData<BE>,
 15}
 16
 17impl<D: Data, BE: Backend> ZnxInfos for CnvPVecR<D, BE> {
 18    fn cols(&self) -> usize {
 19        self.cols
 20    }
 21
 22    fn n(&self) -> usize {
 23        self.n
 24    }
 25
 26    fn rows(&self) -> usize {
 27        1
 28    }
 29
 30    fn size(&self) -> usize {
 31        self.size
 32    }
 33}
 34
 35impl<D: Data, BE: Backend> DataView for CnvPVecR<D, BE> {
 36    type D = D;
 37    fn data(&self) -> &Self::D {
 38        &self.data
 39    }
 40}
 41
 42impl<D: Data, B: Backend> DataViewMut for CnvPVecR<D, B> {
 43    fn data_mut(&mut self) -> &mut Self::D {
 44        &mut self.data
 45    }
 46}
 47
 48impl<D: DataRef, BE: Backend> ZnxView for CnvPVecR<D, BE> {
 49    type Scalar = BE::ScalarPrep;
 50}
 51
 52impl<D: DataRef + From<Vec<u8>>, B: Backend> CnvPVecR<D, B>
 53where
 54    B: CnvPVecBytesOfImpl,
 55{
 56    pub fn alloc(n: usize, cols: usize, size: usize) -> Self {
 57        let data: Vec<u8> = alloc_aligned::<u8>(B::bytes_of_cnv_pvec_right_impl(n, cols, size));
 58        Self {
 59            data: data.into(),
 60            n,
 61            size,
 62            cols,
 63            _phantom: PhantomData,
 64        }
 65    }
 66
 67    pub fn from_bytes(n: usize, cols: usize, size: usize, bytes: impl Into<Vec<u8>>) -> Self {
 68        let data: Vec<u8> = bytes.into();
 69        assert!(data.len() == B::bytes_of_cnv_pvec_right_impl(n, cols, size));
 70        Self {
 71            data: data.into(),
 72            n,
 73            size,
 74            cols,
 75            _phantom: PhantomData,
 76        }
 77    }
 78}
 79
 80impl<D: Data, B: Backend> CnvPVecR<D, B> {
 81    pub fn from_data(data: D, n: usize, cols: usize, size: usize) -> Self {
 82        Self {
 83            data,
 84            n,
 85            cols,
 86            size,
 87            _phantom: PhantomData,
 88        }
 89    }
 90}
 91
 92pub struct CnvPVecL<D: Data, BE: Backend> {
 93    data: D,
 94    n: usize,
 95    size: usize,
 96    cols: usize,
 97    _phantom: PhantomData<BE>,
 98}
 99
100impl<D: Data, BE: Backend> ZnxInfos for CnvPVecL<D, BE> {
101    fn cols(&self) -> usize {
102        self.cols
103    }
104
105    fn n(&self) -> usize {
106        self.n
107    }
108
109    fn rows(&self) -> usize {
110        1
111    }
112
113    fn size(&self) -> usize {
114        self.size
115    }
116}
117
118impl<D: Data, BE: Backend> DataView for CnvPVecL<D, BE> {
119    type D = D;
120    fn data(&self) -> &Self::D {
121        &self.data
122    }
123}
124
125impl<D: Data, B: Backend> DataViewMut for CnvPVecL<D, B> {
126    fn data_mut(&mut self) -> &mut Self::D {
127        &mut self.data
128    }
129}
130
131impl<D: DataRef, BE: Backend> ZnxView for CnvPVecL<D, BE> {
132    type Scalar = BE::ScalarPrep;
133}
134
135impl<D: DataRef + From<Vec<u8>>, B: Backend> CnvPVecL<D, B>
136where
137    B: CnvPVecBytesOfImpl,
138{
139    pub fn alloc(n: usize, cols: usize, size: usize) -> Self {
140        let data: Vec<u8> = alloc_aligned::<u8>(B::bytes_of_cnv_pvec_left_impl(n, cols, size));
141        Self {
142            data: data.into(),
143            n,
144            size,
145            cols,
146            _phantom: PhantomData,
147        }
148    }
149
150    pub fn from_bytes(n: usize, cols: usize, size: usize, bytes: impl Into<Vec<u8>>) -> Self {
151        let data: Vec<u8> = bytes.into();
152        assert!(data.len() == B::bytes_of_cnv_pvec_left_impl(n, cols, size));
153        Self {
154            data: data.into(),
155            n,
156            size,
157            cols,
158            _phantom: PhantomData,
159        }
160    }
161}
162
163impl<D: Data, B: Backend> CnvPVecL<D, B> {
164    pub fn from_data(data: D, n: usize, cols: usize, size: usize) -> Self {
165        Self {
166            data,
167            n,
168            cols,
169            size,
170            _phantom: PhantomData,
171        }
172    }
173}
174
175pub trait CnvPVecRToRef<BE: Backend> {
176    fn to_ref(&self) -> CnvPVecR<&[u8], BE>;
177}
178
179impl<D: DataRef, BE: Backend> CnvPVecRToRef<BE> for CnvPVecR<D, BE> {
180    fn to_ref(&self) -> CnvPVecR<&[u8], BE> {
181        CnvPVecR {
182            data: self.data.as_ref(),
183            n: self.n,
184            size: self.size,
185            cols: self.cols,
186            _phantom: self._phantom,
187        }
188    }
189}
190
191pub trait CnvPVecRToMut<BE: Backend> {
192    fn to_mut(&mut self) -> CnvPVecR<&mut [u8], BE>;
193}
194
195impl<D: DataMut, BE: Backend> CnvPVecRToMut<BE> for CnvPVecR<D, BE> {
196    fn to_mut(&mut self) -> CnvPVecR<&mut [u8], BE> {
197        CnvPVecR {
198            data: self.data.as_mut(),
199            n: self.n,
200            size: self.size,
201            cols: self.cols,
202            _phantom: self._phantom,
203        }
204    }
205}
206
207pub trait CnvPVecLToRef<BE: Backend> {
208    fn to_ref(&self) -> CnvPVecL<&[u8], BE>;
209}
210
211impl<D: DataRef, BE: Backend> CnvPVecLToRef<BE> for CnvPVecL<D, BE> {
212    fn to_ref(&self) -> CnvPVecL<&[u8], BE> {
213        CnvPVecL {
214            data: self.data.as_ref(),
215            n: self.n,
216            size: self.size,
217            cols: self.cols,
218            _phantom: self._phantom,
219        }
220    }
221}
222
223pub trait CnvPVecLToMut<BE: Backend> {
224    fn to_mut(&mut self) -> CnvPVecL<&mut [u8], BE>;
225}
226
227impl<D: DataMut, BE: Backend> CnvPVecLToMut<BE> for CnvPVecL<D, BE> {
228    fn to_mut(&mut self) -> CnvPVecL<&mut [u8], BE> {
229        CnvPVecL {
230            data: self.data.as_mut(),
231            n: self.n,
232            size: self.size,
233            cols: self.cols,
234            _phantom: self._phantom,
235        }
236    }
237}