schema_org_types/schemas/classes/
link_role.rs

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

schema_org_types/schemas/classes/
link_role.rs
