16392720284

Committed 19 Jul 2025 09:04PM UTC coverage: 24.784%. Remained the same

Build # 16392720284

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

79 of 299 new or added lines in 5 files covered. (26.42%)

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

0.0

/src/types/array/conversions/hash_map.rs

use std::{collections::HashMap, convert::TryFrom};

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

use super::super::ZendHashTable;

// TODO: Generalize hasher
#[allow(clippy::implicit_hasher)]
impl<'a, V> TryFrom<&'a ZendHashTable> for HashMap<String, V>
where
    V: FromZval<'a>,
{
    type Error = Error;

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

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

        Ok(hm)
    }
}

impl<K, V> TryFrom<HashMap<K, V>> for ZBox<ZendHashTable>
where
    K: AsRef<str>,
    V: IntoZval,
{
    type Error = Error;

    fn try_from(value: HashMap<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.as_ref(), v)?;
        }

        Ok(ht)
    }
}

// TODO: Generalize hasher
#[allow(clippy::implicit_hasher)]
impl<K, V> IntoZval for HashMap<K, V>
where
    K: AsRef<str>,
    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(())
    }
}

// TODO: Generalize hasher
#[allow(clippy::implicit_hasher)]
impl<'a, T> FromZval<'a> for HashMap<String, 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::{collections::HashMap, 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::ZendHashTable;
12
13	// TODO: Generalize hasher
14	#[allow(clippy::implicit_hasher)]
15	impl<'a, V> TryFrom<&'a ZendHashTable> for HashMap<String, V>
16	where
17	V: FromZval<'a>,
18	{
19	type Error = Error;
20
NEW 21	fn try_from(value: &'a ZendHashTable) -> Result<Self> {	×
NEW 22	let mut hm = HashMap::with_capacity(value.len());	×
23
NEW 24	for (key, val) in value {	×
NEW 25	hm.insert(	×
NEW 26	key.to_string(),	×
NEW 27	V::from_zval(val).ok_or_else(\|\| Error::ZvalConversion(val.get_type()))?,	×
28	);
29	}
30
NEW 31	Ok(hm)	×
32	}
33	}
34
35	impl<K, V> TryFrom<HashMap<K, V>> for ZBox<ZendHashTable>
36	where
37	K: AsRef<str>,
38	V: IntoZval,
39	{
40	type Error = Error;
41
NEW 42	fn try_from(value: HashMap<K, V>) -> Result<Self> {	×
43	let mut ht = ZendHashTable::with_capacity(
NEW 44	value.len().try_into().map_err(\|_\| Error::IntegerOverflow)?,	×
45	);
46
NEW 47	for (k, v) in value {	×
NEW 48	ht.insert(k.as_ref(), v)?;	×
49	}
50
NEW 51	Ok(ht)	×
52	}
53	}
54
55	// TODO: Generalize hasher
56	#[allow(clippy::implicit_hasher)]
57	impl<K, V> IntoZval for HashMap<K, V>
58	where
59	K: AsRef<str>,
60	V: IntoZval,
61	{
62	const TYPE: DataType = DataType::Array;
63	const NULLABLE: bool = false;
64
NEW 65	fn set_zval(self, zv: &mut Zval, _: bool) -> Result<()> {	×
NEW 66	let arr = self.try_into()?;	×
NEW 67	zv.set_hashtable(arr);	×
NEW 68	Ok(())	×
69	}
70	}
71
72	// TODO: Generalize hasher
73	#[allow(clippy::implicit_hasher)]
74	impl<'a, T> FromZval<'a> for HashMap<String, T>
75	where
76	T: FromZval<'a>,
77	{
78	const TYPE: DataType = DataType::Array;
79
NEW 80	fn from_zval(zval: &'a Zval) -> Option<Self> {	×
NEW 81	zval.array().and_then(\|arr\| arr.try_into().ok())	×
82	}
83	}

davidcole1340 / ext-php-rs / 16392720284

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