6815798908

Committed 09 Nov 2023 05:17PM UTC coverage: 72.607% (-2.4%) from 75.01%

Build # 6815798908

Build Type

push

github

Committed by

web-flow

Commit Message

Implement `Any/BufferProvider` for some smart pointers (#4255)

Allows storing them as a `Box<dyn Any/BufferProvider>` without using a
wrapper type that implements the trait.

Run Details

44281 of 60987 relevant lines covered (72.61%)

201375.86 hits per line

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

61.54

/components/datetime/src/skeleton/serde.rs

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use alloc::format;
use core::convert::TryFrom;
use smallvec::SmallVec;

pub mod reference {
    use super::*;
    use crate::skeleton::reference::Skeleton;

    #[cfg(feature = "datagen")]
    use ::serde::{ser, Serialize};
    use serde::{de, Deserialize, Deserializer};
    /// This is an implementation of the serde deserialization visitor pattern.
    #[allow(clippy::upper_case_acronyms)]
    pub(super) struct DeserializeSkeletonUTS35String;

    impl<'de> de::Visitor<'de> for DeserializeSkeletonUTS35String {
        type Value = Skeleton;

        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(formatter, "Expected to find a valid skeleton.")
        }

        /// A [`Skeleton`] serialized into a string follows UTS-35.
        /// https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
        /// This string consists of a symbol that is repeated N times. This string is
        /// deserialized here into the Skeleton format which is used in memory
        /// when working with formatting datetimes.
        fn visit_str<E>(self, skeleton_string: &str) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            Skeleton::try_from(skeleton_string).map_err(|err| {
                de::Error::invalid_value(
                    de::Unexpected::Other(&format!("{skeleton_string:?} {err}")),
                    &"field symbols representing a skeleton",
                )
            })
        }
    }

    impl<'de> Deserialize<'de> for Skeleton {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            if deserializer.is_human_readable() {
                deserializer.deserialize_str(DeserializeSkeletonUTS35String)
            } else {
                let sv = SmallVec::deserialize(deserializer)?;
                Ok(sv.into())
            }
        }
    }

    #[cfg(feature = "datagen")]
    impl Serialize for Skeleton {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: ser::Serializer,
        {
            if serializer.is_human_readable() {
                // Serialize into the UTS 35 string representation.
                let string = self.to_string();
                serializer.serialize_str(&string)
            } else {
                self.0.serialize(serializer)
            }
        }
    }
}

pub mod runtime {
    use crate::skeleton::runtime::Skeleton;
    use zerovec::ZeroVec;

    #[cfg(feature = "datagen")]
    use ::serde::{ser, Serialize};
    use serde::{de, Deserialize, Deserializer};
    /// This is an implementation of the serde deserialization visitor pattern.
    #[allow(clippy::upper_case_acronyms)]
    struct DeserializeSkeletonUTS35String;

    impl<'de> de::Visitor<'de> for DeserializeSkeletonUTS35String {
        type Value = Skeleton<'de>;

        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(formatter, "Expected to find a valid skeleton.")
        }

        fn visit_borrowed_str<E>(self, skeleton_string: &'de str) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            let reference_deserializer = super::reference::DeserializeSkeletonUTS35String;
            let skeleton = reference_deserializer.visit_str(skeleton_string)?;

            Ok(skeleton.into())
        }
    }

    impl<'de> Deserialize<'de> for Skeleton<'de> {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            if deserializer.is_human_readable() {
                deserializer.deserialize_str(DeserializeSkeletonUTS35String)
            } else {
                let zv = ZeroVec::deserialize(deserializer)?;
                Ok(zv.into())
            }
        }
    }

    #[cfg(feature = "datagen")]
    impl Serialize for Skeleton<'_> {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: ser::Serializer,
        {
            if serializer.is_human_readable() {
                // Serialize into the UTS 35 string representation.
                let string = self.to_string();
                serializer.serialize_str(&string)
            } else {
                self.0.serialize(serializer)
            }
        }
    }
}

1	// This file is part of ICU4X. For terms of use, please see the file
2	// called LICENSE at the top level of the ICU4X source tree
3	// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5	use alloc::format;
6	use core::convert::TryFrom;
7	use smallvec::SmallVec;
8
9	pub mod reference {
10	use super::*;
11	use crate::skeleton::reference::Skeleton;
12
13	#[cfg(feature = "datagen")]
14	use ::serde::{ser, Serialize};
15	use serde::{de, Deserialize, Deserializer};
16	/// This is an implementation of the serde deserialization visitor pattern.
17	#[allow(clippy::upper_case_acronyms)]
18	pub(super) struct DeserializeSkeletonUTS35String;
19
20	impl<'de> de::Visitor<'de> for DeserializeSkeletonUTS35String {
21	type Value = Skeleton;
22
23	fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {	×
24	write!(formatter, "Expected to find a valid skeleton.")	×
25	}	×
26
27	/// A [`Skeleton`] serialized into a string follows UTS-35.
28	/// https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
29	/// This string consists of a symbol that is repeated N times. This string is
30	/// deserialized here into the Skeleton format which is used in memory
31	/// when working with formatting datetimes.
32	fn visit_str<E>(self, skeleton_string: &str) -> Result<Self::Value, E>	2✔
33	where
34	E: de::Error,
35	{
36	Skeleton::try_from(skeleton_string).map_err(\|err\| {	3✔
37	de::Error::invalid_value(	1✔
38	de::Unexpected::Other(&format!("{skeleton_string:?} {err}")),	1✔
39	&"field symbols representing a skeleton",
40	)
41	})	1✔
42	}	2✔
43	}
44
45	impl<'de> Deserialize<'de> for Skeleton {
46	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>	2✔
47	where
48	D: Deserializer<'de>,
49	{
50	if deserializer.is_human_readable() {	2✔
51	deserializer.deserialize_str(DeserializeSkeletonUTS35String)	2✔
52	} else {
53	let sv = SmallVec::deserialize(deserializer)?;	×
54	Ok(sv.into())	×
55	}	×
56	}	2✔
57	}
58
59	#[cfg(feature = "datagen")]
60	impl Serialize for Skeleton {
61	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>	20✔
62	where
63	S: ser::Serializer,
64	{
65	if serializer.is_human_readable() {	20✔
66	// Serialize into the UTS 35 string representation.
67	let string = self.to_string();	20✔
68	serializer.serialize_str(&string)	20✔
69	} else {	20✔
70	self.0.serialize(serializer)	×
71	}
72	}	20✔
73	}
74	}
75
76	pub mod runtime {
77	use crate::skeleton::runtime::Skeleton;
78	use zerovec::ZeroVec;
79
80	#[cfg(feature = "datagen")]
81	use ::serde::{ser, Serialize};
82	use serde::{de, Deserialize, Deserializer};
83	/// This is an implementation of the serde deserialization visitor pattern.
84	#[allow(clippy::upper_case_acronyms)]
85	struct DeserializeSkeletonUTS35String;
86
87	impl<'de> de::Visitor<'de> for DeserializeSkeletonUTS35String {
88	type Value = Skeleton<'de>;
89
90	fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {	×
91	write!(formatter, "Expected to find a valid skeleton.")	×
92	}	×
93
94	fn visit_borrowed_str<E>(self, skeleton_string: &'de str) -> Result<Self::Value, E>
95	where
96	E: de::Error,
97	{
98	let reference_deserializer = super::reference::DeserializeSkeletonUTS35String;
99	let skeleton = reference_deserializer.visit_str(skeleton_string)?;
100
101	Ok(skeleton.into())
102	}
103	}
104
105	impl<'de> Deserialize<'de> for Skeleton<'de> {
106	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
107	where
108	D: Deserializer<'de>,
109	{
110	if deserializer.is_human_readable() {
111	deserializer.deserialize_str(DeserializeSkeletonUTS35String)
112	} else {
113	let zv = ZeroVec::deserialize(deserializer)?;
114	Ok(zv.into())
115	}
116	}
117	}
118
119	#[cfg(feature = "datagen")]
120	impl Serialize for Skeleton<'_> {
121	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
122	where
123	S: ser::Serializer,
124	{
125	if serializer.is_human_readable() {
126	// Serialize into the UTS 35 string representation.
127	let string = self.to_string();
128	serializer.serialize_str(&string)
129	} else {
130	self.0.serialize(serializer)
131	}
132	}
133	}
134	}

zbraniecki / icu4x / 6815798908

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