schema_org_types/schemas/classes/
performance_role.rs

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

schema_org_types/schemas/classes/
performance_role.rs
