16403168934

Committed 20 Jul 2025 06:55PM UTC coverage: 27.026% (-0.1%) from 27.144%

Build # 16403168934

Build Type

Pull #535

github

Committed by

web-flow

Commit Message

Merge bd65d8aee into 6869625f4

Pull Request Pull Request #535: feat(array): BTreeMap conversion

Run Details

0 of 20 new or added lines in 2 files covered. (0.0%)

100 existing lines in 3 files now uncovered.

1127 of 4170 relevant lines covered (27.03%)

5.64 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 super::super::ZendHashTable;
use crate::types::ArrayKey;
use crate::{
    boxed::ZBox,
    convert::{FromZval, IntoZval},
    error::{Error, Result},
    flags::DataType,
    types::Zval,
};
use std::hash::{Hash, RandomState};
use std::{collections::HashMap, convert::TryFrom};

impl<'a, K, V> TryFrom<&'a ZendHashTable> for HashMap<K, V, RandomState>
where
    K: TryFrom<ArrayKey<'a>, Error = Error> + Eq + Hash,
    V: FromZval<'a>,
{
    type Error = Error;

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

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

davidcole1340 / ext-php-rs / 16403168934

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