16392473053

Committed 19 Jul 2025 08:30PM UTC coverage: 24.784%. Remained the same

Build # 16392473053

Build Type

Pull #529

github

Committed by

ptondereau

Commit Message

refactor(array): split array.rs types into smaller files

Pull Request Pull Request #529: refactor(array): split array.rs types into smaller files

Run Details

56 of 170 new or added lines in 5 files covered. (32.94%)

976 of 3938 relevant lines covered (24.78%)

5.6 hits per line

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

58.14

/src/types/array/conversions/vec.rs

use std::convert::TryFrom;

use crate::{
    boxed::ZBox,
    convert::{FromZval, IntoZval},
    error::{Error, Result},
    flags::DataType,
    types::Zval,
};

use super::super::{ArrayKey, ZendHashTable};

///////////////////////////////////////////
// Vec<(K, V)> conversions
///////////////////////////////////////////

impl<'a, K, V> TryFrom<&'a ZendHashTable> for Vec<(K, V)>
where
    K: TryFrom<ArrayKey<'a>, Error = Error>,
    V: FromZval<'a>,
{
    type Error = Error;

    fn try_from(value: &'a ZendHashTable) -> Result<Self> {
        let mut vec = Vec::with_capacity(value.len());

        for (key, val) in value {
            vec.push((
                key.try_into()?,
                V::from_zval(val).ok_or_else(|| Error::ZvalConversion(val.get_type()))?,
            ));
        }

        Ok(vec)
    }
}

impl<'a, V> TryFrom<&'a ZendHashTable> for Vec<(ArrayKey<'a>, V)>
where
    V: FromZval<'a>,
{
    type Error = Error;

    fn try_from(value: &'a ZendHashTable) -> Result<Self> {
        let mut vec = Vec::with_capacity(value.len());

        for (key, val) in value {
            vec.push((
                key,
                V::from_zval(val).ok_or_else(|| Error::ZvalConversion(val.get_type()))?,
            ));
        }

        Ok(vec)
    }
}

impl<'a, K, V> TryFrom<Vec<(K, V)>> for ZBox<ZendHashTable>
where
    K: Into<ArrayKey<'a>>,
    V: IntoZval,
{
    type Error = Error;

    fn try_from(value: Vec<(K, V)>) -> Result<Self> {
        let mut ht = ZendHashTable::with_capacity(
            value.len().try_into().map_err(|_| Error::IntegerOverflow)?,
        );

        for (k, v) in value {
            ht.insert(k, v)?;
        }

        Ok(ht)
    }
}

impl<'a, K, V> IntoZval for Vec<(K, V)>
where
    K: Into<ArrayKey<'a>>,
    V: IntoZval,
{
    const TYPE: DataType = DataType::Array;
    const NULLABLE: bool = false;

    fn set_zval(self, zv: &mut Zval, _: bool) -> Result<()> {
        let arr = self.try_into()?;
        zv.set_hashtable(arr);
        Ok(())
    }
}

impl<'a, K, V> FromZval<'a> for Vec<(K, V)>
where
    K: TryFrom<ArrayKey<'a>, Error = Error>,
    V: FromZval<'a>,
{
    const TYPE: DataType = DataType::Array;

    fn from_zval(zval: &'a Zval) -> Option<Self> {
        zval.array().and_then(|arr| arr.try_into().ok())
    }
}

impl<'a, V> FromZval<'a> for Vec<(ArrayKey<'a>, V)>
where
    V: FromZval<'a>,
{
    const TYPE: DataType = DataType::Array;

    fn from_zval(zval: &'a Zval) -> Option<Self> {
        zval.array().and_then(|arr| arr.try_into().ok())
    }
}

///////////////////////////////////////////
// Vec<T> conversions
///////////////////////////////////////////

impl<'a, T> TryFrom<&'a ZendHashTable> for Vec<T>
where
    T: FromZval<'a>,
{
    type Error = Error;

    fn try_from(value: &'a ZendHashTable) -> Result<Self> {
        let mut vec = Vec::with_capacity(value.len());

        for (_, val) in value {
            vec.push(T::from_zval(val).ok_or_else(|| Error::ZvalConversion(val.get_type()))?);
        }

        Ok(vec)
    }
}

impl<T> TryFrom<Vec<T>> for ZBox<ZendHashTable>
where
    T: IntoZval,
{
    type Error = Error;

    fn try_from(value: Vec<T>) -> Result<Self> {
        let mut ht = ZendHashTable::with_capacity(
            value.len().try_into().map_err(|_| Error::IntegerOverflow)?,
        );

        for val in value {
            ht.push(val)?;
        }

        Ok(ht)
    }
}

impl<T> IntoZval for Vec<T>
where
    T: IntoZval,
{
    const TYPE: DataType = DataType::Array;
    const NULLABLE: bool = false;

    fn set_zval(self, zv: &mut Zval, _: bool) -> Result<()> {
        let arr = self.try_into()?;
        zv.set_hashtable(arr);
        Ok(())
    }
}

impl<'a, T> FromZval<'a> for Vec<T>
where
    T: FromZval<'a>,
{
    const TYPE: DataType = DataType::Array;

    fn from_zval(zval: &'a Zval) -> Option<Self> {
        zval.array().and_then(|arr| arr.try_into().ok())
    }
}

1	use std::convert::TryFrom;
2
3	use crate::{
4	boxed::ZBox,
5	convert::{FromZval, IntoZval},
6	error::{Error, Result},
7	flags::DataType,
8	types::Zval,
9	};
10
11	use super::super::{ArrayKey, ZendHashTable};
12
13	///////////////////////////////////////////
14	// Vec<(K, V)> conversions
15	///////////////////////////////////////////
16
17	impl<'a, K, V> TryFrom<&'a ZendHashTable> for Vec<(K, V)>
18	where
19	K: TryFrom<ArrayKey<'a>, Error = Error>,
20	V: FromZval<'a>,
21	{
22	type Error = Error;
23
24	fn try_from(value: &'a ZendHashTable) -> Result<Self> {	7✔
25	let mut vec = Vec::with_capacity(value.len());	28✔
26
27	for (key, val) in value {	46✔
28	vec.push((	25✔
29	key.try_into()?,	31✔
30	V::from_zval(val).ok_or_else(\|\| Error::ZvalConversion(val.get_type()))?,	11✔
31	));
32	}
33
34	Ok(vec)	4✔
35	}
36	}
37
38	impl<'a, V> TryFrom<&'a ZendHashTable> for Vec<(ArrayKey<'a>, V)>
39	where
40	V: FromZval<'a>,
41	{
42	type Error = Error;
43
44	fn try_from(value: &'a ZendHashTable) -> Result<Self> {	2✔
45	let mut vec = Vec::with_capacity(value.len());	8✔
46
47	for (key, val) in value {	20✔
48	vec.push((	12✔
49	key,	6✔
50	V::from_zval(val).ok_or_else(\|\| Error::ZvalConversion(val.get_type()))?,	18✔
51	));
52	}
53
54	Ok(vec)	2✔
55	}
56	}
57
58	impl<'a, K, V> TryFrom<Vec<(K, V)>> for ZBox<ZendHashTable>
59	where
60	K: Into<ArrayKey<'a>>,
61	V: IntoZval,
62	{
63	type Error = Error;
64
65	fn try_from(value: Vec<(K, V)>) -> Result<Self> {	4✔
66	let mut ht = ZendHashTable::with_capacity(
67	value.len().try_into().map_err(\|_\| Error::IntegerOverflow)?,	16✔
68	);
69
70	for (k, v) in value {	40✔
71	ht.insert(k, v)?;	36✔
72	}
73
74	Ok(ht)	4✔
75	}
76	}
77
78	impl<'a, K, V> IntoZval for Vec<(K, V)>
79	where
80	K: Into<ArrayKey<'a>>,
81	V: IntoZval,
82	{
83	const TYPE: DataType = DataType::Array;
84	const NULLABLE: bool = false;
85
86	fn set_zval(self, zv: &mut Zval, _: bool) -> Result<()> {	2✔
87	let arr = self.try_into()?;	6✔
NEW 88	zv.set_hashtable(arr);	×
NEW 89	Ok(())	×
90	}
91	}
92
93	impl<'a, K, V> FromZval<'a> for Vec<(K, V)>
94	where
95	K: TryFrom<ArrayKey<'a>, Error = Error>,
96	V: FromZval<'a>,
97	{
98	const TYPE: DataType = DataType::Array;
99
100	fn from_zval(zval: &'a Zval) -> Option<Self> {	3✔
101	zval.array().and_then(\|arr\| arr.try_into().ok())	18✔
102	}
103	}
104
105	impl<'a, V> FromZval<'a> for Vec<(ArrayKey<'a>, V)>
106	where
107	V: FromZval<'a>,
108	{
109	const TYPE: DataType = DataType::Array;
110
111	fn from_zval(zval: &'a Zval) -> Option<Self> {	1✔
112	zval.array().and_then(\|arr\| arr.try_into().ok())	6✔
113	}
114	}
115
116	///////////////////////////////////////////
117	// Vec<T> conversions
118	///////////////////////////////////////////
119
120	impl<'a, T> TryFrom<&'a ZendHashTable> for Vec<T>
121	where
122	T: FromZval<'a>,
123	{
124	type Error = Error;
125
NEW 126	fn try_from(value: &'a ZendHashTable) -> Result<Self> {	×
NEW 127	let mut vec = Vec::with_capacity(value.len());	×
128
NEW 129	for (_, val) in value {	×
NEW 130	vec.push(T::from_zval(val).ok_or_else(\|\| Error::ZvalConversion(val.get_type()))?);	×
131	}
132
NEW 133	Ok(vec)	×
134	}
135	}
136
137	impl<T> TryFrom<Vec<T>> for ZBox<ZendHashTable>
138	where
139	T: IntoZval,
140	{
141	type Error = Error;
142
NEW 143	fn try_from(value: Vec<T>) -> Result<Self> {	×
144	let mut ht = ZendHashTable::with_capacity(
NEW 145	value.len().try_into().map_err(\|_\| Error::IntegerOverflow)?,	×
146	);
147
NEW 148	for val in value {	×
NEW 149	ht.push(val)?;	×
150	}
151
NEW 152	Ok(ht)	×
153	}
154	}
155
156	impl<T> IntoZval for Vec<T>
157	where
158	T: IntoZval,
159	{
160	const TYPE: DataType = DataType::Array;
161	const NULLABLE: bool = false;
162
NEW 163	fn set_zval(self, zv: &mut Zval, _: bool) -> Result<()> {	×
NEW 164	let arr = self.try_into()?;	×
NEW 165	zv.set_hashtable(arr);	×
NEW 166	Ok(())	×
167	}
168	}
169
170	impl<'a, T> FromZval<'a> for Vec<T>
171	where
172	T: FromZval<'a>,
173	{
174	const TYPE: DataType = DataType::Array;
175
NEW 176	fn from_zval(zval: &'a Zval) -> Option<Self> {	×
NEW 177	zval.array().and_then(\|arr\| arr.try_into().ok())	×
178	}
179	}

davidcole1340 / ext-php-rs / 16392473053

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