schema_org_types/schemas/classes/
quantitative_value_distribution.rs

1use super::*;
2/// <https://schema.org/QuantitativeValueDistribution>
3#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct QuantitativeValueDistribution {
6	/// <https://schema.org/duration>
7	pub r#duration: Vec<DurationProperty>,
8	/// <https://schema.org/median>
9	pub r#median: Vec<MedianProperty>,
10	/// <https://schema.org/percentile10>
11	pub r#percentile_10: Vec<Percentile10Property>,
12	/// <https://schema.org/percentile25>
13	pub r#percentile_25: Vec<Percentile25Property>,
14	/// <https://schema.org/percentile75>
15	pub r#percentile_75: Vec<Percentile75Property>,
16	/// <https://schema.org/percentile90>
17	pub r#percentile_90: Vec<Percentile90Property>,
18	/// <https://schema.org/additionalType>
19	pub r#additional_type: Vec<AdditionalTypeProperty>,
20	/// <https://schema.org/alternateName>
21	pub r#alternate_name: Vec<AlternateNameProperty>,
22	/// <https://schema.org/description>
23	pub r#description: Vec<DescriptionProperty>,
24	/// <https://schema.org/disambiguatingDescription>
25	pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
26	/// <https://schema.org/identifier>
27	pub r#identifier: Vec<IdentifierProperty>,
28	/// <https://schema.org/image>
29	pub r#image: Vec<ImageProperty>,
30	/// <https://schema.org/mainEntityOfPage>
31	pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
32	/// <https://schema.org/name>
33	pub r#name: Vec<NameProperty>,
34	/// <https://schema.org/potentialAction>
35	pub r#potential_action: Vec<PotentialActionProperty>,
36	/// <https://schema.org/sameAs>
37	pub r#same_as: Vec<SameAsProperty>,
38	/// <https://schema.org/subjectOf>
39	pub r#subject_of: Vec<SubjectOfProperty>,
40	/// <https://schema.org/url>
41	pub r#url: Vec<UrlProperty>,
42}
43/// This trait is for properties from <https://schema.org/QuantitativeValueDistribution>.
44pub trait QuantitativeValueDistributionTrait {
45	/// Get <https://schema.org/duration> from [`Self`] as borrowed slice.
46	fn get_duration(&self) -> &[DurationProperty];
47	/// Take <https://schema.org/duration> from [`Self`] as owned vector.
48	fn take_duration(&mut self) -> Vec<DurationProperty>;
49	/// Get <https://schema.org/median> from [`Self`] as borrowed slice.
50	fn get_median(&self) -> &[MedianProperty];
51	/// Take <https://schema.org/median> from [`Self`] as owned vector.
52	fn take_median(&mut self) -> Vec<MedianProperty>;
53	/// Get <https://schema.org/percentile10> from [`Self`] as borrowed slice.
54	fn get_percentile_10(&self) -> &[Percentile10Property];
55	/// Take <https://schema.org/percentile10> from [`Self`] as owned vector.
56	fn take_percentile_10(&mut self) -> Vec<Percentile10Property>;
57	/// Get <https://schema.org/percentile25> from [`Self`] as borrowed slice.
58	fn get_percentile_25(&self) -> &[Percentile25Property];
59	/// Take <https://schema.org/percentile25> from [`Self`] as owned vector.
60	fn take_percentile_25(&mut self) -> Vec<Percentile25Property>;
61	/// Get <https://schema.org/percentile75> from [`Self`] as borrowed slice.
62	fn get_percentile_75(&self) -> &[Percentile75Property];
63	/// Take <https://schema.org/percentile75> from [`Self`] as owned vector.
64	fn take_percentile_75(&mut self) -> Vec<Percentile75Property>;
65	/// Get <https://schema.org/percentile90> from [`Self`] as borrowed slice.
66	fn get_percentile_90(&self) -> &[Percentile90Property];
67	/// Take <https://schema.org/percentile90> from [`Self`] as owned vector.
68	fn take_percentile_90(&mut self) -> Vec<Percentile90Property>;
69}
70impl QuantitativeValueDistributionTrait for QuantitativeValueDistribution {
71	fn get_duration(&self) -> &[DurationProperty] {
72		self.r#duration.as_slice()
73	}
74	fn take_duration(&mut self) -> Vec<DurationProperty> {
75		std::mem::take(&mut self.r#duration)
76	}
77	fn get_median(&self) -> &[MedianProperty] {
78		self.r#median.as_slice()
79	}
80	fn take_median(&mut self) -> Vec<MedianProperty> {
81		std::mem::take(&mut self.r#median)
82	}
83	fn get_percentile_10(&self) -> &[Percentile10Property] {
84		self.r#percentile_10.as_slice()
85	}
86	fn take_percentile_10(&mut self) -> Vec<Percentile10Property> {
87		std::mem::take(&mut self.r#percentile_10)
88	}
89	fn get_percentile_25(&self) -> &[Percentile25Property] {
90		self.r#percentile_25.as_slice()
91	}
92	fn take_percentile_25(&mut self) -> Vec<Percentile25Property> {
93		std::mem::take(&mut self.r#percentile_25)
94	}
95	fn get_percentile_75(&self) -> &[Percentile75Property] {
96		self.r#percentile_75.as_slice()
97	}
98	fn take_percentile_75(&mut self) -> Vec<Percentile75Property> {
99		std::mem::take(&mut self.r#percentile_75)
100	}
101	fn get_percentile_90(&self) -> &[Percentile90Property] {
102		self.r#percentile_90.as_slice()
103	}
104	fn take_percentile_90(&mut self) -> Vec<Percentile90Property> {
105		std::mem::take(&mut self.r#percentile_90)
106	}
107}
108impl StructuredValueTrait for QuantitativeValueDistribution {}
109impl ThingTrait for QuantitativeValueDistribution {
110	fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
111		self.r#additional_type.as_slice()
112	}
113	fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
114		std::mem::take(&mut self.r#additional_type)
115	}
116	fn get_alternate_name(&self) -> &[AlternateNameProperty] {
117		self.r#alternate_name.as_slice()
118	}
119	fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
120		std::mem::take(&mut self.r#alternate_name)
121	}
122	fn get_description(&self) -> &[DescriptionProperty] {
123		self.r#description.as_slice()
124	}
125	fn take_description(&mut self) -> Vec<DescriptionProperty> {
126		std::mem::take(&mut self.r#description)
127	}
128	fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
129		self.r#disambiguating_description.as_slice()
130	}
131	fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
132		std::mem::take(&mut self.r#disambiguating_description)
133	}
134	fn get_identifier(&self) -> &[IdentifierProperty] {
135		self.r#identifier.as_slice()
136	}
137	fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
138		std::mem::take(&mut self.r#identifier)
139	}
140	fn get_image(&self) -> &[ImageProperty] {
141		self.r#image.as_slice()
142	}
143	fn take_image(&mut self) -> Vec<ImageProperty> {
144		std::mem::take(&mut self.r#image)
145	}
146	fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
147		self.r#main_entity_of_page.as_slice()
148	}
149	fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
150		std::mem::take(&mut self.r#main_entity_of_page)
151	}
152	fn get_name(&self) -> &[NameProperty] {
153		self.r#name.as_slice()
154	}
155	fn take_name(&mut self) -> Vec<NameProperty> {
156		std::mem::take(&mut self.r#name)
157	}
158	fn get_potential_action(&self) -> &[PotentialActionProperty] {
159		self.r#potential_action.as_slice()
160	}
161	fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
162		std::mem::take(&mut self.r#potential_action)
163	}
164	fn get_same_as(&self) -> &[SameAsProperty] {
165		self.r#same_as.as_slice()
166	}
167	fn take_same_as(&mut self) -> Vec<SameAsProperty> {
168		std::mem::take(&mut self.r#same_as)
169	}
170	fn get_subject_of(&self) -> &[SubjectOfProperty] {
171		self.r#subject_of.as_slice()
172	}
173	fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
174		std::mem::take(&mut self.r#subject_of)
175	}
176	fn get_url(&self) -> &[UrlProperty] {
177		self.r#url.as_slice()
178	}
179	fn take_url(&mut self) -> Vec<UrlProperty> {
180		std::mem::take(&mut self.r#url)
181	}
182}
183#[cfg(feature = "serde")]
184mod serde {
185	use std::{fmt, fmt::Formatter};
186
187	use ::serde::{
188		de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
189	};
190
191	use super::*;
192	impl Serialize for QuantitativeValueDistribution {
193		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
194		where
195			S: Serializer,
196		{
197			let len: usize = [
198				!Vec::is_empty(&self.r#duration) as usize,
199				!Vec::is_empty(&self.r#median) as usize,
200				!Vec::is_empty(&self.r#percentile_10) as usize,
201				!Vec::is_empty(&self.r#percentile_25) as usize,
202				!Vec::is_empty(&self.r#percentile_75) as usize,
203				!Vec::is_empty(&self.r#percentile_90) as usize,
204				!Vec::is_empty(&self.r#additional_type) as usize,
205				!Vec::is_empty(&self.r#alternate_name) as usize,
206				!Vec::is_empty(&self.r#description) as usize,
207				!Vec::is_empty(&self.r#disambiguating_description) as usize,
208				!Vec::is_empty(&self.r#identifier) as usize,
209				!Vec::is_empty(&self.r#image) as usize,
210				!Vec::is_empty(&self.r#main_entity_of_page) as usize,
211				!Vec::is_empty(&self.r#name) as usize,
212				!Vec::is_empty(&self.r#potential_action) as usize,
213				!Vec::is_empty(&self.r#same_as) as usize,
214				!Vec::is_empty(&self.r#subject_of) as usize,
215				!Vec::is_empty(&self.r#url) as usize,
216			]
217			.iter()
218			.sum();
219			let mut serialize_struct =
220				Serializer::serialize_struct(serializer, "QuantitativeValueDistribution", len)?;
221			if !Vec::is_empty(&self.r#duration) {
222				serialize_struct.serialize_field("duration", {
223					struct SerializeWith<'a>(&'a Vec<DurationProperty>);
224					impl<'a> Serialize for SerializeWith<'a> {
225						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
226						where
227							S: Serializer,
228						{
229							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
230								self.0, serializer,
231							)
232						}
233					}
234					&SerializeWith(&self.r#duration)
235				})?;
236			} else {
237				serialize_struct.skip_field("duration")?;
238			}
239			if !Vec::is_empty(&self.r#median) {
240				serialize_struct.serialize_field("median", {
241					struct SerializeWith<'a>(&'a Vec<MedianProperty>);
242					impl<'a> Serialize for SerializeWith<'a> {
243						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
244						where
245							S: Serializer,
246						{
247							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
248								self.0, serializer,
249							)
250						}
251					}
252					&SerializeWith(&self.r#median)
253				})?;
254			} else {
255				serialize_struct.skip_field("median")?;
256			}
257			if !Vec::is_empty(&self.r#percentile_10) {
258				serialize_struct.serialize_field("percentile10", {
259					struct SerializeWith<'a>(&'a Vec<Percentile10Property>);
260					impl<'a> Serialize for SerializeWith<'a> {
261						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
262						where
263							S: Serializer,
264						{
265							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
266								self.0, serializer,
267							)
268						}
269					}
270					&SerializeWith(&self.r#percentile_10)
271				})?;
272			} else {
273				serialize_struct.skip_field("percentile10")?;
274			}
275			if !Vec::is_empty(&self.r#percentile_25) {
276				serialize_struct.serialize_field("percentile25", {
277					struct SerializeWith<'a>(&'a Vec<Percentile25Property>);
278					impl<'a> Serialize for SerializeWith<'a> {
279						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
280						where
281							S: Serializer,
282						{
283							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
284								self.0, serializer,
285							)
286						}
287					}
288					&SerializeWith(&self.r#percentile_25)
289				})?;
290			} else {
291				serialize_struct.skip_field("percentile25")?;
292			}
293			if !Vec::is_empty(&self.r#percentile_75) {
294				serialize_struct.serialize_field("percentile75", {
295					struct SerializeWith<'a>(&'a Vec<Percentile75Property>);
296					impl<'a> Serialize for SerializeWith<'a> {
297						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
298						where
299							S: Serializer,
300						{
301							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
302								self.0, serializer,
303							)
304						}
305					}
306					&SerializeWith(&self.r#percentile_75)
307				})?;
308			} else {
309				serialize_struct.skip_field("percentile75")?;
310			}
311			if !Vec::is_empty(&self.r#percentile_90) {
312				serialize_struct.serialize_field("percentile90", {
313					struct SerializeWith<'a>(&'a Vec<Percentile90Property>);
314					impl<'a> Serialize for SerializeWith<'a> {
315						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
316						where
317							S: Serializer,
318						{
319							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
320								self.0, serializer,
321							)
322						}
323					}
324					&SerializeWith(&self.r#percentile_90)
325				})?;
326			} else {
327				serialize_struct.skip_field("percentile90")?;
328			}
329			if !Vec::is_empty(&self.r#additional_type) {
330				serialize_struct.serialize_field("additionalType", {
331					struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
332					impl<'a> Serialize for SerializeWith<'a> {
333						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
334						where
335							S: Serializer,
336						{
337							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
338								self.0, serializer,
339							)
340						}
341					}
342					&SerializeWith(&self.r#additional_type)
343				})?;
344			} else {
345				serialize_struct.skip_field("additionalType")?;
346			}
347			if !Vec::is_empty(&self.r#alternate_name) {
348				serialize_struct.serialize_field("alternateName", {
349					struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
350					impl<'a> Serialize for SerializeWith<'a> {
351						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
352						where
353							S: Serializer,
354						{
355							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
356								self.0, serializer,
357							)
358						}
359					}
360					&SerializeWith(&self.r#alternate_name)
361				})?;
362			} else {
363				serialize_struct.skip_field("alternateName")?;
364			}
365			if !Vec::is_empty(&self.r#description) {
366				serialize_struct.serialize_field("description", {
367					struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
368					impl<'a> Serialize for SerializeWith<'a> {
369						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
370						where
371							S: Serializer,
372						{
373							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
374								self.0, serializer,
375							)
376						}
377					}
378					&SerializeWith(&self.r#description)
379				})?;
380			} else {
381				serialize_struct.skip_field("description")?;
382			}
383			if !Vec::is_empty(&self.r#disambiguating_description) {
384				serialize_struct.serialize_field("disambiguatingDescription", {
385					struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
386					impl<'a> Serialize for SerializeWith<'a> {
387						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
388						where
389							S: Serializer,
390						{
391							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
392								self.0, serializer,
393							)
394						}
395					}
396					&SerializeWith(&self.r#disambiguating_description)
397				})?;
398			} else {
399				serialize_struct.skip_field("disambiguatingDescription")?;
400			}
401			if !Vec::is_empty(&self.r#identifier) {
402				serialize_struct.serialize_field("identifier", {
403					struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
404					impl<'a> Serialize for SerializeWith<'a> {
405						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
406						where
407							S: Serializer,
408						{
409							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
410								self.0, serializer,
411							)
412						}
413					}
414					&SerializeWith(&self.r#identifier)
415				})?;
416			} else {
417				serialize_struct.skip_field("identifier")?;
418			}
419			if !Vec::is_empty(&self.r#image) {
420				serialize_struct.serialize_field("image", {
421					struct SerializeWith<'a>(&'a Vec<ImageProperty>);
422					impl<'a> Serialize for SerializeWith<'a> {
423						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
424						where
425							S: Serializer,
426						{
427							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
428								self.0, serializer,
429							)
430						}
431					}
432					&SerializeWith(&self.r#image)
433				})?;
434			} else {
435				serialize_struct.skip_field("image")?;
436			}
437			if !Vec::is_empty(&self.r#main_entity_of_page) {
438				serialize_struct.serialize_field("mainEntityOfPage", {
439					struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
440					impl<'a> Serialize for SerializeWith<'a> {
441						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
442						where
443							S: Serializer,
444						{
445							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
446								self.0, serializer,
447							)
448						}
449					}
450					&SerializeWith(&self.r#main_entity_of_page)
451				})?;
452			} else {
453				serialize_struct.skip_field("mainEntityOfPage")?;
454			}
455			if !Vec::is_empty(&self.r#name) {
456				serialize_struct.serialize_field("name", {
457					struct SerializeWith<'a>(&'a Vec<NameProperty>);
458					impl<'a> Serialize for SerializeWith<'a> {
459						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
460						where
461							S: Serializer,
462						{
463							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
464								self.0, serializer,
465							)
466						}
467					}
468					&SerializeWith(&self.r#name)
469				})?;
470			} else {
471				serialize_struct.skip_field("name")?;
472			}
473			if !Vec::is_empty(&self.r#potential_action) {
474				serialize_struct.serialize_field("potentialAction", {
475					struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
476					impl<'a> Serialize for SerializeWith<'a> {
477						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
478						where
479							S: Serializer,
480						{
481							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
482								self.0, serializer,
483							)
484						}
485					}
486					&SerializeWith(&self.r#potential_action)
487				})?;
488			} else {
489				serialize_struct.skip_field("potentialAction")?;
490			}
491			if !Vec::is_empty(&self.r#same_as) {
492				serialize_struct.serialize_field("sameAs", {
493					struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
494					impl<'a> Serialize for SerializeWith<'a> {
495						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
496						where
497							S: Serializer,
498						{
499							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
500								self.0, serializer,
501							)
502						}
503					}
504					&SerializeWith(&self.r#same_as)
505				})?;
506			} else {
507				serialize_struct.skip_field("sameAs")?;
508			}
509			if !Vec::is_empty(&self.r#subject_of) {
510				serialize_struct.serialize_field("subjectOf", {
511					struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
512					impl<'a> Serialize for SerializeWith<'a> {
513						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
514						where
515							S: Serializer,
516						{
517							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
518								self.0, serializer,
519							)
520						}
521					}
522					&SerializeWith(&self.r#subject_of)
523				})?;
524			} else {
525				serialize_struct.skip_field("subjectOf")?;
526			}
527			if !Vec::is_empty(&self.r#url) {
528				serialize_struct.serialize_field("url", {
529					struct SerializeWith<'a>(&'a Vec<UrlProperty>);
530					impl<'a> Serialize for SerializeWith<'a> {
531						fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
532						where
533							S: Serializer,
534						{
535							serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
536								self.0, serializer,
537							)
538						}
539					}
540					&SerializeWith(&self.r#url)
541				})?;
542			} else {
543				serialize_struct.skip_field("url")?;
544			}
545			serialize_struct.end()
546		}
547	}
548	impl<'de> Deserialize<'de> for QuantitativeValueDistribution {
549		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
550		where
551			D: Deserializer<'de>,
552		{
553			enum Field {
554				Duration,
555				Median,
556				Percentile10,
557				Percentile25,
558				Percentile75,
559				Percentile90,
560				AdditionalType,
561				AlternateName,
562				Description,
563				DisambiguatingDescription,
564				Identifier,
565				Image,
566				MainEntityOfPage,
567				Name,
568				PotentialAction,
569				SameAs,
570				SubjectOf,
571				Url,
572				Ignore,
573			}
574			struct FieldVisitor;
575			impl<'de> Visitor<'de> for FieldVisitor {
576				type Value = Field;
577				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
578					formatter.write_str("field identifier")
579				}
580				fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
581				where
582					E: de::Error,
583				{
584					match value {
585						"duration" => Ok(Field::Duration),
586						"median" => Ok(Field::Median),
587						"percentile10" => Ok(Field::Percentile10),
588						"percentile25" => Ok(Field::Percentile25),
589						"percentile75" => Ok(Field::Percentile75),
590						"percentile90" => Ok(Field::Percentile90),
591						"additionalType" => Ok(Field::AdditionalType),
592						"alternateName" => Ok(Field::AlternateName),
593						"description" => Ok(Field::Description),
594						"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
595						"identifier" => Ok(Field::Identifier),
596						"image" => Ok(Field::Image),
597						"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
598						"name" => Ok(Field::Name),
599						"potentialAction" => Ok(Field::PotentialAction),
600						"sameAs" => Ok(Field::SameAs),
601						"subjectOf" => Ok(Field::SubjectOf),
602						"url" => Ok(Field::Url),
603						"id" | "type" => Ok(Field::Ignore),
604						_ => Err(de::Error::unknown_field(value, FIELDS)),
605					}
606				}
607				fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
608				where
609					E: de::Error,
610				{
611					match value {
612						b"duration" => Ok(Field::Duration),
613						b"median" => Ok(Field::Median),
614						b"percentile10" => Ok(Field::Percentile10),
615						b"percentile25" => Ok(Field::Percentile25),
616						b"percentile75" => Ok(Field::Percentile75),
617						b"percentile90" => Ok(Field::Percentile90),
618						b"additionalType" => Ok(Field::AdditionalType),
619						b"alternateName" => Ok(Field::AlternateName),
620						b"description" => Ok(Field::Description),
621						b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
622						b"identifier" => Ok(Field::Identifier),
623						b"image" => Ok(Field::Image),
624						b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
625						b"name" => Ok(Field::Name),
626						b"potentialAction" => Ok(Field::PotentialAction),
627						b"sameAs" => Ok(Field::SameAs),
628						b"subjectOf" => Ok(Field::SubjectOf),
629						b"url" => Ok(Field::Url),
630						b"id" | b"type" => Ok(Field::Ignore),
631						_ => {
632							let value = &String::from_utf8_lossy(value);
633							Err(de::Error::unknown_field(value, FIELDS))
634						}
635					}
636				}
637			}
638			impl<'de> Deserialize<'de> for Field {
639				fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
640				where
641					D: Deserializer<'de>,
642				{
643					deserializer.deserialize_identifier(FieldVisitor)
644				}
645			}
646			struct ClassVisitor;
647			impl<'de> Visitor<'de> for ClassVisitor {
648				type Value = QuantitativeValueDistribution;
649				fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
650					formatter.write_str("schema.org schema QuantitativeValueDistribution")
651				}
652				fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
653				where
654					A: de::MapAccess<'de>,
655				{
656					let mut r#duration_property = None;
657					let mut r#median_property = None;
658					let mut r#percentile_10_property = None;
659					let mut r#percentile_25_property = None;
660					let mut r#percentile_75_property = None;
661					let mut r#percentile_90_property = None;
662					let mut r#additional_type_property = None;
663					let mut r#alternate_name_property = None;
664					let mut r#description_property = None;
665					let mut r#disambiguating_description_property = None;
666					let mut r#identifier_property = None;
667					let mut r#image_property = None;
668					let mut r#main_entity_of_page_property = None;
669					let mut r#name_property = None;
670					let mut r#potential_action_property = None;
671					let mut r#same_as_property = None;
672					let mut r#subject_of_property = None;
673					let mut r#url_property = None;
674					while let Some(key) = map.next_key::<Field>()? {
675						match key {
676							Field::Duration => {
677								if r#duration_property.is_some() {
678									return Err(<A::Error as de::Error>::duplicate_field(
679										"duration",
680									));
681								}
682								r#duration_property = Some({
683									struct DeserializeWith(Vec<DurationProperty>);
684									impl<'de> Deserialize<'de> for DeserializeWith {
685										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
686										where
687											D: Deserializer<'de>,
688										{
689											Ok(DeserializeWith(serde_with::As::<
690												serde_with::OneOrMany<serde_with::Same>,
691											>::deserialize(deserializer)?))
692										}
693									}
694									match map.next_value::<DeserializeWith>() {
695										Ok(deserialize_with) => deserialize_with.0,
696										Err(err) => {
697											return Err(err);
698										}
699									}
700								});
701							}
702							Field::Median => {
703								if r#median_property.is_some() {
704									return Err(<A::Error as de::Error>::duplicate_field("median"));
705								}
706								r#median_property = Some({
707									struct DeserializeWith(Vec<MedianProperty>);
708									impl<'de> Deserialize<'de> for DeserializeWith {
709										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
710										where
711											D: Deserializer<'de>,
712										{
713											Ok(DeserializeWith(serde_with::As::<
714												serde_with::OneOrMany<serde_with::Same>,
715											>::deserialize(deserializer)?))
716										}
717									}
718									match map.next_value::<DeserializeWith>() {
719										Ok(deserialize_with) => deserialize_with.0,
720										Err(err) => {
721											return Err(err);
722										}
723									}
724								});
725							}
726							Field::Percentile10 => {
727								if r#percentile_10_property.is_some() {
728									return Err(<A::Error as de::Error>::duplicate_field(
729										"percentile10",
730									));
731								}
732								r#percentile_10_property = Some({
733									struct DeserializeWith(Vec<Percentile10Property>);
734									impl<'de> Deserialize<'de> for DeserializeWith {
735										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
736										where
737											D: Deserializer<'de>,
738										{
739											Ok(DeserializeWith(serde_with::As::<
740												serde_with::OneOrMany<serde_with::Same>,
741											>::deserialize(deserializer)?))
742										}
743									}
744									match map.next_value::<DeserializeWith>() {
745										Ok(deserialize_with) => deserialize_with.0,
746										Err(err) => {
747											return Err(err);
748										}
749									}
750								});
751							}
752							Field::Percentile25 => {
753								if r#percentile_25_property.is_some() {
754									return Err(<A::Error as de::Error>::duplicate_field(
755										"percentile25",
756									));
757								}
758								r#percentile_25_property = Some({
759									struct DeserializeWith(Vec<Percentile25Property>);
760									impl<'de> Deserialize<'de> for DeserializeWith {
761										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
762										where
763											D: Deserializer<'de>,
764										{
765											Ok(DeserializeWith(serde_with::As::<
766												serde_with::OneOrMany<serde_with::Same>,
767											>::deserialize(deserializer)?))
768										}
769									}
770									match map.next_value::<DeserializeWith>() {
771										Ok(deserialize_with) => deserialize_with.0,
772										Err(err) => {
773											return Err(err);
774										}
775									}
776								});
777							}
778							Field::Percentile75 => {
779								if r#percentile_75_property.is_some() {
780									return Err(<A::Error as de::Error>::duplicate_field(
781										"percentile75",
782									));
783								}
784								r#percentile_75_property = Some({
785									struct DeserializeWith(Vec<Percentile75Property>);
786									impl<'de> Deserialize<'de> for DeserializeWith {
787										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
788										where
789											D: Deserializer<'de>,
790										{
791											Ok(DeserializeWith(serde_with::As::<
792												serde_with::OneOrMany<serde_with::Same>,
793											>::deserialize(deserializer)?))
794										}
795									}
796									match map.next_value::<DeserializeWith>() {
797										Ok(deserialize_with) => deserialize_with.0,
798										Err(err) => {
799											return Err(err);
800										}
801									}
802								});
803							}
804							Field::Percentile90 => {
805								if r#percentile_90_property.is_some() {
806									return Err(<A::Error as de::Error>::duplicate_field(
807										"percentile90",
808									));
809								}
810								r#percentile_90_property = Some({
811									struct DeserializeWith(Vec<Percentile90Property>);
812									impl<'de> Deserialize<'de> for DeserializeWith {
813										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
814										where
815											D: Deserializer<'de>,
816										{
817											Ok(DeserializeWith(serde_with::As::<
818												serde_with::OneOrMany<serde_with::Same>,
819											>::deserialize(deserializer)?))
820										}
821									}
822									match map.next_value::<DeserializeWith>() {
823										Ok(deserialize_with) => deserialize_with.0,
824										Err(err) => {
825											return Err(err);
826										}
827									}
828								});
829							}
830							Field::AdditionalType => {
831								if r#additional_type_property.is_some() {
832									return Err(<A::Error as de::Error>::duplicate_field(
833										"additionalType",
834									));
835								}
836								r#additional_type_property = Some({
837									struct DeserializeWith(Vec<AdditionalTypeProperty>);
838									impl<'de> Deserialize<'de> for DeserializeWith {
839										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
840										where
841											D: Deserializer<'de>,
842										{
843											Ok(DeserializeWith(serde_with::As::<
844												serde_with::OneOrMany<serde_with::Same>,
845											>::deserialize(deserializer)?))
846										}
847									}
848									match map.next_value::<DeserializeWith>() {
849										Ok(deserialize_with) => deserialize_with.0,
850										Err(err) => {
851											return Err(err);
852										}
853									}
854								});
855							}
856							Field::AlternateName => {
857								if r#alternate_name_property.is_some() {
858									return Err(<A::Error as de::Error>::duplicate_field(
859										"alternateName",
860									));
861								}
862								r#alternate_name_property = Some({
863									struct DeserializeWith(Vec<AlternateNameProperty>);
864									impl<'de> Deserialize<'de> for DeserializeWith {
865										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
866										where
867											D: Deserializer<'de>,
868										{
869											Ok(DeserializeWith(serde_with::As::<
870												serde_with::OneOrMany<serde_with::Same>,
871											>::deserialize(deserializer)?))
872										}
873									}
874									match map.next_value::<DeserializeWith>() {
875										Ok(deserialize_with) => deserialize_with.0,
876										Err(err) => {
877											return Err(err);
878										}
879									}
880								});
881							}
882							Field::Description => {
883								if r#description_property.is_some() {
884									return Err(<A::Error as de::Error>::duplicate_field(
885										"description",
886									));
887								}
888								r#description_property = Some({
889									struct DeserializeWith(Vec<DescriptionProperty>);
890									impl<'de> Deserialize<'de> for DeserializeWith {
891										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
892										where
893											D: Deserializer<'de>,
894										{
895											Ok(DeserializeWith(serde_with::As::<
896												serde_with::OneOrMany<serde_with::Same>,
897											>::deserialize(deserializer)?))
898										}
899									}
900									match map.next_value::<DeserializeWith>() {
901										Ok(deserialize_with) => deserialize_with.0,
902										Err(err) => {
903											return Err(err);
904										}
905									}
906								});
907							}
908							Field::DisambiguatingDescription => {
909								if r#disambiguating_description_property.is_some() {
910									return Err(<A::Error as de::Error>::duplicate_field(
911										"disambiguatingDescription",
912									));
913								}
914								r#disambiguating_description_property = Some({
915									struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
916									impl<'de> Deserialize<'de> for DeserializeWith {
917										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
918										where
919											D: Deserializer<'de>,
920										{
921											Ok(DeserializeWith(serde_with::As::<
922												serde_with::OneOrMany<serde_with::Same>,
923											>::deserialize(deserializer)?))
924										}
925									}
926									match map.next_value::<DeserializeWith>() {
927										Ok(deserialize_with) => deserialize_with.0,
928										Err(err) => {
929											return Err(err);
930										}
931									}
932								});
933							}
934							Field::Identifier => {
935								if r#identifier_property.is_some() {
936									return Err(<A::Error as de::Error>::duplicate_field(
937										"identifier",
938									));
939								}
940								r#identifier_property = Some({
941									struct DeserializeWith(Vec<IdentifierProperty>);
942									impl<'de> Deserialize<'de> for DeserializeWith {
943										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
944										where
945											D: Deserializer<'de>,
946										{
947											Ok(DeserializeWith(serde_with::As::<
948												serde_with::OneOrMany<serde_with::Same>,
949											>::deserialize(deserializer)?))
950										}
951									}
952									match map.next_value::<DeserializeWith>() {
953										Ok(deserialize_with) => deserialize_with.0,
954										Err(err) => {
955											return Err(err);
956										}
957									}
958								});
959							}
960							Field::Image => {
961								if r#image_property.is_some() {
962									return Err(<A::Error as de::Error>::duplicate_field("image"));
963								}
964								r#image_property = Some({
965									struct DeserializeWith(Vec<ImageProperty>);
966									impl<'de> Deserialize<'de> for DeserializeWith {
967										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
968										where
969											D: Deserializer<'de>,
970										{
971											Ok(DeserializeWith(serde_with::As::<
972												serde_with::OneOrMany<serde_with::Same>,
973											>::deserialize(deserializer)?))
974										}
975									}
976									match map.next_value::<DeserializeWith>() {
977										Ok(deserialize_with) => deserialize_with.0,
978										Err(err) => {
979											return Err(err);
980										}
981									}
982								});
983							}
984							Field::MainEntityOfPage => {
985								if r#main_entity_of_page_property.is_some() {
986									return Err(<A::Error as de::Error>::duplicate_field(
987										"mainEntityOfPage",
988									));
989								}
990								r#main_entity_of_page_property = Some({
991									struct DeserializeWith(Vec<MainEntityOfPageProperty>);
992									impl<'de> Deserialize<'de> for DeserializeWith {
993										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
994										where
995											D: Deserializer<'de>,
996										{
997											Ok(DeserializeWith(serde_with::As::<
998												serde_with::OneOrMany<serde_with::Same>,
999											>::deserialize(deserializer)?))
1000										}
1001									}
1002									match map.next_value::<DeserializeWith>() {
1003										Ok(deserialize_with) => deserialize_with.0,
1004										Err(err) => {
1005											return Err(err);
1006										}
1007									}
1008								});
1009							}
1010							Field::Name => {
1011								if r#name_property.is_some() {
1012									return Err(<A::Error as de::Error>::duplicate_field("name"));
1013								}
1014								r#name_property = Some({
1015									struct DeserializeWith(Vec<NameProperty>);
1016									impl<'de> Deserialize<'de> for DeserializeWith {
1017										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1018										where
1019											D: Deserializer<'de>,
1020										{
1021											Ok(DeserializeWith(serde_with::As::<
1022												serde_with::OneOrMany<serde_with::Same>,
1023											>::deserialize(deserializer)?))
1024										}
1025									}
1026									match map.next_value::<DeserializeWith>() {
1027										Ok(deserialize_with) => deserialize_with.0,
1028										Err(err) => {
1029											return Err(err);
1030										}
1031									}
1032								});
1033							}
1034							Field::PotentialAction => {
1035								if r#potential_action_property.is_some() {
1036									return Err(<A::Error as de::Error>::duplicate_field(
1037										"potentialAction",
1038									));
1039								}
1040								r#potential_action_property = Some({
1041									struct DeserializeWith(Vec<PotentialActionProperty>);
1042									impl<'de> Deserialize<'de> for DeserializeWith {
1043										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1044										where
1045											D: Deserializer<'de>,
1046										{
1047											Ok(DeserializeWith(serde_with::As::<
1048												serde_with::OneOrMany<serde_with::Same>,
1049											>::deserialize(deserializer)?))
1050										}
1051									}
1052									match map.next_value::<DeserializeWith>() {
1053										Ok(deserialize_with) => deserialize_with.0,
1054										Err(err) => {
1055											return Err(err);
1056										}
1057									}
1058								});
1059							}
1060							Field::SameAs => {
1061								if r#same_as_property.is_some() {
1062									return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1063								}
1064								r#same_as_property = Some({
1065									struct DeserializeWith(Vec<SameAsProperty>);
1066									impl<'de> Deserialize<'de> for DeserializeWith {
1067										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1068										where
1069											D: Deserializer<'de>,
1070										{
1071											Ok(DeserializeWith(serde_with::As::<
1072												serde_with::OneOrMany<serde_with::Same>,
1073											>::deserialize(deserializer)?))
1074										}
1075									}
1076									match map.next_value::<DeserializeWith>() {
1077										Ok(deserialize_with) => deserialize_with.0,
1078										Err(err) => {
1079											return Err(err);
1080										}
1081									}
1082								});
1083							}
1084							Field::SubjectOf => {
1085								if r#subject_of_property.is_some() {
1086									return Err(<A::Error as de::Error>::duplicate_field(
1087										"subjectOf",
1088									));
1089								}
1090								r#subject_of_property = Some({
1091									struct DeserializeWith(Vec<SubjectOfProperty>);
1092									impl<'de> Deserialize<'de> for DeserializeWith {
1093										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1094										where
1095											D: Deserializer<'de>,
1096										{
1097											Ok(DeserializeWith(serde_with::As::<
1098												serde_with::OneOrMany<serde_with::Same>,
1099											>::deserialize(deserializer)?))
1100										}
1101									}
1102									match map.next_value::<DeserializeWith>() {
1103										Ok(deserialize_with) => deserialize_with.0,
1104										Err(err) => {
1105											return Err(err);
1106										}
1107									}
1108								});
1109							}
1110							Field::Url => {
1111								if r#url_property.is_some() {
1112									return Err(<A::Error as de::Error>::duplicate_field("url"));
1113								}
1114								r#url_property = Some({
1115									struct DeserializeWith(Vec<UrlProperty>);
1116									impl<'de> Deserialize<'de> for DeserializeWith {
1117										fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1118										where
1119											D: Deserializer<'de>,
1120										{
1121											Ok(DeserializeWith(serde_with::As::<
1122												serde_with::OneOrMany<serde_with::Same>,
1123											>::deserialize(deserializer)?))
1124										}
1125									}
1126									match map.next_value::<DeserializeWith>() {
1127										Ok(deserialize_with) => deserialize_with.0,
1128										Err(err) => {
1129											return Err(err);
1130										}
1131									}
1132								});
1133							}
1134							Field::Ignore => {
1135								let _ = map.next_value::<de::IgnoredAny>()?;
1136							}
1137						}
1138					}
1139					Ok(QuantitativeValueDistribution {
1140						r#duration: r#duration_property.unwrap_or_default(),
1141						r#median: r#median_property.unwrap_or_default(),
1142						r#percentile_10: r#percentile_10_property.unwrap_or_default(),
1143						r#percentile_25: r#percentile_25_property.unwrap_or_default(),
1144						r#percentile_75: r#percentile_75_property.unwrap_or_default(),
1145						r#percentile_90: r#percentile_90_property.unwrap_or_default(),
1146						r#additional_type: r#additional_type_property.unwrap_or_default(),
1147						r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1148						r#description: r#description_property.unwrap_or_default(),
1149						r#disambiguating_description: r#disambiguating_description_property
1150							.unwrap_or_default(),
1151						r#identifier: r#identifier_property.unwrap_or_default(),
1152						r#image: r#image_property.unwrap_or_default(),
1153						r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1154						r#name: r#name_property.unwrap_or_default(),
1155						r#potential_action: r#potential_action_property.unwrap_or_default(),
1156						r#same_as: r#same_as_property.unwrap_or_default(),
1157						r#subject_of: r#subject_of_property.unwrap_or_default(),
1158						r#url: r#url_property.unwrap_or_default(),
1159					})
1160				}
1161			}
1162			const FIELDS: &[&str] = &[
1163				"duration",
1164				"median",
1165				"percentile10",
1166				"percentile25",
1167				"percentile75",
1168				"percentile90",
1169				"additionalType",
1170				"alternateName",
1171				"description",
1172				"disambiguatingDescription",
1173				"identifier",
1174				"image",
1175				"mainEntityOfPage",
1176				"name",
1177				"potentialAction",
1178				"sameAs",
1179				"subjectOf",
1180				"url",
1181			];
1182			deserializer.deserialize_struct("QuantitativeValueDistribution", FIELDS, ClassVisitor)
1183		}
1184	}
1185}
schema_org_types/schemas/classes/quantitative_value_distribution.rs

schema_org_types/schemas/classes/
quantitative_value_distribution.rs
