bitshifter / glam-rs / 184

pending completion

Build # 184

Build Type

Pull #18

travis-ci

Committed by

web-flow

Commit Message

Add matrix serialization tests.
From @bitshifter's branch but adapted to flat serialization.

https://github.com/bitshifter/glam-rs/commit/ae35ffc7a

Pull Request Pull Request #18: Implement Mat2, Mat3 & Mat4 serialization

Run Details

24 of 24 new or added lines in 1 file covered. (100.0%)

2537 of 2921 relevant lines covered (86.85%)

2.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/f32/glam_serde.rs

use crate::{Quat, Vec2, Vec3, Vec4, Mat2, Mat3, Mat4};

use serde::{
    de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
    ser::{Serialize, SerializeTupleStruct, Serializer},
};

use std::fmt;

impl Serialize for Vec2 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let (x, y) = (*self).into();
        let mut state = serializer.serialize_tuple_struct("Vec2", 2)?;
        state.serialize_field(&x)?;
        state.serialize_field(&y)?;
        state.end()
    }
}

#[cfg(feature = "serde")]
impl Serialize for Vec3 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let (x, y, z) = (*self).into();
        // 3 is the number of fields in the struct.
        let mut state = serializer.serialize_tuple_struct("Vec3", 3)?;
        state.serialize_field(&x)?;
        state.serialize_field(&y)?;
        state.serialize_field(&z)?;
        state.end()
    }
}

#[cfg(feature = "serde")]
impl Serialize for Vec4 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let (x, y, z, w) = (*self).into();
        // 4 is the number of fields in the struct.
        let mut state = serializer.serialize_tuple_struct("Vec4", 4)?;
        state.serialize_field(&x)?;
        state.serialize_field(&y)?;
        state.serialize_field(&z)?;
        state.serialize_field(&w)?;
        state.end()
    }
}

#[cfg(feature = "serde")]
impl Serialize for Quat {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let (x, y, z, w) = (*self).into();
        // 4 is the number of fields in the struct.
        let mut state = serializer.serialize_tuple_struct("Quat", 4)?;
        state.serialize_field(&x)?;
        state.serialize_field(&y)?;
        state.serialize_field(&z)?;
        state.serialize_field(&w)?;
        state.end()
    }
}

#[cfg(feature = "serde")]
impl Serialize for Mat2 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let f: &[f32; 4] = self.as_ref();
        let mut state = serializer.serialize_tuple_struct("Mat2", 4)?;
        state.serialize_field(&f[0])?;
        state.serialize_field(&f[1])?;
        state.serialize_field(&f[2])?;
        state.serialize_field(&f[3])?;
        state.end()
    }
}

#[cfg(feature = "serde")]
impl Serialize for Mat3 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let (m00, m01, m02) = self.x_axis.into();
        let (m10, m11, m12) = self.y_axis.into();
        let (m20, m21, m22) = self.z_axis.into();

        let mut state = serializer.serialize_tuple_struct("Mat3", 9)?;
        state.serialize_field(&m00)?;
        state.serialize_field(&m01)?;
        state.serialize_field(&m02)?;
        state.serialize_field(&m10)?;
        state.serialize_field(&m11)?;
        state.serialize_field(&m12)?;
        state.serialize_field(&m20)?;
        state.serialize_field(&m21)?;
        state.serialize_field(&m22)?;
        state.end()
    }
}

#[cfg(feature = "serde")]
impl Serialize for Mat4 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let f: &[f32; 16] = self.as_ref();
        let mut state = serializer.serialize_tuple_struct("Mat4", 16)?;
        for i in 0..16 {
            state.serialize_field(&f[i])?;
        }
        state.end()
    }
}

impl<'de> Deserialize<'de> for Vec2 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct Vec2Visitor;

        // TODO: Not sure why this line is reported as uncovered
        #[cfg_attr(tarpaulin, skip)]
        impl<'de> Visitor<'de> for Vec2Visitor {
            type Value = Vec2;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Vec2")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Vec2, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let x = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                let y = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                Ok(Vec2::new(x, y))
            }
        }

        deserializer.deserialize_tuple_struct("Vec2", 2, Vec2Visitor)
    }
}

impl<'de> Deserialize<'de> for Vec3 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct Vec3Visitor;

        // TODO: Not sure why this line is reported as uncovered
        #[cfg_attr(tarpaulin, skip)]
        impl<'de> Visitor<'de> for Vec3Visitor {
            type Value = Vec3;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Vec2")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Vec3, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let x = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                let y = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                let z = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(2, &self))?;
                Ok(Vec3::new(x, y, z))
            }
        }

        deserializer.deserialize_tuple_struct("Vec3", 3, Vec3Visitor)
    }
}

impl<'de> Deserialize<'de> for Vec4 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct Vec4Visitor;

        // TODO: Not sure why this line is reported as uncovered
        #[cfg_attr(tarpaulin, skip)]
        impl<'de> Visitor<'de> for Vec4Visitor {
            type Value = Vec4;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Vec2")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Vec4, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let x = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                let y = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                let z = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(2, &self))?;
                let w = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(3, &self))?;
                Ok(Vec4::new(x, y, z, w))
            }
        }

        deserializer.deserialize_tuple_struct("Vec4", 4, Vec4Visitor)
    }
}

impl<'de> Deserialize<'de> for Quat {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct QuatVisitor;

        // TODO: Not sure why this line is reported as uncovered
        #[cfg_attr(tarpaulin, skip)]
        impl<'de> Visitor<'de> for QuatVisitor {
            type Value = Quat;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Vec2")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Quat, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let x = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                let y = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                let z = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(2, &self))?;
                let w = seq
                    .next_element()?
                    .ok_or_else(|| de::Error::invalid_length(3, &self))?;
                Ok(Quat::new(x, y, z, w))
            }
        }

        deserializer.deserialize_tuple_struct("Quat", 4, QuatVisitor)
    }
}

impl<'de> Deserialize<'de> for Mat2 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct Mat2Visitor;

        // TODO: Not sure why this line is reported as uncovered
        #[cfg_attr(tarpaulin, skip)]
        impl<'de> Visitor<'de> for Mat2Visitor {
            type Value = Mat2;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Mat2")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Mat2, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let mut f = { [0.0; 4] };
                for i in 0..4 {
                    f[i] = seq
                        .next_element()?
                        .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                }
                let x = Vec2::new(f[0], f[1]);
                let y = Vec2::new(f[2], f[3]);
                Ok(Mat2::new(x, y))
            }
        }

        deserializer.deserialize_tuple_struct("Mat2", 4, Mat2Visitor)
    }
}

impl<'de> Deserialize<'de> for Mat3 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct Mat3Visitor;

        // TODO: Not sure why this line is reported as uncovered
        #[cfg_attr(tarpaulin, skip)]
        impl<'de> Visitor<'de> for Mat3Visitor {
            type Value = Mat3;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Mat3")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Mat3, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let mut f = { [0.0; 9] };
                for i in 0..9 {
                    f[i] = seq
                        .next_element()?
                        .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                }
                let x = Vec3::new(f[0], f[1], f[2]);
                let y = Vec3::new(f[3], f[4], f[5]);
                let z = Vec3::new(f[6], f[7], f[8]);
                Ok(Mat3::new(x, y, z))
            }
        }

        deserializer.deserialize_tuple_struct("Mat3", 9, Mat3Visitor)
    }
}

impl<'de> Deserialize<'de> for Mat4 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct Mat4Visitor;

        // TODO: Not sure why this line is reported as uncovered
        #[cfg_attr(tarpaulin, skip)]
        impl<'de> Visitor<'de> for Mat4Visitor {
            type Value = Mat4;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Mat4")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Mat4, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let mut f = { [0.0; 16] };
                for i in 0..16 {
                    f[i] = seq
                        .next_element()?
                        .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                }
                let x = Vec4::new(f[0], f[1], f[2], f[3]);
                let y = Vec4::new(f[4], f[5], f[6], f[7]);
                let z = Vec4::new(f[8], f[9], f[10], f[11]);
                let w = Vec4::new(f[12], f[13], f[14], f[15]);
                Ok(Mat4::new(x, y, z, w))
            }
        }

        deserializer.deserialize_tuple_struct("Mat4", 16, Mat4Visitor)
    }
}

1	use crate::{Quat, Vec2, Vec3, Vec4, Mat2, Mat3, Mat4};
2
3	use serde::{
4	de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
5	ser::{Serialize, SerializeTupleStruct, Serializer},
6	};
7
8	use std::fmt;
9
10	impl Serialize for Vec2 {
11	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
12	where
13	S: Serializer,
14	{
15	let (x, y) = (*self).into();	×
16	let mut state = serializer.serialize_tuple_struct("Vec2", 2)?;	×
17	state.serialize_field(&x)?;	×
18	state.serialize_field(&y)?;	×
19	state.end()	×
20	}
21	}
22
23	#[cfg(feature = "serde")]
24	impl Serialize for Vec3 {
25	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
26	where
27	S: Serializer,
28	{
29	let (x, y, z) = (*self).into();	×
30	// 3 is the number of fields in the struct.
31	let mut state = serializer.serialize_tuple_struct("Vec3", 3)?;	×
32	state.serialize_field(&x)?;	×
33	state.serialize_field(&y)?;	×
34	state.serialize_field(&z)?;	×
35	state.end()	×
36	}
37	}
38
39	#[cfg(feature = "serde")]
40	impl Serialize for Vec4 {
41	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
42	where
43	S: Serializer,
44	{
45	let (x, y, z, w) = (*self).into();	×
46	// 4 is the number of fields in the struct.
47	let mut state = serializer.serialize_tuple_struct("Vec4", 4)?;	×
48	state.serialize_field(&x)?;	×
49	state.serialize_field(&y)?;	×
50	state.serialize_field(&z)?;	×
51	state.serialize_field(&w)?;	×
52	state.end()	×
53	}
54	}
55
56	#[cfg(feature = "serde")]
57	impl Serialize for Quat {
58	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
59	where
60	S: Serializer,
61	{
62	let (x, y, z, w) = (*self).into();	×
63	// 4 is the number of fields in the struct.
64	let mut state = serializer.serialize_tuple_struct("Quat", 4)?;	×
65	state.serialize_field(&x)?;	×
66	state.serialize_field(&y)?;	×
67	state.serialize_field(&z)?;	×
68	state.serialize_field(&w)?;	×
69	state.end()	×
70	}
71	}
72
73	#[cfg(feature = "serde")]
74	impl Serialize for Mat2 {
75	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
76	where
77	S: Serializer,
78	{
79	let f: &[f32; 4] = self.as_ref();	×
80	let mut state = serializer.serialize_tuple_struct("Mat2", 4)?;	×
81	state.serialize_field(&f[0])?;	×
82	state.serialize_field(&f[1])?;	×
83	state.serialize_field(&f[2])?;	×
84	state.serialize_field(&f[3])?;	×
85	state.end()	×
86	}
87	}
88
89	#[cfg(feature = "serde")]
90	impl Serialize for Mat3 {
91	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
92	where
93	S: Serializer,
94	{
95	let (m00, m01, m02) = self.x_axis.into();	×
96	let (m10, m11, m12) = self.y_axis.into();	×
97	let (m20, m21, m22) = self.z_axis.into();	×
98
99	let mut state = serializer.serialize_tuple_struct("Mat3", 9)?;	×
100	state.serialize_field(&m00)?;	×
101	state.serialize_field(&m01)?;	×
102	state.serialize_field(&m02)?;	×
103	state.serialize_field(&m10)?;	×
104	state.serialize_field(&m11)?;	×
105	state.serialize_field(&m12)?;	×
106	state.serialize_field(&m20)?;	×
107	state.serialize_field(&m21)?;	×
108	state.serialize_field(&m22)?;	×
109	state.end()	×
110	}
111	}
112
113	#[cfg(feature = "serde")]
114	impl Serialize for Mat4 {
115	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
116	where
117	S: Serializer,
118	{
119	let f: &[f32; 16] = self.as_ref();	×
120	let mut state = serializer.serialize_tuple_struct("Mat4", 16)?;	×
121	for i in 0..16 {	×
122	state.serialize_field(&f[i])?;
123	}
124	state.end()
125	}
126	}
127
128	impl<'de> Deserialize<'de> for Vec2 {
129	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
130	where
131	D: Deserializer<'de>,
132	{
133	struct Vec2Visitor;
134
135	// TODO: Not sure why this line is reported as uncovered
136	#[cfg_attr(tarpaulin, skip)]
137	impl<'de> Visitor<'de> for Vec2Visitor {
138	type Value = Vec2;
139
140	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
141	formatter.write_str("struct Vec2")
142	}
143
144	fn visit_seq<V>(self, mut seq: V) -> Result<Vec2, V::Error>
145	where
146	V: SeqAccess<'de>,
147	{
148	let x = seq
149	.next_element()?
150	.ok_or_else(\|\| de::Error::invalid_length(0, &self))?;
151	let y = seq
152	.next_element()?
153	.ok_or_else(\|\| de::Error::invalid_length(1, &self))?;
154	Ok(Vec2::new(x, y))
155	}
156	}
157
158	deserializer.deserialize_tuple_struct("Vec2", 2, Vec2Visitor)
159	}
160	}
161
162	impl<'de> Deserialize<'de> for Vec3 {
163	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
164	where
165	D: Deserializer<'de>,
166	{
167	struct Vec3Visitor;
168
169	// TODO: Not sure why this line is reported as uncovered
170	#[cfg_attr(tarpaulin, skip)]
171	impl<'de> Visitor<'de> for Vec3Visitor {
172	type Value = Vec3;
173
174	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
175	formatter.write_str("struct Vec2")
176	}
177
178	fn visit_seq<V>(self, mut seq: V) -> Result<Vec3, V::Error>
179	where
180	V: SeqAccess<'de>,
181	{
182	let x = seq
183	.next_element()?
184	.ok_or_else(\|\| de::Error::invalid_length(0, &self))?;
185	let y = seq
186	.next_element()?
187	.ok_or_else(\|\| de::Error::invalid_length(1, &self))?;
188	let z = seq
189	.next_element()?
190	.ok_or_else(\|\| de::Error::invalid_length(2, &self))?;
191	Ok(Vec3::new(x, y, z))
192	}
193	}
194
195	deserializer.deserialize_tuple_struct("Vec3", 3, Vec3Visitor)
196	}
197	}
198
199	impl<'de> Deserialize<'de> for Vec4 {
200	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
201	where
202	D: Deserializer<'de>,
203	{
204	struct Vec4Visitor;
205
206	// TODO: Not sure why this line is reported as uncovered
207	#[cfg_attr(tarpaulin, skip)]
208	impl<'de> Visitor<'de> for Vec4Visitor {
209	type Value = Vec4;
210
211	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
212	formatter.write_str("struct Vec2")
213	}
214
215	fn visit_seq<V>(self, mut seq: V) -> Result<Vec4, V::Error>
216	where
217	V: SeqAccess<'de>,
218	{
219	let x = seq
220	.next_element()?
221	.ok_or_else(\|\| de::Error::invalid_length(0, &self))?;
222	let y = seq
223	.next_element()?
224	.ok_or_else(\|\| de::Error::invalid_length(1, &self))?;
225	let z = seq
226	.next_element()?
227	.ok_or_else(\|\| de::Error::invalid_length(2, &self))?;
228	let w = seq
229	.next_element()?
230	.ok_or_else(\|\| de::Error::invalid_length(3, &self))?;
231	Ok(Vec4::new(x, y, z, w))
232	}
233	}
234
235	deserializer.deserialize_tuple_struct("Vec4", 4, Vec4Visitor)
236	}
237	}
238
239	impl<'de> Deserialize<'de> for Quat {
240	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
241	where
242	D: Deserializer<'de>,
243	{
244	struct QuatVisitor;
245
246	// TODO: Not sure why this line is reported as uncovered
247	#[cfg_attr(tarpaulin, skip)]
248	impl<'de> Visitor<'de> for QuatVisitor {
249	type Value = Quat;
250
251	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
252	formatter.write_str("struct Vec2")
253	}
254
255	fn visit_seq<V>(self, mut seq: V) -> Result<Quat, V::Error>
256	where
257	V: SeqAccess<'de>,
258	{
259	let x = seq
260	.next_element()?
261	.ok_or_else(\|\| de::Error::invalid_length(0, &self))?;
262	let y = seq
263	.next_element()?
264	.ok_or_else(\|\| de::Error::invalid_length(1, &self))?;
265	let z = seq
266	.next_element()?
267	.ok_or_else(\|\| de::Error::invalid_length(2, &self))?;
268	let w = seq
269	.next_element()?
270	.ok_or_else(\|\| de::Error::invalid_length(3, &self))?;
271	Ok(Quat::new(x, y, z, w))
272	}
273	}
274
275	deserializer.deserialize_tuple_struct("Quat", 4, QuatVisitor)
276	}
277	}
278
279	impl<'de> Deserialize<'de> for Mat2 {
280	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
281	where
282	D: Deserializer<'de>,
283	{
284	struct Mat2Visitor;
285
286	// TODO: Not sure why this line is reported as uncovered
287	#[cfg_attr(tarpaulin, skip)]
288	impl<'de> Visitor<'de> for Mat2Visitor {
289	type Value = Mat2;
290
291	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
292	formatter.write_str("struct Mat2")
293	}
294
295	fn visit_seq<V>(self, mut seq: V) -> Result<Mat2, V::Error>
296	where
297	V: SeqAccess<'de>,
298	{
299	let mut f = { [0.0; 4] };
300	for i in 0..4 {
301	f[i] = seq
302	.next_element()?
303	.ok_or_else(\|\| de::Error::invalid_length(i, &self))?;
304	}
305	let x = Vec2::new(f[0], f[1]);
306	let y = Vec2::new(f[2], f[3]);
307	Ok(Mat2::new(x, y))
308	}
309	}
310
311	deserializer.deserialize_tuple_struct("Mat2", 4, Mat2Visitor)
312	}
313	}
314
315	impl<'de> Deserialize<'de> for Mat3 {
316	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
317	where
318	D: Deserializer<'de>,
319	{
320	struct Mat3Visitor;
321
322	// TODO: Not sure why this line is reported as uncovered
323	#[cfg_attr(tarpaulin, skip)]
324	impl<'de> Visitor<'de> for Mat3Visitor {
325	type Value = Mat3;
326
327	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
328	formatter.write_str("struct Mat3")
329	}
330
331	fn visit_seq<V>(self, mut seq: V) -> Result<Mat3, V::Error>
332	where
333	V: SeqAccess<'de>,
334	{
335	let mut f = { [0.0; 9] };
336	for i in 0..9 {
337	f[i] = seq
338	.next_element()?
339	.ok_or_else(\|\| de::Error::invalid_length(i, &self))?;
340	}
341	let x = Vec3::new(f[0], f[1], f[2]);
342	let y = Vec3::new(f[3], f[4], f[5]);
343	let z = Vec3::new(f[6], f[7], f[8]);
344	Ok(Mat3::new(x, y, z))
345	}
346	}
347
348	deserializer.deserialize_tuple_struct("Mat3", 9, Mat3Visitor)
349	}
350	}
351
352	impl<'de> Deserialize<'de> for Mat4 {
353	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
354	where
355	D: Deserializer<'de>,
356	{
357	struct Mat4Visitor;
358
359	// TODO: Not sure why this line is reported as uncovered
360	#[cfg_attr(tarpaulin, skip)]
361	impl<'de> Visitor<'de> for Mat4Visitor {
362	type Value = Mat4;
363
364	fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
365	formatter.write_str("struct Mat4")
366	}
367
368	fn visit_seq<V>(self, mut seq: V) -> Result<Mat4, V::Error>
369	where
370	V: SeqAccess<'de>,
371	{
372	let mut f = { [0.0; 16] };
373	for i in 0..16 {
374	f[i] = seq
375	.next_element()?
376	.ok_or_else(\|\| de::Error::invalid_length(i, &self))?;
377	}
378	let x = Vec4::new(f[0], f[1], f[2], f[3]);
379	let y = Vec4::new(f[4], f[5], f[6], f[7]);
380	let z = Vec4::new(f[8], f[9], f[10], f[11]);
381	let w = Vec4::new(f[12], f[13], f[14], f[15]);
382	Ok(Mat4::new(x, y, z, w))
383	}
384	}
385
386	deserializer.deserialize_tuple_struct("Mat4", 16, Mat4Visitor)
387	}
388	}

bitshifter / glam-rs / 184

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous