1pub trait Input {
2 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference;
3}
4
5pub trait Output {
6 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference;
7}
8
9pub(crate) fn reflectapi_type_empty(
10 schema: &mut crate::Typespace,
11 type_name: &str,
12 description: &str,
13) -> crate::TypeReference {
14 if schema.reserve_type(type_name) {
15 let mut type_def = crate::Struct::new(type_name);
16 type_def.description = description.into();
17 schema.insert_type(type_def.into());
18 }
19 crate::TypeReference::new(type_name, Vec::new())
20}
21
22pub(crate) fn reflectapi_type_simple(
23 schema: &mut crate::Typespace,
24 type_name: &str,
25 description: &str,
26 fallback: Option<crate::TypeReference>,
27) -> crate::TypeReference {
28 if schema.reserve_type(type_name) {
29 let mut type_def =
30 crate::Primitive::new(type_name.into(), description.into(), Vec::new(), None);
31 type_def.fallback = fallback;
32 schema.insert_type(type_def.into());
33 }
34 crate::TypeReference::new(type_name, Vec::new())
35}
36
37impl Output for &'static str {
38 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
39 reflectapi_type_simple(schema, "std::string::String", "UTF-8 encoded string", None)
40 }
41}
42
43macro_rules! impl_reflectapi_simple {
44 ($type:ty, $description:tt) => {
45 impl Input for $type {
46 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
47 reflectapi_type_simple(schema, stringify!($type), $description, None)
48 }
49 }
50 impl Output for $type {
51 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
52 reflectapi_type_simple(schema, stringify!($type), $description, None)
53 }
54 }
55 };
56}
57impl_reflectapi_simple!(i8, "8-bit signed integer");
58impl_reflectapi_simple!(i16, "16-bit signed integer");
59impl_reflectapi_simple!(i32, "32-bit signed integer");
60impl_reflectapi_simple!(i64, "64-bit signed integer");
61impl_reflectapi_simple!(i128, "128-bit signed integer");
62impl_reflectapi_simple!(u8, "8-bit unsigned integer");
63impl_reflectapi_simple!(u16, "16-bit unsigned integer");
64impl_reflectapi_simple!(u32, "32-bit unsigned integer");
65impl_reflectapi_simple!(u64, "64-bit unsigned integer");
66impl_reflectapi_simple!(u128, "128-bit unsigned integer");
67impl_reflectapi_simple!(f32, "32-bit floating point number");
68impl_reflectapi_simple!(f64, "64-bit floating point number");
69impl_reflectapi_simple!(bool, "Boolean value");
70impl_reflectapi_simple!(char, "Unicode character");
71impl_reflectapi_simple!(std::string::String, "UTF-8 encoded string");
72
73macro_rules! impl_reflectapi_simple_with_fallback {
74 ($type:ty, $description:tt, $fallback:expr) => {
75 impl Input for $type {
76 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
77 reflectapi_type_simple(schema, stringify!($type), $description, $fallback)
78 }
79 }
80 impl Output for $type {
81 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
82 reflectapi_type_simple(schema, stringify!($type), $description, $fallback)
83 }
84 }
85 };
86}
87
88impl_reflectapi_simple_with_fallback!(
89 std::num::NonZeroU8,
90 "8-bit non-zero unsigned integer",
91 Some("u8".into())
92);
93impl_reflectapi_simple_with_fallback!(
94 std::num::NonZeroU16,
95 "16-bit non-zero unsigned integer",
96 Some("u16".into())
97);
98impl_reflectapi_simple_with_fallback!(
99 std::num::NonZeroU32,
100 "32-bit non-zero unsigned integer",
101 Some("u32".into())
102);
103impl_reflectapi_simple_with_fallback!(
104 std::num::NonZeroU64,
105 "64-bit non-zero unsigned integer",
106 Some("u64".into())
107);
108impl_reflectapi_simple_with_fallback!(
109 std::num::NonZeroU128,
110 "128-bit non-zero unsigned integer",
111 Some("u128".into())
112);
113
114impl Input for isize {
115 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
116 let fallback = Some(i64::reflectapi_input_type(schema));
117 reflectapi_type_simple(
118 schema,
119 "isize",
120 "Machine-specific-bit signed integer",
121 fallback,
122 )
123 }
124}
125impl Output for isize {
126 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
127 let fallback = Some(i64::reflectapi_output_type(schema));
128 reflectapi_type_simple(
129 schema,
130 "isize",
131 "Machine-specific-bit signed integer",
132 fallback,
133 )
134 }
135}
136
137impl Input for usize {
138 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
139 let fallback = Some(u64::reflectapi_input_type(schema));
140 reflectapi_type_simple(
141 schema,
142 "usize",
143 "Machine-specific-bit unsigned integer",
144 fallback,
145 )
146 }
147}
148impl Output for usize {
149 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
150 let fallback = Some(u64::reflectapi_output_type(schema));
151 reflectapi_type_simple(
152 schema,
153 "usize",
154 "Machine-specific-bit unsigned integer",
155 fallback,
156 )
157 }
158}
159
160fn reflectapi_type_vector(schema: &mut crate::Typespace) -> String {
161 let type_name = "std::vec::Vec";
162 if schema.reserve_type(type_name) {
163 let type_def = crate::Primitive::new(
164 type_name.into(),
165 "Expandable array type".into(),
166 vec!["T".into()],
167 None,
168 );
169 schema.insert_type(type_def.into());
170 }
171 type_name.into()
172}
173impl<T: Input> Input for Vec<T> {
174 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
175 crate::TypeReference::new(
176 reflectapi_type_vector(schema),
177 vec![T::reflectapi_input_type(schema)],
178 )
179 }
180}
181impl<T: Output> Output for Vec<T> {
182 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
183 crate::TypeReference::new(
184 reflectapi_type_vector(schema),
185 vec![T::reflectapi_output_type(schema)],
186 )
187 }
188}
189
190fn reflectapi_type_option(schema: &mut crate::Typespace) -> String {
191 let type_name = "std::option::Option";
192 if schema.reserve_type(type_name) {
193 let mut type_def = crate::Enum::new(type_name.into());
194 type_def.parameters.push("T".into());
195 type_def.description = "Optional nullable type".into();
196 type_def.representation = crate::Representation::None;
197
198 let mut variant = crate::Variant::new("None".into());
199 variant.description = "The value is not provided, i.e. null".into();
200 type_def.variants.push(variant);
201
202 let mut variant = crate::Variant::new("Some".into());
203 variant.description = "The value is provided and set to some value".into();
204 variant.fields = crate::Fields::Unnamed(vec![crate::Field::new("0".into(), "T".into())]);
205 type_def.variants.push(variant);
206
207 schema.insert_type(type_def.into());
208 }
209 type_name.into()
210}
211impl<T: Input> Input for Option<T> {
212 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
213 crate::TypeReference::new(
214 reflectapi_type_option(schema),
215 vec![T::reflectapi_input_type(schema)],
216 )
217 }
218}
219impl<T: Output> Output for Option<T> {
220 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
221 crate::TypeReference::new(
222 reflectapi_type_option(schema),
223 vec![T::reflectapi_output_type(schema)],
224 )
225 }
226}
227
228fn reflectapi_type_btreemap(schema: &mut crate::Typespace) -> String {
229 let type_name = "std::collections::BTreeMap";
230 if schema.reserve_type(type_name) {
231 let type_def = crate::Primitive::new(
232 type_name.into(),
233 "Ordered key-value map type".into(),
234 vec!["K".into(), "V".into()],
235 Some(crate::TypeReference::new(
236 reflectapi_type_hashmap(schema),
237 vec!["K".into(), "V".into()],
238 )),
239 );
240 schema.insert_type(type_def.into());
241 }
242 type_name.into()
243}
244
245impl<K: Input, V: Input> Input for std::collections::BTreeMap<K, V> {
246 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
247 crate::TypeReference::new(
248 reflectapi_type_btreemap(schema),
249 vec![
250 K::reflectapi_input_type(schema),
251 V::reflectapi_input_type(schema),
252 ],
253 )
254 }
255}
256
257impl<K: Output, V: Output> Output for std::collections::BTreeMap<K, V> {
258 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
259 crate::TypeReference::new(
260 reflectapi_type_btreemap(schema),
261 vec![
262 K::reflectapi_output_type(schema),
263 V::reflectapi_output_type(schema),
264 ],
265 )
266 }
267}
268
269pub(super) fn reflectapi_type_hashmap(schema: &mut crate::Typespace) -> String {
270 let type_name = "std::collections::HashMap";
271 if schema.reserve_type(type_name) {
272 let type_def = crate::Primitive::new(
273 type_name.into(),
274 "Key-value map type".into(),
275 vec!["K".into(), "V".into()],
276 None,
277 );
278 schema.insert_type(type_def.into());
279 }
280 type_name.into()
281}
282
283impl<K: Input, V: Input> Input for std::collections::HashMap<K, V> {
284 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
285 crate::TypeReference::new(
286 reflectapi_type_hashmap(schema),
287 vec![
288 K::reflectapi_input_type(schema),
289 V::reflectapi_input_type(schema),
290 ],
291 )
292 }
293}
294impl<K: Output, V: Output> Output for std::collections::HashMap<K, V> {
295 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
296 crate::TypeReference::new(
297 reflectapi_type_hashmap(schema),
298 vec![
299 K::reflectapi_output_type(schema),
300 V::reflectapi_output_type(schema),
301 ],
302 )
303 }
304}
305
306pub(crate) fn reflectapi_type_hashset(schema: &mut crate::Typespace) -> String {
307 let type_name = "std::collections::HashSet";
308 if schema.reserve_type(type_name) {
309 let type_def = crate::Primitive::new(
310 type_name.into(),
311 "Value set type".into(),
312 vec!["V".into()],
313 Some(crate::TypeReference::new(
314 reflectapi_type_vector(schema),
315 vec!["V".into()],
316 )),
317 );
318 schema.insert_type(type_def.into());
319 }
320 type_name.into()
321}
322impl<V: Input> Input for std::collections::HashSet<V> {
323 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
324 crate::TypeReference::new(
325 reflectapi_type_hashset(schema),
326 vec![V::reflectapi_input_type(schema)],
327 )
328 }
329}
330impl<V: Output> Output for std::collections::HashSet<V> {
331 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
332 crate::TypeReference::new(
333 reflectapi_type_hashset(schema),
334 vec![V::reflectapi_output_type(schema)],
335 )
336 }
337}
338
339fn reflectapi_type_btreeset(schema: &mut crate::Typespace) -> String {
340 let type_name = "std::collections::BTreeSet";
341 if schema.reserve_type(type_name) {
342 let type_def = crate::Primitive::new(
343 type_name.into(),
344 "Ordered set type".into(),
345 vec!["V".into()],
346 Some(crate::TypeReference::new(
347 reflectapi_type_hashset(schema),
348 vec!["V".into()],
349 )),
350 );
351 schema.insert_type(type_def.into());
352 }
353 type_name.into()
354}
355
356impl<V: Input> Input for std::collections::BTreeSet<V> {
357 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
358 crate::TypeReference::new(
359 reflectapi_type_btreeset(schema),
360 vec![V::reflectapi_input_type(schema)],
361 )
362 }
363}
364
365impl<V: Output> Output for std::collections::BTreeSet<V> {
366 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
367 crate::TypeReference::new(
368 reflectapi_type_btreeset(schema),
369 vec![V::reflectapi_output_type(schema)],
370 )
371 }
372}
373
374fn reflectapi_type_tuple(schema: &mut crate::Typespace, count: usize) -> String {
375 let type_name = format!("std::tuple::Tuple{}", count);
376 if schema.reserve_type(&type_name) {
377 let parameters = (1..(count + 1)).map(|i| format!("T{}", i).into()).collect();
378 let type_def = crate::Primitive::new(
379 type_name.clone(),
380 format!("Tuple holding {} elements", count),
381 parameters,
382 None,
383 );
384 schema.insert_type(type_def.into());
385 }
386 type_name
387}
388macro_rules! count {
389 () => (0usize);
390 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));
391}
392macro_rules! impl_reflectapi_tuple {
393 ( $( $name:ident )+) => {
394 impl<$($name: Input),+> Input for ($($name,)+)
395 {
396 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
397 let type_name = reflectapi_type_tuple(schema, count!($($name)*));
398 crate::TypeReference::new(
399 type_name,
400 vec![$($name::reflectapi_input_type(schema)),+],
401 )
402 }
403 }
404
405 impl<$($name: Output),+> Output for ($($name,)+)
406 {
407 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
408 let type_name = reflectapi_type_tuple(schema, count!($($name)*));
409 crate::TypeReference::new(
410 type_name,
411 vec![$($name::reflectapi_output_type(schema)),+],
412 )
413 }
414 }
415 };
416}
417
418impl_reflectapi_tuple! { A }
419impl_reflectapi_tuple! { A B }
420impl_reflectapi_tuple! { A B C }
421impl_reflectapi_tuple! { A B C D }
422impl_reflectapi_tuple! { A B C D E }
423impl_reflectapi_tuple! { A B C D E F }
424impl_reflectapi_tuple! { A B C D E F G }
425impl_reflectapi_tuple! { A B C D E F G H }
426impl_reflectapi_tuple! { A B C D E F G H I }
427impl_reflectapi_tuple! { A B C D E F G H I J }
428impl_reflectapi_tuple! { A B C D E F G H I J K }
429impl_reflectapi_tuple! { A B C D E F G H I J K L }
430
431fn reflectapi_type_array(schema: &mut crate::Typespace) -> String {
432 let type_name = "std::array::Array";
433 if schema.reserve_type(type_name) {
434 let type_def = crate::Primitive::new(
435 type_name.into(),
436 "Fixed-size Array".to_string(),
437 vec!["T".into(), "N".to_string().into()],
438 Some(crate::TypeReference::new(
439 reflectapi_type_vector(schema),
440 vec!["T".into()],
441 )),
442 );
443 schema.insert_type(type_def.into());
444 }
445 type_name.into()
446}
447impl<T: Input, const N: usize> Input for [T; N] {
448 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
449 crate::TypeReference::new(
450 reflectapi_type_array(schema),
451 vec![T::reflectapi_input_type(schema), N.to_string().into()],
452 )
453 }
454}
455impl<T: Output, const N: usize> Output for [T; N] {
456 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
457 crate::TypeReference::new(
458 reflectapi_type_array(schema),
459 vec![T::reflectapi_output_type(schema), N.to_string().into()],
460 )
461 }
462}
463
464fn reflectapi_type_pointer(
465 schema: &mut crate::Typespace,
466 type_name: &str,
467 with_lifetime: bool,
468) -> String {
469 if schema.reserve_type(type_name) {
470 let mut type_def = crate::Primitive::new(
471 type_name.into(),
472 format!("{type_name} pointer type"),
473 vec!["T".into()],
474 Some("T".into()),
475 );
476 if with_lifetime {
477 type_def.parameters.insert(0, "'a".into());
478 }
479 schema.insert_type(type_def.into());
480 }
481 type_name.into()
482}
483macro_rules! impl_reflectapi_pointer {
484 ($type:path) => {
485 impl<T: Input> Input for $type {
486 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
487 crate::TypeReference::new(
488 reflectapi_type_pointer(schema, &stringify!($type).replace("<T>", ""), false),
489 vec![T::reflectapi_input_type(schema)],
490 )
491 }
492 }
493 impl<T: Output> Output for $type {
494 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
495 crate::TypeReference::new(
496 reflectapi_type_pointer(schema, &stringify!($type).replace("<T>", ""), false),
497 vec![T::reflectapi_output_type(schema)],
498 )
499 }
500 }
501 };
502}
503
504impl_reflectapi_pointer!(std::boxed::Box<T>);
505impl_reflectapi_pointer!(std::rc::Rc<T>);
506impl_reflectapi_pointer!(std::sync::Arc<T>);
507impl_reflectapi_pointer!(std::cell::Cell<T>);
508impl_reflectapi_pointer!(std::cell::RefCell<T>);
509impl_reflectapi_pointer!(std::sync::Mutex<T>);
510impl_reflectapi_pointer!(std::sync::RwLock<T>);
511impl_reflectapi_pointer!(std::sync::Weak<T>);
512
513macro_rules! impl_reflectapi_pointer_with_lifetime {
514 ($type:path) => {
515 impl<'a, T: Input> Input for $type {
516 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
517 crate::TypeReference::new(
518 reflectapi_type_pointer(
519 schema,
520 &stringify!($type).replace("<'a, T>", ""),
521 true,
522 ),
523 vec![T::reflectapi_input_type(schema)],
524 )
525 }
526 }
527 impl<'a, T: Output> Output for $type {
528 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
529 crate::TypeReference::new(
530 reflectapi_type_pointer(
531 schema,
532 &stringify!($type).replace("<'a, T>", ""),
533 true,
534 ),
535 vec![T::reflectapi_output_type(schema)],
536 )
537 }
538 }
539 };
540}
541impl_reflectapi_pointer_with_lifetime!(std::cell::Ref<'a, T>);
542impl_reflectapi_pointer_with_lifetime!(std::cell::RefMut<'a, T>);
543impl_reflectapi_pointer_with_lifetime!(std::sync::MutexGuard<'a, T>);
544impl_reflectapi_pointer_with_lifetime!(std::sync::RwLockReadGuard<'a, T>);
545impl_reflectapi_pointer_with_lifetime!(std::sync::RwLockWriteGuard<'a, T>);
546
547impl<T: Input> Input for *const T {
548 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
549 crate::TypeReference::new(
550 reflectapi_type_pointer(schema, "*const", false),
551 vec![T::reflectapi_input_type(schema)],
552 )
553 }
554}
555impl<T: Output> Output for *const T {
556 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
557 crate::TypeReference::new(
558 reflectapi_type_pointer(schema, "*const", false),
559 vec![T::reflectapi_output_type(schema)],
560 )
561 }
562}
563impl<T: Input> Input for *mut T {
564 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
565 crate::TypeReference::new(
566 reflectapi_type_pointer(schema, "*mut", false),
567 vec![T::reflectapi_input_type(schema)],
568 )
569 }
570}
571impl<T: Output> Output for *mut T {
572 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
573 crate::TypeReference::new(
574 reflectapi_type_pointer(schema, "*mut", false),
575 vec![T::reflectapi_output_type(schema)],
576 )
577 }
578}
579impl<'a, T: Input + Clone> Input for std::borrow::Cow<'a, T> {
580 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
581 crate::TypeReference::new(
582 reflectapi_type_pointer(schema, "std::borrow::Cow", true),
583 vec![T::reflectapi_input_type(schema)],
584 )
585 }
586}
587impl<'a, T: Output + Clone> Output for std::borrow::Cow<'a, T> {
588 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
589 crate::TypeReference::new(
590 reflectapi_type_pointer(schema, "std::borrow::Cow", true),
591 vec![T::reflectapi_output_type(schema)],
592 )
593 }
594}
595
596fn reflectapi_type_phantom_data(schema: &mut crate::Typespace) -> String {
597 let type_name = "std::marker::PhantomData";
598 if schema.reserve_type(type_name) {
599 let type_def = crate::Primitive::new(
600 type_name.into(),
601 "Zero-sized phantom data".to_string(),
602 vec!["T".into()],
603 None,
604 );
605 schema.insert_type(type_def.into());
606 }
607 type_name.into()
608}
609impl<T: Input> Input for std::marker::PhantomData<T> {
610 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
611 crate::TypeReference::new(
612 reflectapi_type_phantom_data(schema),
613 vec![T::reflectapi_input_type(schema)],
614 )
615 }
616}
617impl<T: Output> Output for std::marker::PhantomData<T> {
618 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
619 crate::TypeReference::new(
620 reflectapi_type_phantom_data(schema),
621 vec![T::reflectapi_output_type(schema)],
622 )
623 }
624}
625
626impl Input for std::convert::Infallible {
627 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
628 crate::infallible::Infallible::reflectapi_input_type(schema)
630 }
631}
632impl Output for std::convert::Infallible {
633 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
634 crate::infallible::Infallible::reflectapi_output_type(schema)
636 }
637}
638
639impl Input for () {
640 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
641 reflectapi_type_simple(schema, "std::tuple::Tuple0", "Unit type", None)
642 }
643}
644
645impl Output for () {
646 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
647 reflectapi_type_simple(schema, "std::tuple::Tuple0", "Unit type", None)
648 }
649}
650
651fn reflectapi_duration(schema: &mut crate::Typespace) -> crate::TypeReference {
652 let type_name = "std::time::Duration";
653 if schema.reserve_type(type_name) {
654 let type_def = crate::Struct {
655 name: type_name.into(),
656 description: "Time duration type".into(),
657 fields: crate::Fields::Named(vec![
658 crate::Field::new("secs".into(), "u64".into()).with_required(true),
659 crate::Field::new("nanos".into(), "u32".into()).with_required(true),
660 ]),
661 serde_name: Default::default(),
662 parameters: Default::default(),
663 transparent: Default::default(),
664 codegen_config: Default::default(),
665 };
666
667 schema.insert_type(type_def.into());
668 }
669
670 crate::TypeReference::new(type_name, Vec::new())
671}
672impl Input for std::time::Duration {
673 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
674 u64::reflectapi_input_type(schema);
675 u32::reflectapi_input_type(schema);
676 reflectapi_duration(schema)
677 }
678}
679impl Output for std::time::Duration {
680 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
681 u64::reflectapi_output_type(schema);
682 u32::reflectapi_output_type(schema);
683 reflectapi_duration(schema)
684 }
685}
686
687impl Input for std::path::PathBuf {
688 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
689 reflectapi_type_simple(
690 schema,
691 "std::path::PathBuf",
692 "File path type",
693 Some("std::string::String".into()),
694 )
695 }
696}
697impl Output for std::path::PathBuf {
698 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
699 reflectapi_type_simple(
700 schema,
701 "std::path::PathBuf",
702 "File path type",
703 Some("std::string::String".into()),
704 )
705 }
706}
707
708impl Input for std::path::Path {
709 fn reflectapi_input_type(schema: &mut crate::Typespace) -> crate::TypeReference {
710 reflectapi_type_simple(
711 schema,
712 "std::path::Path",
713 "File path type",
714 Some("std::path::PathBuf".into()),
715 )
716 }
717}
718impl Output for std::path::Path {
719 fn reflectapi_output_type(schema: &mut crate::Typespace) -> crate::TypeReference {
720 reflectapi_type_simple(
721 schema,
722 "std::path::Path",
723 "File path type",
724 Some("std::path::PathBuf".into()),
725 )
726 }
727}