1use super::*;
2#[cfg_attr(feature = "derive-debug", derive(Debug))]
4#[cfg_attr(feature = "derive-clone", derive(Clone))]
5pub struct BorrowAction {
6 pub r#lender: Vec<LenderProperty>,
8 pub r#action_status: Vec<ActionStatusProperty>,
10 pub r#agent: Vec<AgentProperty>,
12 pub r#end_time: Vec<EndTimeProperty>,
14 pub r#error: Vec<ErrorProperty>,
16 pub r#instrument: Vec<InstrumentProperty>,
18 pub r#location: Vec<LocationProperty>,
20 pub r#object: Vec<ObjectProperty>,
22 pub r#participant: Vec<ParticipantProperty>,
24 pub r#provider: Vec<ProviderProperty>,
26 pub r#result: Vec<ResultProperty>,
28 pub r#start_time: Vec<StartTimeProperty>,
30 pub r#target: Vec<TargetProperty>,
32 pub r#additional_type: Vec<AdditionalTypeProperty>,
34 pub r#alternate_name: Vec<AlternateNameProperty>,
36 pub r#description: Vec<DescriptionProperty>,
38 pub r#disambiguating_description: Vec<DisambiguatingDescriptionProperty>,
40 pub r#identifier: Vec<IdentifierProperty>,
42 pub r#image: Vec<ImageProperty>,
44 pub r#main_entity_of_page: Vec<MainEntityOfPageProperty>,
46 pub r#name: Vec<NameProperty>,
48 pub r#potential_action: Vec<PotentialActionProperty>,
50 pub r#same_as: Vec<SameAsProperty>,
52 pub r#subject_of: Vec<SubjectOfProperty>,
54 pub r#url: Vec<UrlProperty>,
56 pub r#from_location: Vec<FromLocationProperty>,
58 pub r#to_location: Vec<ToLocationProperty>,
60}
61pub trait BorrowActionTrait {
63 fn get_lender(&self) -> &[LenderProperty];
65 fn take_lender(&mut self) -> Vec<LenderProperty>;
67}
68impl BorrowActionTrait for BorrowAction {
69 fn get_lender(&self) -> &[LenderProperty] {
70 self.r#lender.as_slice()
71 }
72 fn take_lender(&mut self) -> Vec<LenderProperty> {
73 std::mem::take(&mut self.r#lender)
74 }
75}
76impl ActionTrait for BorrowAction {
77 fn get_action_status(&self) -> &[ActionStatusProperty] {
78 self.r#action_status.as_slice()
79 }
80 fn take_action_status(&mut self) -> Vec<ActionStatusProperty> {
81 std::mem::take(&mut self.r#action_status)
82 }
83 fn get_agent(&self) -> &[AgentProperty] {
84 self.r#agent.as_slice()
85 }
86 fn take_agent(&mut self) -> Vec<AgentProperty> {
87 std::mem::take(&mut self.r#agent)
88 }
89 fn get_end_time(&self) -> &[EndTimeProperty] {
90 self.r#end_time.as_slice()
91 }
92 fn take_end_time(&mut self) -> Vec<EndTimeProperty> {
93 std::mem::take(&mut self.r#end_time)
94 }
95 fn get_error(&self) -> &[ErrorProperty] {
96 self.r#error.as_slice()
97 }
98 fn take_error(&mut self) -> Vec<ErrorProperty> {
99 std::mem::take(&mut self.r#error)
100 }
101 fn get_instrument(&self) -> &[InstrumentProperty] {
102 self.r#instrument.as_slice()
103 }
104 fn take_instrument(&mut self) -> Vec<InstrumentProperty> {
105 std::mem::take(&mut self.r#instrument)
106 }
107 fn get_location(&self) -> &[LocationProperty] {
108 self.r#location.as_slice()
109 }
110 fn take_location(&mut self) -> Vec<LocationProperty> {
111 std::mem::take(&mut self.r#location)
112 }
113 fn get_object(&self) -> &[ObjectProperty] {
114 self.r#object.as_slice()
115 }
116 fn take_object(&mut self) -> Vec<ObjectProperty> {
117 std::mem::take(&mut self.r#object)
118 }
119 fn get_participant(&self) -> &[ParticipantProperty] {
120 self.r#participant.as_slice()
121 }
122 fn take_participant(&mut self) -> Vec<ParticipantProperty> {
123 std::mem::take(&mut self.r#participant)
124 }
125 fn get_provider(&self) -> &[ProviderProperty] {
126 self.r#provider.as_slice()
127 }
128 fn take_provider(&mut self) -> Vec<ProviderProperty> {
129 std::mem::take(&mut self.r#provider)
130 }
131 fn get_result(&self) -> &[ResultProperty] {
132 self.r#result.as_slice()
133 }
134 fn take_result(&mut self) -> Vec<ResultProperty> {
135 std::mem::take(&mut self.r#result)
136 }
137 fn get_start_time(&self) -> &[StartTimeProperty] {
138 self.r#start_time.as_slice()
139 }
140 fn take_start_time(&mut self) -> Vec<StartTimeProperty> {
141 std::mem::take(&mut self.r#start_time)
142 }
143 fn get_target(&self) -> &[TargetProperty] {
144 self.r#target.as_slice()
145 }
146 fn take_target(&mut self) -> Vec<TargetProperty> {
147 std::mem::take(&mut self.r#target)
148 }
149}
150impl ThingTrait for BorrowAction {
151 fn get_additional_type(&self) -> &[AdditionalTypeProperty] {
152 self.r#additional_type.as_slice()
153 }
154 fn take_additional_type(&mut self) -> Vec<AdditionalTypeProperty> {
155 std::mem::take(&mut self.r#additional_type)
156 }
157 fn get_alternate_name(&self) -> &[AlternateNameProperty] {
158 self.r#alternate_name.as_slice()
159 }
160 fn take_alternate_name(&mut self) -> Vec<AlternateNameProperty> {
161 std::mem::take(&mut self.r#alternate_name)
162 }
163 fn get_description(&self) -> &[DescriptionProperty] {
164 self.r#description.as_slice()
165 }
166 fn take_description(&mut self) -> Vec<DescriptionProperty> {
167 std::mem::take(&mut self.r#description)
168 }
169 fn get_disambiguating_description(&self) -> &[DisambiguatingDescriptionProperty] {
170 self.r#disambiguating_description.as_slice()
171 }
172 fn take_disambiguating_description(&mut self) -> Vec<DisambiguatingDescriptionProperty> {
173 std::mem::take(&mut self.r#disambiguating_description)
174 }
175 fn get_identifier(&self) -> &[IdentifierProperty] {
176 self.r#identifier.as_slice()
177 }
178 fn take_identifier(&mut self) -> Vec<IdentifierProperty> {
179 std::mem::take(&mut self.r#identifier)
180 }
181 fn get_image(&self) -> &[ImageProperty] {
182 self.r#image.as_slice()
183 }
184 fn take_image(&mut self) -> Vec<ImageProperty> {
185 std::mem::take(&mut self.r#image)
186 }
187 fn get_main_entity_of_page(&self) -> &[MainEntityOfPageProperty] {
188 self.r#main_entity_of_page.as_slice()
189 }
190 fn take_main_entity_of_page(&mut self) -> Vec<MainEntityOfPageProperty> {
191 std::mem::take(&mut self.r#main_entity_of_page)
192 }
193 fn get_name(&self) -> &[NameProperty] {
194 self.r#name.as_slice()
195 }
196 fn take_name(&mut self) -> Vec<NameProperty> {
197 std::mem::take(&mut self.r#name)
198 }
199 fn get_potential_action(&self) -> &[PotentialActionProperty] {
200 self.r#potential_action.as_slice()
201 }
202 fn take_potential_action(&mut self) -> Vec<PotentialActionProperty> {
203 std::mem::take(&mut self.r#potential_action)
204 }
205 fn get_same_as(&self) -> &[SameAsProperty] {
206 self.r#same_as.as_slice()
207 }
208 fn take_same_as(&mut self) -> Vec<SameAsProperty> {
209 std::mem::take(&mut self.r#same_as)
210 }
211 fn get_subject_of(&self) -> &[SubjectOfProperty] {
212 self.r#subject_of.as_slice()
213 }
214 fn take_subject_of(&mut self) -> Vec<SubjectOfProperty> {
215 std::mem::take(&mut self.r#subject_of)
216 }
217 fn get_url(&self) -> &[UrlProperty] {
218 self.r#url.as_slice()
219 }
220 fn take_url(&mut self) -> Vec<UrlProperty> {
221 std::mem::take(&mut self.r#url)
222 }
223}
224impl TransferActionTrait for BorrowAction {
225 fn get_from_location(&self) -> &[FromLocationProperty] {
226 self.r#from_location.as_slice()
227 }
228 fn take_from_location(&mut self) -> Vec<FromLocationProperty> {
229 std::mem::take(&mut self.r#from_location)
230 }
231 fn get_to_location(&self) -> &[ToLocationProperty] {
232 self.r#to_location.as_slice()
233 }
234 fn take_to_location(&mut self) -> Vec<ToLocationProperty> {
235 std::mem::take(&mut self.r#to_location)
236 }
237}
238#[cfg(feature = "serde")]
239mod serde {
240 use std::{fmt, fmt::Formatter};
241
242 use ::serde::{
243 de, de::Visitor, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer,
244 };
245
246 use super::*;
247 impl Serialize for BorrowAction {
248 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
249 where
250 S: Serializer,
251 {
252 let len: usize = [
253 !Vec::is_empty(&self.r#lender) as usize,
254 !Vec::is_empty(&self.r#action_status) as usize,
255 !Vec::is_empty(&self.r#agent) as usize,
256 !Vec::is_empty(&self.r#end_time) as usize,
257 !Vec::is_empty(&self.r#error) as usize,
258 !Vec::is_empty(&self.r#instrument) as usize,
259 !Vec::is_empty(&self.r#location) as usize,
260 !Vec::is_empty(&self.r#object) as usize,
261 !Vec::is_empty(&self.r#participant) as usize,
262 !Vec::is_empty(&self.r#provider) as usize,
263 !Vec::is_empty(&self.r#result) as usize,
264 !Vec::is_empty(&self.r#start_time) as usize,
265 !Vec::is_empty(&self.r#target) as usize,
266 !Vec::is_empty(&self.r#additional_type) as usize,
267 !Vec::is_empty(&self.r#alternate_name) as usize,
268 !Vec::is_empty(&self.r#description) as usize,
269 !Vec::is_empty(&self.r#disambiguating_description) as usize,
270 !Vec::is_empty(&self.r#identifier) as usize,
271 !Vec::is_empty(&self.r#image) as usize,
272 !Vec::is_empty(&self.r#main_entity_of_page) as usize,
273 !Vec::is_empty(&self.r#name) as usize,
274 !Vec::is_empty(&self.r#potential_action) as usize,
275 !Vec::is_empty(&self.r#same_as) as usize,
276 !Vec::is_empty(&self.r#subject_of) as usize,
277 !Vec::is_empty(&self.r#url) as usize,
278 !Vec::is_empty(&self.r#from_location) as usize,
279 !Vec::is_empty(&self.r#to_location) as usize,
280 ]
281 .iter()
282 .sum();
283 let mut serialize_struct =
284 Serializer::serialize_struct(serializer, "BorrowAction", len)?;
285 if !Vec::is_empty(&self.r#lender) {
286 serialize_struct.serialize_field("lender", {
287 struct SerializeWith<'a>(&'a Vec<LenderProperty>);
288 impl<'a> Serialize for SerializeWith<'a> {
289 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
290 where
291 S: Serializer,
292 {
293 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
294 self.0, serializer,
295 )
296 }
297 }
298 &SerializeWith(&self.r#lender)
299 })?;
300 } else {
301 serialize_struct.skip_field("lender")?;
302 }
303 if !Vec::is_empty(&self.r#action_status) {
304 serialize_struct.serialize_field("actionStatus", {
305 struct SerializeWith<'a>(&'a Vec<ActionStatusProperty>);
306 impl<'a> Serialize for SerializeWith<'a> {
307 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
308 where
309 S: Serializer,
310 {
311 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
312 self.0, serializer,
313 )
314 }
315 }
316 &SerializeWith(&self.r#action_status)
317 })?;
318 } else {
319 serialize_struct.skip_field("actionStatus")?;
320 }
321 if !Vec::is_empty(&self.r#agent) {
322 serialize_struct.serialize_field("agent", {
323 struct SerializeWith<'a>(&'a Vec<AgentProperty>);
324 impl<'a> Serialize for SerializeWith<'a> {
325 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
326 where
327 S: Serializer,
328 {
329 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
330 self.0, serializer,
331 )
332 }
333 }
334 &SerializeWith(&self.r#agent)
335 })?;
336 } else {
337 serialize_struct.skip_field("agent")?;
338 }
339 if !Vec::is_empty(&self.r#end_time) {
340 serialize_struct.serialize_field("endTime", {
341 struct SerializeWith<'a>(&'a Vec<EndTimeProperty>);
342 impl<'a> Serialize for SerializeWith<'a> {
343 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
344 where
345 S: Serializer,
346 {
347 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
348 self.0, serializer,
349 )
350 }
351 }
352 &SerializeWith(&self.r#end_time)
353 })?;
354 } else {
355 serialize_struct.skip_field("endTime")?;
356 }
357 if !Vec::is_empty(&self.r#error) {
358 serialize_struct.serialize_field("error", {
359 struct SerializeWith<'a>(&'a Vec<ErrorProperty>);
360 impl<'a> Serialize for SerializeWith<'a> {
361 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
362 where
363 S: Serializer,
364 {
365 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
366 self.0, serializer,
367 )
368 }
369 }
370 &SerializeWith(&self.r#error)
371 })?;
372 } else {
373 serialize_struct.skip_field("error")?;
374 }
375 if !Vec::is_empty(&self.r#instrument) {
376 serialize_struct.serialize_field("instrument", {
377 struct SerializeWith<'a>(&'a Vec<InstrumentProperty>);
378 impl<'a> Serialize for SerializeWith<'a> {
379 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
380 where
381 S: Serializer,
382 {
383 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
384 self.0, serializer,
385 )
386 }
387 }
388 &SerializeWith(&self.r#instrument)
389 })?;
390 } else {
391 serialize_struct.skip_field("instrument")?;
392 }
393 if !Vec::is_empty(&self.r#location) {
394 serialize_struct.serialize_field("location", {
395 struct SerializeWith<'a>(&'a Vec<LocationProperty>);
396 impl<'a> Serialize for SerializeWith<'a> {
397 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
398 where
399 S: Serializer,
400 {
401 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
402 self.0, serializer,
403 )
404 }
405 }
406 &SerializeWith(&self.r#location)
407 })?;
408 } else {
409 serialize_struct.skip_field("location")?;
410 }
411 if !Vec::is_empty(&self.r#object) {
412 serialize_struct.serialize_field("object", {
413 struct SerializeWith<'a>(&'a Vec<ObjectProperty>);
414 impl<'a> Serialize for SerializeWith<'a> {
415 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
416 where
417 S: Serializer,
418 {
419 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
420 self.0, serializer,
421 )
422 }
423 }
424 &SerializeWith(&self.r#object)
425 })?;
426 } else {
427 serialize_struct.skip_field("object")?;
428 }
429 if !Vec::is_empty(&self.r#participant) {
430 serialize_struct.serialize_field("participant", {
431 struct SerializeWith<'a>(&'a Vec<ParticipantProperty>);
432 impl<'a> Serialize for SerializeWith<'a> {
433 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
434 where
435 S: Serializer,
436 {
437 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
438 self.0, serializer,
439 )
440 }
441 }
442 &SerializeWith(&self.r#participant)
443 })?;
444 } else {
445 serialize_struct.skip_field("participant")?;
446 }
447 if !Vec::is_empty(&self.r#provider) {
448 serialize_struct.serialize_field("provider", {
449 struct SerializeWith<'a>(&'a Vec<ProviderProperty>);
450 impl<'a> Serialize for SerializeWith<'a> {
451 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
452 where
453 S: Serializer,
454 {
455 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
456 self.0, serializer,
457 )
458 }
459 }
460 &SerializeWith(&self.r#provider)
461 })?;
462 } else {
463 serialize_struct.skip_field("provider")?;
464 }
465 if !Vec::is_empty(&self.r#result) {
466 serialize_struct.serialize_field("result", {
467 struct SerializeWith<'a>(&'a Vec<ResultProperty>);
468 impl<'a> Serialize for SerializeWith<'a> {
469 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
470 where
471 S: Serializer,
472 {
473 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
474 self.0, serializer,
475 )
476 }
477 }
478 &SerializeWith(&self.r#result)
479 })?;
480 } else {
481 serialize_struct.skip_field("result")?;
482 }
483 if !Vec::is_empty(&self.r#start_time) {
484 serialize_struct.serialize_field("startTime", {
485 struct SerializeWith<'a>(&'a Vec<StartTimeProperty>);
486 impl<'a> Serialize for SerializeWith<'a> {
487 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
488 where
489 S: Serializer,
490 {
491 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
492 self.0, serializer,
493 )
494 }
495 }
496 &SerializeWith(&self.r#start_time)
497 })?;
498 } else {
499 serialize_struct.skip_field("startTime")?;
500 }
501 if !Vec::is_empty(&self.r#target) {
502 serialize_struct.serialize_field("target", {
503 struct SerializeWith<'a>(&'a Vec<TargetProperty>);
504 impl<'a> Serialize for SerializeWith<'a> {
505 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
506 where
507 S: Serializer,
508 {
509 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
510 self.0, serializer,
511 )
512 }
513 }
514 &SerializeWith(&self.r#target)
515 })?;
516 } else {
517 serialize_struct.skip_field("target")?;
518 }
519 if !Vec::is_empty(&self.r#additional_type) {
520 serialize_struct.serialize_field("additionalType", {
521 struct SerializeWith<'a>(&'a Vec<AdditionalTypeProperty>);
522 impl<'a> Serialize for SerializeWith<'a> {
523 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
524 where
525 S: Serializer,
526 {
527 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
528 self.0, serializer,
529 )
530 }
531 }
532 &SerializeWith(&self.r#additional_type)
533 })?;
534 } else {
535 serialize_struct.skip_field("additionalType")?;
536 }
537 if !Vec::is_empty(&self.r#alternate_name) {
538 serialize_struct.serialize_field("alternateName", {
539 struct SerializeWith<'a>(&'a Vec<AlternateNameProperty>);
540 impl<'a> Serialize for SerializeWith<'a> {
541 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
542 where
543 S: Serializer,
544 {
545 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
546 self.0, serializer,
547 )
548 }
549 }
550 &SerializeWith(&self.r#alternate_name)
551 })?;
552 } else {
553 serialize_struct.skip_field("alternateName")?;
554 }
555 if !Vec::is_empty(&self.r#description) {
556 serialize_struct.serialize_field("description", {
557 struct SerializeWith<'a>(&'a Vec<DescriptionProperty>);
558 impl<'a> Serialize for SerializeWith<'a> {
559 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
560 where
561 S: Serializer,
562 {
563 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
564 self.0, serializer,
565 )
566 }
567 }
568 &SerializeWith(&self.r#description)
569 })?;
570 } else {
571 serialize_struct.skip_field("description")?;
572 }
573 if !Vec::is_empty(&self.r#disambiguating_description) {
574 serialize_struct.serialize_field("disambiguatingDescription", {
575 struct SerializeWith<'a>(&'a Vec<DisambiguatingDescriptionProperty>);
576 impl<'a> Serialize for SerializeWith<'a> {
577 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
578 where
579 S: Serializer,
580 {
581 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
582 self.0, serializer,
583 )
584 }
585 }
586 &SerializeWith(&self.r#disambiguating_description)
587 })?;
588 } else {
589 serialize_struct.skip_field("disambiguatingDescription")?;
590 }
591 if !Vec::is_empty(&self.r#identifier) {
592 serialize_struct.serialize_field("identifier", {
593 struct SerializeWith<'a>(&'a Vec<IdentifierProperty>);
594 impl<'a> Serialize for SerializeWith<'a> {
595 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
596 where
597 S: Serializer,
598 {
599 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
600 self.0, serializer,
601 )
602 }
603 }
604 &SerializeWith(&self.r#identifier)
605 })?;
606 } else {
607 serialize_struct.skip_field("identifier")?;
608 }
609 if !Vec::is_empty(&self.r#image) {
610 serialize_struct.serialize_field("image", {
611 struct SerializeWith<'a>(&'a Vec<ImageProperty>);
612 impl<'a> Serialize for SerializeWith<'a> {
613 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
614 where
615 S: Serializer,
616 {
617 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
618 self.0, serializer,
619 )
620 }
621 }
622 &SerializeWith(&self.r#image)
623 })?;
624 } else {
625 serialize_struct.skip_field("image")?;
626 }
627 if !Vec::is_empty(&self.r#main_entity_of_page) {
628 serialize_struct.serialize_field("mainEntityOfPage", {
629 struct SerializeWith<'a>(&'a Vec<MainEntityOfPageProperty>);
630 impl<'a> Serialize for SerializeWith<'a> {
631 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
632 where
633 S: Serializer,
634 {
635 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
636 self.0, serializer,
637 )
638 }
639 }
640 &SerializeWith(&self.r#main_entity_of_page)
641 })?;
642 } else {
643 serialize_struct.skip_field("mainEntityOfPage")?;
644 }
645 if !Vec::is_empty(&self.r#name) {
646 serialize_struct.serialize_field("name", {
647 struct SerializeWith<'a>(&'a Vec<NameProperty>);
648 impl<'a> Serialize for SerializeWith<'a> {
649 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
650 where
651 S: Serializer,
652 {
653 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
654 self.0, serializer,
655 )
656 }
657 }
658 &SerializeWith(&self.r#name)
659 })?;
660 } else {
661 serialize_struct.skip_field("name")?;
662 }
663 if !Vec::is_empty(&self.r#potential_action) {
664 serialize_struct.serialize_field("potentialAction", {
665 struct SerializeWith<'a>(&'a Vec<PotentialActionProperty>);
666 impl<'a> Serialize for SerializeWith<'a> {
667 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
668 where
669 S: Serializer,
670 {
671 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
672 self.0, serializer,
673 )
674 }
675 }
676 &SerializeWith(&self.r#potential_action)
677 })?;
678 } else {
679 serialize_struct.skip_field("potentialAction")?;
680 }
681 if !Vec::is_empty(&self.r#same_as) {
682 serialize_struct.serialize_field("sameAs", {
683 struct SerializeWith<'a>(&'a Vec<SameAsProperty>);
684 impl<'a> Serialize for SerializeWith<'a> {
685 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
686 where
687 S: Serializer,
688 {
689 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
690 self.0, serializer,
691 )
692 }
693 }
694 &SerializeWith(&self.r#same_as)
695 })?;
696 } else {
697 serialize_struct.skip_field("sameAs")?;
698 }
699 if !Vec::is_empty(&self.r#subject_of) {
700 serialize_struct.serialize_field("subjectOf", {
701 struct SerializeWith<'a>(&'a Vec<SubjectOfProperty>);
702 impl<'a> Serialize for SerializeWith<'a> {
703 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
704 where
705 S: Serializer,
706 {
707 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
708 self.0, serializer,
709 )
710 }
711 }
712 &SerializeWith(&self.r#subject_of)
713 })?;
714 } else {
715 serialize_struct.skip_field("subjectOf")?;
716 }
717 if !Vec::is_empty(&self.r#url) {
718 serialize_struct.serialize_field("url", {
719 struct SerializeWith<'a>(&'a Vec<UrlProperty>);
720 impl<'a> Serialize for SerializeWith<'a> {
721 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
722 where
723 S: Serializer,
724 {
725 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
726 self.0, serializer,
727 )
728 }
729 }
730 &SerializeWith(&self.r#url)
731 })?;
732 } else {
733 serialize_struct.skip_field("url")?;
734 }
735 if !Vec::is_empty(&self.r#from_location) {
736 serialize_struct.serialize_field("fromLocation", {
737 struct SerializeWith<'a>(&'a Vec<FromLocationProperty>);
738 impl<'a> Serialize for SerializeWith<'a> {
739 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
740 where
741 S: Serializer,
742 {
743 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
744 self.0, serializer,
745 )
746 }
747 }
748 &SerializeWith(&self.r#from_location)
749 })?;
750 } else {
751 serialize_struct.skip_field("fromLocation")?;
752 }
753 if !Vec::is_empty(&self.r#to_location) {
754 serialize_struct.serialize_field("toLocation", {
755 struct SerializeWith<'a>(&'a Vec<ToLocationProperty>);
756 impl<'a> Serialize for SerializeWith<'a> {
757 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
758 where
759 S: Serializer,
760 {
761 serde_with::As::<serde_with::OneOrMany<serde_with::Same>>::serialize(
762 self.0, serializer,
763 )
764 }
765 }
766 &SerializeWith(&self.r#to_location)
767 })?;
768 } else {
769 serialize_struct.skip_field("toLocation")?;
770 }
771 serialize_struct.end()
772 }
773 }
774 impl<'de> Deserialize<'de> for BorrowAction {
775 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
776 where
777 D: Deserializer<'de>,
778 {
779 enum Field {
780 Lender,
781 ActionStatus,
782 Agent,
783 EndTime,
784 Error,
785 Instrument,
786 Location,
787 Object,
788 Participant,
789 Provider,
790 Result,
791 StartTime,
792 Target,
793 AdditionalType,
794 AlternateName,
795 Description,
796 DisambiguatingDescription,
797 Identifier,
798 Image,
799 MainEntityOfPage,
800 Name,
801 PotentialAction,
802 SameAs,
803 SubjectOf,
804 Url,
805 FromLocation,
806 ToLocation,
807 Ignore,
808 }
809 struct FieldVisitor;
810 impl<'de> Visitor<'de> for FieldVisitor {
811 type Value = Field;
812 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
813 formatter.write_str("field identifier")
814 }
815 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
816 where
817 E: de::Error,
818 {
819 match value {
820 "lender" => Ok(Field::Lender),
821 "actionStatus" => Ok(Field::ActionStatus),
822 "agent" => Ok(Field::Agent),
823 "endTime" => Ok(Field::EndTime),
824 "error" => Ok(Field::Error),
825 "instrument" => Ok(Field::Instrument),
826 "location" => Ok(Field::Location),
827 "object" => Ok(Field::Object),
828 "participant" => Ok(Field::Participant),
829 "provider" => Ok(Field::Provider),
830 "result" => Ok(Field::Result),
831 "startTime" => Ok(Field::StartTime),
832 "target" => Ok(Field::Target),
833 "additionalType" => Ok(Field::AdditionalType),
834 "alternateName" => Ok(Field::AlternateName),
835 "description" => Ok(Field::Description),
836 "disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
837 "identifier" => Ok(Field::Identifier),
838 "image" => Ok(Field::Image),
839 "mainEntityOfPage" => Ok(Field::MainEntityOfPage),
840 "name" => Ok(Field::Name),
841 "potentialAction" => Ok(Field::PotentialAction),
842 "sameAs" => Ok(Field::SameAs),
843 "subjectOf" => Ok(Field::SubjectOf),
844 "url" => Ok(Field::Url),
845 "fromLocation" => Ok(Field::FromLocation),
846 "toLocation" => Ok(Field::ToLocation),
847 "id" | "type" => Ok(Field::Ignore),
848 _ => Err(de::Error::unknown_field(value, FIELDS)),
849 }
850 }
851 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
852 where
853 E: de::Error,
854 {
855 match value {
856 b"lender" => Ok(Field::Lender),
857 b"actionStatus" => Ok(Field::ActionStatus),
858 b"agent" => Ok(Field::Agent),
859 b"endTime" => Ok(Field::EndTime),
860 b"error" => Ok(Field::Error),
861 b"instrument" => Ok(Field::Instrument),
862 b"location" => Ok(Field::Location),
863 b"object" => Ok(Field::Object),
864 b"participant" => Ok(Field::Participant),
865 b"provider" => Ok(Field::Provider),
866 b"result" => Ok(Field::Result),
867 b"startTime" => Ok(Field::StartTime),
868 b"target" => Ok(Field::Target),
869 b"additionalType" => Ok(Field::AdditionalType),
870 b"alternateName" => Ok(Field::AlternateName),
871 b"description" => Ok(Field::Description),
872 b"disambiguatingDescription" => Ok(Field::DisambiguatingDescription),
873 b"identifier" => Ok(Field::Identifier),
874 b"image" => Ok(Field::Image),
875 b"mainEntityOfPage" => Ok(Field::MainEntityOfPage),
876 b"name" => Ok(Field::Name),
877 b"potentialAction" => Ok(Field::PotentialAction),
878 b"sameAs" => Ok(Field::SameAs),
879 b"subjectOf" => Ok(Field::SubjectOf),
880 b"url" => Ok(Field::Url),
881 b"fromLocation" => Ok(Field::FromLocation),
882 b"toLocation" => Ok(Field::ToLocation),
883 b"id" | b"type" => Ok(Field::Ignore),
884 _ => {
885 let value = &String::from_utf8_lossy(value);
886 Err(de::Error::unknown_field(value, FIELDS))
887 }
888 }
889 }
890 }
891 impl<'de> Deserialize<'de> for Field {
892 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
893 where
894 D: Deserializer<'de>,
895 {
896 deserializer.deserialize_identifier(FieldVisitor)
897 }
898 }
899 struct ClassVisitor;
900 impl<'de> Visitor<'de> for ClassVisitor {
901 type Value = BorrowAction;
902 fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
903 formatter.write_str("schema.org schema BorrowAction")
904 }
905 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
906 where
907 A: de::MapAccess<'de>,
908 {
909 let mut r#lender_property = None;
910 let mut r#action_status_property = None;
911 let mut r#agent_property = None;
912 let mut r#end_time_property = None;
913 let mut r#error_property = None;
914 let mut r#instrument_property = None;
915 let mut r#location_property = None;
916 let mut r#object_property = None;
917 let mut r#participant_property = None;
918 let mut r#provider_property = None;
919 let mut r#result_property = None;
920 let mut r#start_time_property = None;
921 let mut r#target_property = None;
922 let mut r#additional_type_property = None;
923 let mut r#alternate_name_property = None;
924 let mut r#description_property = None;
925 let mut r#disambiguating_description_property = None;
926 let mut r#identifier_property = None;
927 let mut r#image_property = None;
928 let mut r#main_entity_of_page_property = None;
929 let mut r#name_property = None;
930 let mut r#potential_action_property = None;
931 let mut r#same_as_property = None;
932 let mut r#subject_of_property = None;
933 let mut r#url_property = None;
934 let mut r#from_location_property = None;
935 let mut r#to_location_property = None;
936 while let Some(key) = map.next_key::<Field>()? {
937 match key {
938 Field::Lender => {
939 if r#lender_property.is_some() {
940 return Err(<A::Error as de::Error>::duplicate_field("lender"));
941 }
942 r#lender_property = Some({
943 struct DeserializeWith(Vec<LenderProperty>);
944 impl<'de> Deserialize<'de> for DeserializeWith {
945 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
946 where
947 D: Deserializer<'de>,
948 {
949 Ok(DeserializeWith(serde_with::As::<
950 serde_with::OneOrMany<serde_with::Same>,
951 >::deserialize(deserializer)?))
952 }
953 }
954 match map.next_value::<DeserializeWith>() {
955 Ok(deserialize_with) => deserialize_with.0,
956 Err(err) => {
957 return Err(err);
958 }
959 }
960 });
961 }
962 Field::ActionStatus => {
963 if r#action_status_property.is_some() {
964 return Err(<A::Error as de::Error>::duplicate_field(
965 "actionStatus",
966 ));
967 }
968 r#action_status_property = Some({
969 struct DeserializeWith(Vec<ActionStatusProperty>);
970 impl<'de> Deserialize<'de> for DeserializeWith {
971 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
972 where
973 D: Deserializer<'de>,
974 {
975 Ok(DeserializeWith(serde_with::As::<
976 serde_with::OneOrMany<serde_with::Same>,
977 >::deserialize(deserializer)?))
978 }
979 }
980 match map.next_value::<DeserializeWith>() {
981 Ok(deserialize_with) => deserialize_with.0,
982 Err(err) => {
983 return Err(err);
984 }
985 }
986 });
987 }
988 Field::Agent => {
989 if r#agent_property.is_some() {
990 return Err(<A::Error as de::Error>::duplicate_field("agent"));
991 }
992 r#agent_property = Some({
993 struct DeserializeWith(Vec<AgentProperty>);
994 impl<'de> Deserialize<'de> for DeserializeWith {
995 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
996 where
997 D: Deserializer<'de>,
998 {
999 Ok(DeserializeWith(serde_with::As::<
1000 serde_with::OneOrMany<serde_with::Same>,
1001 >::deserialize(deserializer)?))
1002 }
1003 }
1004 match map.next_value::<DeserializeWith>() {
1005 Ok(deserialize_with) => deserialize_with.0,
1006 Err(err) => {
1007 return Err(err);
1008 }
1009 }
1010 });
1011 }
1012 Field::EndTime => {
1013 if r#end_time_property.is_some() {
1014 return Err(<A::Error as de::Error>::duplicate_field(
1015 "endTime",
1016 ));
1017 }
1018 r#end_time_property = Some({
1019 struct DeserializeWith(Vec<EndTimeProperty>);
1020 impl<'de> Deserialize<'de> for DeserializeWith {
1021 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1022 where
1023 D: Deserializer<'de>,
1024 {
1025 Ok(DeserializeWith(serde_with::As::<
1026 serde_with::OneOrMany<serde_with::Same>,
1027 >::deserialize(deserializer)?))
1028 }
1029 }
1030 match map.next_value::<DeserializeWith>() {
1031 Ok(deserialize_with) => deserialize_with.0,
1032 Err(err) => {
1033 return Err(err);
1034 }
1035 }
1036 });
1037 }
1038 Field::Error => {
1039 if r#error_property.is_some() {
1040 return Err(<A::Error as de::Error>::duplicate_field("error"));
1041 }
1042 r#error_property = Some({
1043 struct DeserializeWith(Vec<ErrorProperty>);
1044 impl<'de> Deserialize<'de> for DeserializeWith {
1045 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1046 where
1047 D: Deserializer<'de>,
1048 {
1049 Ok(DeserializeWith(serde_with::As::<
1050 serde_with::OneOrMany<serde_with::Same>,
1051 >::deserialize(deserializer)?))
1052 }
1053 }
1054 match map.next_value::<DeserializeWith>() {
1055 Ok(deserialize_with) => deserialize_with.0,
1056 Err(err) => {
1057 return Err(err);
1058 }
1059 }
1060 });
1061 }
1062 Field::Instrument => {
1063 if r#instrument_property.is_some() {
1064 return Err(<A::Error as de::Error>::duplicate_field(
1065 "instrument",
1066 ));
1067 }
1068 r#instrument_property = Some({
1069 struct DeserializeWith(Vec<InstrumentProperty>);
1070 impl<'de> Deserialize<'de> for DeserializeWith {
1071 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1072 where
1073 D: Deserializer<'de>,
1074 {
1075 Ok(DeserializeWith(serde_with::As::<
1076 serde_with::OneOrMany<serde_with::Same>,
1077 >::deserialize(deserializer)?))
1078 }
1079 }
1080 match map.next_value::<DeserializeWith>() {
1081 Ok(deserialize_with) => deserialize_with.0,
1082 Err(err) => {
1083 return Err(err);
1084 }
1085 }
1086 });
1087 }
1088 Field::Location => {
1089 if r#location_property.is_some() {
1090 return Err(<A::Error as de::Error>::duplicate_field(
1091 "location",
1092 ));
1093 }
1094 r#location_property = Some({
1095 struct DeserializeWith(Vec<LocationProperty>);
1096 impl<'de> Deserialize<'de> for DeserializeWith {
1097 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1098 where
1099 D: Deserializer<'de>,
1100 {
1101 Ok(DeserializeWith(serde_with::As::<
1102 serde_with::OneOrMany<serde_with::Same>,
1103 >::deserialize(deserializer)?))
1104 }
1105 }
1106 match map.next_value::<DeserializeWith>() {
1107 Ok(deserialize_with) => deserialize_with.0,
1108 Err(err) => {
1109 return Err(err);
1110 }
1111 }
1112 });
1113 }
1114 Field::Object => {
1115 if r#object_property.is_some() {
1116 return Err(<A::Error as de::Error>::duplicate_field("object"));
1117 }
1118 r#object_property = Some({
1119 struct DeserializeWith(Vec<ObjectProperty>);
1120 impl<'de> Deserialize<'de> for DeserializeWith {
1121 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1122 where
1123 D: Deserializer<'de>,
1124 {
1125 Ok(DeserializeWith(serde_with::As::<
1126 serde_with::OneOrMany<serde_with::Same>,
1127 >::deserialize(deserializer)?))
1128 }
1129 }
1130 match map.next_value::<DeserializeWith>() {
1131 Ok(deserialize_with) => deserialize_with.0,
1132 Err(err) => {
1133 return Err(err);
1134 }
1135 }
1136 });
1137 }
1138 Field::Participant => {
1139 if r#participant_property.is_some() {
1140 return Err(<A::Error as de::Error>::duplicate_field(
1141 "participant",
1142 ));
1143 }
1144 r#participant_property = Some({
1145 struct DeserializeWith(Vec<ParticipantProperty>);
1146 impl<'de> Deserialize<'de> for DeserializeWith {
1147 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1148 where
1149 D: Deserializer<'de>,
1150 {
1151 Ok(DeserializeWith(serde_with::As::<
1152 serde_with::OneOrMany<serde_with::Same>,
1153 >::deserialize(deserializer)?))
1154 }
1155 }
1156 match map.next_value::<DeserializeWith>() {
1157 Ok(deserialize_with) => deserialize_with.0,
1158 Err(err) => {
1159 return Err(err);
1160 }
1161 }
1162 });
1163 }
1164 Field::Provider => {
1165 if r#provider_property.is_some() {
1166 return Err(<A::Error as de::Error>::duplicate_field(
1167 "provider",
1168 ));
1169 }
1170 r#provider_property = Some({
1171 struct DeserializeWith(Vec<ProviderProperty>);
1172 impl<'de> Deserialize<'de> for DeserializeWith {
1173 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1174 where
1175 D: Deserializer<'de>,
1176 {
1177 Ok(DeserializeWith(serde_with::As::<
1178 serde_with::OneOrMany<serde_with::Same>,
1179 >::deserialize(deserializer)?))
1180 }
1181 }
1182 match map.next_value::<DeserializeWith>() {
1183 Ok(deserialize_with) => deserialize_with.0,
1184 Err(err) => {
1185 return Err(err);
1186 }
1187 }
1188 });
1189 }
1190 Field::Result => {
1191 if r#result_property.is_some() {
1192 return Err(<A::Error as de::Error>::duplicate_field("result"));
1193 }
1194 r#result_property = Some({
1195 struct DeserializeWith(Vec<ResultProperty>);
1196 impl<'de> Deserialize<'de> for DeserializeWith {
1197 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1198 where
1199 D: Deserializer<'de>,
1200 {
1201 Ok(DeserializeWith(serde_with::As::<
1202 serde_with::OneOrMany<serde_with::Same>,
1203 >::deserialize(deserializer)?))
1204 }
1205 }
1206 match map.next_value::<DeserializeWith>() {
1207 Ok(deserialize_with) => deserialize_with.0,
1208 Err(err) => {
1209 return Err(err);
1210 }
1211 }
1212 });
1213 }
1214 Field::StartTime => {
1215 if r#start_time_property.is_some() {
1216 return Err(<A::Error as de::Error>::duplicate_field(
1217 "startTime",
1218 ));
1219 }
1220 r#start_time_property = Some({
1221 struct DeserializeWith(Vec<StartTimeProperty>);
1222 impl<'de> Deserialize<'de> for DeserializeWith {
1223 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1224 where
1225 D: Deserializer<'de>,
1226 {
1227 Ok(DeserializeWith(serde_with::As::<
1228 serde_with::OneOrMany<serde_with::Same>,
1229 >::deserialize(deserializer)?))
1230 }
1231 }
1232 match map.next_value::<DeserializeWith>() {
1233 Ok(deserialize_with) => deserialize_with.0,
1234 Err(err) => {
1235 return Err(err);
1236 }
1237 }
1238 });
1239 }
1240 Field::Target => {
1241 if r#target_property.is_some() {
1242 return Err(<A::Error as de::Error>::duplicate_field("target"));
1243 }
1244 r#target_property = Some({
1245 struct DeserializeWith(Vec<TargetProperty>);
1246 impl<'de> Deserialize<'de> for DeserializeWith {
1247 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1248 where
1249 D: Deserializer<'de>,
1250 {
1251 Ok(DeserializeWith(serde_with::As::<
1252 serde_with::OneOrMany<serde_with::Same>,
1253 >::deserialize(deserializer)?))
1254 }
1255 }
1256 match map.next_value::<DeserializeWith>() {
1257 Ok(deserialize_with) => deserialize_with.0,
1258 Err(err) => {
1259 return Err(err);
1260 }
1261 }
1262 });
1263 }
1264 Field::AdditionalType => {
1265 if r#additional_type_property.is_some() {
1266 return Err(<A::Error as de::Error>::duplicate_field(
1267 "additionalType",
1268 ));
1269 }
1270 r#additional_type_property = Some({
1271 struct DeserializeWith(Vec<AdditionalTypeProperty>);
1272 impl<'de> Deserialize<'de> for DeserializeWith {
1273 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1274 where
1275 D: Deserializer<'de>,
1276 {
1277 Ok(DeserializeWith(serde_with::As::<
1278 serde_with::OneOrMany<serde_with::Same>,
1279 >::deserialize(deserializer)?))
1280 }
1281 }
1282 match map.next_value::<DeserializeWith>() {
1283 Ok(deserialize_with) => deserialize_with.0,
1284 Err(err) => {
1285 return Err(err);
1286 }
1287 }
1288 });
1289 }
1290 Field::AlternateName => {
1291 if r#alternate_name_property.is_some() {
1292 return Err(<A::Error as de::Error>::duplicate_field(
1293 "alternateName",
1294 ));
1295 }
1296 r#alternate_name_property = Some({
1297 struct DeserializeWith(Vec<AlternateNameProperty>);
1298 impl<'de> Deserialize<'de> for DeserializeWith {
1299 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1300 where
1301 D: Deserializer<'de>,
1302 {
1303 Ok(DeserializeWith(serde_with::As::<
1304 serde_with::OneOrMany<serde_with::Same>,
1305 >::deserialize(deserializer)?))
1306 }
1307 }
1308 match map.next_value::<DeserializeWith>() {
1309 Ok(deserialize_with) => deserialize_with.0,
1310 Err(err) => {
1311 return Err(err);
1312 }
1313 }
1314 });
1315 }
1316 Field::Description => {
1317 if r#description_property.is_some() {
1318 return Err(<A::Error as de::Error>::duplicate_field(
1319 "description",
1320 ));
1321 }
1322 r#description_property = Some({
1323 struct DeserializeWith(Vec<DescriptionProperty>);
1324 impl<'de> Deserialize<'de> for DeserializeWith {
1325 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1326 where
1327 D: Deserializer<'de>,
1328 {
1329 Ok(DeserializeWith(serde_with::As::<
1330 serde_with::OneOrMany<serde_with::Same>,
1331 >::deserialize(deserializer)?))
1332 }
1333 }
1334 match map.next_value::<DeserializeWith>() {
1335 Ok(deserialize_with) => deserialize_with.0,
1336 Err(err) => {
1337 return Err(err);
1338 }
1339 }
1340 });
1341 }
1342 Field::DisambiguatingDescription => {
1343 if r#disambiguating_description_property.is_some() {
1344 return Err(<A::Error as de::Error>::duplicate_field(
1345 "disambiguatingDescription",
1346 ));
1347 }
1348 r#disambiguating_description_property = Some({
1349 struct DeserializeWith(Vec<DisambiguatingDescriptionProperty>);
1350 impl<'de> Deserialize<'de> for DeserializeWith {
1351 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1352 where
1353 D: Deserializer<'de>,
1354 {
1355 Ok(DeserializeWith(serde_with::As::<
1356 serde_with::OneOrMany<serde_with::Same>,
1357 >::deserialize(deserializer)?))
1358 }
1359 }
1360 match map.next_value::<DeserializeWith>() {
1361 Ok(deserialize_with) => deserialize_with.0,
1362 Err(err) => {
1363 return Err(err);
1364 }
1365 }
1366 });
1367 }
1368 Field::Identifier => {
1369 if r#identifier_property.is_some() {
1370 return Err(<A::Error as de::Error>::duplicate_field(
1371 "identifier",
1372 ));
1373 }
1374 r#identifier_property = Some({
1375 struct DeserializeWith(Vec<IdentifierProperty>);
1376 impl<'de> Deserialize<'de> for DeserializeWith {
1377 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1378 where
1379 D: Deserializer<'de>,
1380 {
1381 Ok(DeserializeWith(serde_with::As::<
1382 serde_with::OneOrMany<serde_with::Same>,
1383 >::deserialize(deserializer)?))
1384 }
1385 }
1386 match map.next_value::<DeserializeWith>() {
1387 Ok(deserialize_with) => deserialize_with.0,
1388 Err(err) => {
1389 return Err(err);
1390 }
1391 }
1392 });
1393 }
1394 Field::Image => {
1395 if r#image_property.is_some() {
1396 return Err(<A::Error as de::Error>::duplicate_field("image"));
1397 }
1398 r#image_property = Some({
1399 struct DeserializeWith(Vec<ImageProperty>);
1400 impl<'de> Deserialize<'de> for DeserializeWith {
1401 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1402 where
1403 D: Deserializer<'de>,
1404 {
1405 Ok(DeserializeWith(serde_with::As::<
1406 serde_with::OneOrMany<serde_with::Same>,
1407 >::deserialize(deserializer)?))
1408 }
1409 }
1410 match map.next_value::<DeserializeWith>() {
1411 Ok(deserialize_with) => deserialize_with.0,
1412 Err(err) => {
1413 return Err(err);
1414 }
1415 }
1416 });
1417 }
1418 Field::MainEntityOfPage => {
1419 if r#main_entity_of_page_property.is_some() {
1420 return Err(<A::Error as de::Error>::duplicate_field(
1421 "mainEntityOfPage",
1422 ));
1423 }
1424 r#main_entity_of_page_property = Some({
1425 struct DeserializeWith(Vec<MainEntityOfPageProperty>);
1426 impl<'de> Deserialize<'de> for DeserializeWith {
1427 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1428 where
1429 D: Deserializer<'de>,
1430 {
1431 Ok(DeserializeWith(serde_with::As::<
1432 serde_with::OneOrMany<serde_with::Same>,
1433 >::deserialize(deserializer)?))
1434 }
1435 }
1436 match map.next_value::<DeserializeWith>() {
1437 Ok(deserialize_with) => deserialize_with.0,
1438 Err(err) => {
1439 return Err(err);
1440 }
1441 }
1442 });
1443 }
1444 Field::Name => {
1445 if r#name_property.is_some() {
1446 return Err(<A::Error as de::Error>::duplicate_field("name"));
1447 }
1448 r#name_property = Some({
1449 struct DeserializeWith(Vec<NameProperty>);
1450 impl<'de> Deserialize<'de> for DeserializeWith {
1451 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1452 where
1453 D: Deserializer<'de>,
1454 {
1455 Ok(DeserializeWith(serde_with::As::<
1456 serde_with::OneOrMany<serde_with::Same>,
1457 >::deserialize(deserializer)?))
1458 }
1459 }
1460 match map.next_value::<DeserializeWith>() {
1461 Ok(deserialize_with) => deserialize_with.0,
1462 Err(err) => {
1463 return Err(err);
1464 }
1465 }
1466 });
1467 }
1468 Field::PotentialAction => {
1469 if r#potential_action_property.is_some() {
1470 return Err(<A::Error as de::Error>::duplicate_field(
1471 "potentialAction",
1472 ));
1473 }
1474 r#potential_action_property = Some({
1475 struct DeserializeWith(Vec<PotentialActionProperty>);
1476 impl<'de> Deserialize<'de> for DeserializeWith {
1477 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1478 where
1479 D: Deserializer<'de>,
1480 {
1481 Ok(DeserializeWith(serde_with::As::<
1482 serde_with::OneOrMany<serde_with::Same>,
1483 >::deserialize(deserializer)?))
1484 }
1485 }
1486 match map.next_value::<DeserializeWith>() {
1487 Ok(deserialize_with) => deserialize_with.0,
1488 Err(err) => {
1489 return Err(err);
1490 }
1491 }
1492 });
1493 }
1494 Field::SameAs => {
1495 if r#same_as_property.is_some() {
1496 return Err(<A::Error as de::Error>::duplicate_field("sameAs"));
1497 }
1498 r#same_as_property = Some({
1499 struct DeserializeWith(Vec<SameAsProperty>);
1500 impl<'de> Deserialize<'de> for DeserializeWith {
1501 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1502 where
1503 D: Deserializer<'de>,
1504 {
1505 Ok(DeserializeWith(serde_with::As::<
1506 serde_with::OneOrMany<serde_with::Same>,
1507 >::deserialize(deserializer)?))
1508 }
1509 }
1510 match map.next_value::<DeserializeWith>() {
1511 Ok(deserialize_with) => deserialize_with.0,
1512 Err(err) => {
1513 return Err(err);
1514 }
1515 }
1516 });
1517 }
1518 Field::SubjectOf => {
1519 if r#subject_of_property.is_some() {
1520 return Err(<A::Error as de::Error>::duplicate_field(
1521 "subjectOf",
1522 ));
1523 }
1524 r#subject_of_property = Some({
1525 struct DeserializeWith(Vec<SubjectOfProperty>);
1526 impl<'de> Deserialize<'de> for DeserializeWith {
1527 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1528 where
1529 D: Deserializer<'de>,
1530 {
1531 Ok(DeserializeWith(serde_with::As::<
1532 serde_with::OneOrMany<serde_with::Same>,
1533 >::deserialize(deserializer)?))
1534 }
1535 }
1536 match map.next_value::<DeserializeWith>() {
1537 Ok(deserialize_with) => deserialize_with.0,
1538 Err(err) => {
1539 return Err(err);
1540 }
1541 }
1542 });
1543 }
1544 Field::Url => {
1545 if r#url_property.is_some() {
1546 return Err(<A::Error as de::Error>::duplicate_field("url"));
1547 }
1548 r#url_property = Some({
1549 struct DeserializeWith(Vec<UrlProperty>);
1550 impl<'de> Deserialize<'de> for DeserializeWith {
1551 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1552 where
1553 D: Deserializer<'de>,
1554 {
1555 Ok(DeserializeWith(serde_with::As::<
1556 serde_with::OneOrMany<serde_with::Same>,
1557 >::deserialize(deserializer)?))
1558 }
1559 }
1560 match map.next_value::<DeserializeWith>() {
1561 Ok(deserialize_with) => deserialize_with.0,
1562 Err(err) => {
1563 return Err(err);
1564 }
1565 }
1566 });
1567 }
1568 Field::FromLocation => {
1569 if r#from_location_property.is_some() {
1570 return Err(<A::Error as de::Error>::duplicate_field(
1571 "fromLocation",
1572 ));
1573 }
1574 r#from_location_property = Some({
1575 struct DeserializeWith(Vec<FromLocationProperty>);
1576 impl<'de> Deserialize<'de> for DeserializeWith {
1577 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1578 where
1579 D: Deserializer<'de>,
1580 {
1581 Ok(DeserializeWith(serde_with::As::<
1582 serde_with::OneOrMany<serde_with::Same>,
1583 >::deserialize(deserializer)?))
1584 }
1585 }
1586 match map.next_value::<DeserializeWith>() {
1587 Ok(deserialize_with) => deserialize_with.0,
1588 Err(err) => {
1589 return Err(err);
1590 }
1591 }
1592 });
1593 }
1594 Field::ToLocation => {
1595 if r#to_location_property.is_some() {
1596 return Err(<A::Error as de::Error>::duplicate_field(
1597 "toLocation",
1598 ));
1599 }
1600 r#to_location_property = Some({
1601 struct DeserializeWith(Vec<ToLocationProperty>);
1602 impl<'de> Deserialize<'de> for DeserializeWith {
1603 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1604 where
1605 D: Deserializer<'de>,
1606 {
1607 Ok(DeserializeWith(serde_with::As::<
1608 serde_with::OneOrMany<serde_with::Same>,
1609 >::deserialize(deserializer)?))
1610 }
1611 }
1612 match map.next_value::<DeserializeWith>() {
1613 Ok(deserialize_with) => deserialize_with.0,
1614 Err(err) => {
1615 return Err(err);
1616 }
1617 }
1618 });
1619 }
1620 Field::Ignore => {
1621 let _ = map.next_value::<de::IgnoredAny>()?;
1622 }
1623 }
1624 }
1625 Ok(BorrowAction {
1626 r#lender: r#lender_property.unwrap_or_default(),
1627 r#action_status: r#action_status_property.unwrap_or_default(),
1628 r#agent: r#agent_property.unwrap_or_default(),
1629 r#end_time: r#end_time_property.unwrap_or_default(),
1630 r#error: r#error_property.unwrap_or_default(),
1631 r#instrument: r#instrument_property.unwrap_or_default(),
1632 r#location: r#location_property.unwrap_or_default(),
1633 r#object: r#object_property.unwrap_or_default(),
1634 r#participant: r#participant_property.unwrap_or_default(),
1635 r#provider: r#provider_property.unwrap_or_default(),
1636 r#result: r#result_property.unwrap_or_default(),
1637 r#start_time: r#start_time_property.unwrap_or_default(),
1638 r#target: r#target_property.unwrap_or_default(),
1639 r#additional_type: r#additional_type_property.unwrap_or_default(),
1640 r#alternate_name: r#alternate_name_property.unwrap_or_default(),
1641 r#description: r#description_property.unwrap_or_default(),
1642 r#disambiguating_description: r#disambiguating_description_property
1643 .unwrap_or_default(),
1644 r#identifier: r#identifier_property.unwrap_or_default(),
1645 r#image: r#image_property.unwrap_or_default(),
1646 r#main_entity_of_page: r#main_entity_of_page_property.unwrap_or_default(),
1647 r#name: r#name_property.unwrap_or_default(),
1648 r#potential_action: r#potential_action_property.unwrap_or_default(),
1649 r#same_as: r#same_as_property.unwrap_or_default(),
1650 r#subject_of: r#subject_of_property.unwrap_or_default(),
1651 r#url: r#url_property.unwrap_or_default(),
1652 r#from_location: r#from_location_property.unwrap_or_default(),
1653 r#to_location: r#to_location_property.unwrap_or_default(),
1654 })
1655 }
1656 }
1657 const FIELDS: &[&str] = &[
1658 "lender",
1659 "actionStatus",
1660 "agent",
1661 "endTime",
1662 "error",
1663 "instrument",
1664 "location",
1665 "object",
1666 "participant",
1667 "provider",
1668 "result",
1669 "startTime",
1670 "target",
1671 "additionalType",
1672 "alternateName",
1673 "description",
1674 "disambiguatingDescription",
1675 "identifier",
1676 "image",
1677 "mainEntityOfPage",
1678 "name",
1679 "potentialAction",
1680 "sameAs",
1681 "subjectOf",
1682 "url",
1683 "fromLocation",
1684 "toLocation",
1685 ];
1686 deserializer.deserialize_struct("BorrowAction", FIELDS, ClassVisitor)
1687 }
1688 }
1689}