1pub mod asset_uuid {
6 #[derive(Copy, Clone)]
7 pub struct Owned(());
8 impl<'a> ::capnp::traits::Owned<'a> for Owned {
9 type Builder = Builder<'a>;
10 type Reader = Reader<'a>;
11 }
12 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
13 type Builder = Builder<'a>;
14 type Reader = Reader<'a>;
15 }
16 impl ::capnp::traits::Pipelined for Owned {
17 type Pipeline = Pipeline;
18 }
19
20 #[derive(Clone, Copy)]
21 pub struct Reader<'a> {
22 reader: ::capnp::private::layout::StructReader<'a>,
23 }
24
25 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
26 #[inline]
27 fn type_id() -> u64 {
28 _private::TYPE_ID
29 }
30 }
31 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
32 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
33 Reader { reader }
34 }
35 }
36
37 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
38 fn get_from_pointer(
39 reader: &::capnp::private::layout::PointerReader<'a>,
40 default: ::core::option::Option<&'a [capnp::Word]>,
41 ) -> ::capnp::Result<Reader<'a>> {
42 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
43 reader.get_struct(default)?,
44 ))
45 }
46 }
47
48 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
49 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
50 self.reader
51 }
52 }
53
54 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
55 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
56 self.reader
57 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
58 }
59 }
60
61 impl<'a> Reader<'a> {
62 pub fn reborrow(&self) -> Reader<'_> {
63 Reader { ..*self }
64 }
65
66 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
67 self.reader.total_size()
68 }
69
70 #[inline]
71 pub fn get_id(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
72 ::capnp::traits::FromPointerReader::get_from_pointer(
73 &self.reader.get_pointer_field(0),
74 ::core::option::Option::None,
75 )
76 }
77
78 pub fn has_id(&self) -> bool {
79 !self.reader.get_pointer_field(0).is_null()
80 }
81 }
82
83 pub struct Builder<'a> {
84 builder: ::capnp::private::layout::StructBuilder<'a>,
85 }
86 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
87 #[inline]
88 fn struct_size() -> ::capnp::private::layout::StructSize {
89 _private::STRUCT_SIZE
90 }
91 }
92 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
93 #[inline]
94 fn type_id() -> u64 {
95 _private::TYPE_ID
96 }
97 }
98 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
99 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
100 Builder { builder }
101 }
102 }
103
104 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
105 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
106 self.builder
107 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
108 }
109 }
110
111 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
112 fn init_pointer(
113 builder: ::capnp::private::layout::PointerBuilder<'a>,
114 _size: u32,
115 ) -> Builder<'a> {
116 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
117 }
118
119 fn get_from_pointer(
120 builder: ::capnp::private::layout::PointerBuilder<'a>,
121 default: ::core::option::Option<&'a [capnp::Word]>,
122 ) -> ::capnp::Result<Builder<'a>> {
123 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
124 builder.get_struct(_private::STRUCT_SIZE, default)?,
125 ))
126 }
127 }
128
129 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
130 fn set_pointer_builder<'b>(
131 pointer: ::capnp::private::layout::PointerBuilder<'b>,
132 value: Reader<'a>,
133 canonicalize: bool,
134 ) -> ::capnp::Result<()> {
135 pointer.set_struct(&value.reader, canonicalize)
136 }
137 }
138
139 impl<'a> Builder<'a> {
140 pub fn into_reader(self) -> Reader<'a> {
141 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
142 }
143
144 pub fn reborrow(&mut self) -> Builder<'_> {
145 Builder { ..*self }
146 }
147
148 pub fn reborrow_as_reader(&self) -> Reader<'_> {
149 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
150 }
151
152 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
153 self.builder.into_reader().total_size()
154 }
155
156 #[inline]
157 pub fn get_id(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
158 ::capnp::traits::FromPointerBuilder::get_from_pointer(
159 self.builder.get_pointer_field(0),
160 ::core::option::Option::None,
161 )
162 }
163
164 #[inline]
165 pub fn set_id(&mut self, value: ::capnp::data::Reader<'_>) {
166 self.builder.get_pointer_field(0).set_data(value);
167 }
168
169 #[inline]
170 pub fn init_id(self, size: u32) -> ::capnp::data::Builder<'a> {
171 self.builder.get_pointer_field(0).init_data(size)
172 }
173
174 pub fn has_id(&self) -> bool {
175 !self.builder.get_pointer_field(0).is_null()
176 }
177 }
178
179 pub struct Pipeline {
180 _typeless: ::capnp::any_pointer::Pipeline,
181 }
182 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
183 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
184 Pipeline {
185 _typeless: typeless,
186 }
187 }
188 }
189 impl Pipeline {}
190 mod _private {
191 use capnp::private::layout;
192 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
193 data: 0,
194 pointers: 1,
195 };
196 pub const TYPE_ID: u64 = 0xa6fb_d4e8_3f1f_3558;
197 }
198}
199
200pub mod asset_ref {
201 pub use self::Which::{Path, Uuid};
202
203 #[derive(Copy, Clone)]
204 pub struct Owned(());
205 impl<'a> ::capnp::traits::Owned<'a> for Owned {
206 type Builder = Builder<'a>;
207 type Reader = Reader<'a>;
208 }
209 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
210 type Builder = Builder<'a>;
211 type Reader = Reader<'a>;
212 }
213 impl ::capnp::traits::Pipelined for Owned {
214 type Pipeline = Pipeline;
215 }
216
217 #[derive(Clone, Copy)]
218 pub struct Reader<'a> {
219 reader: ::capnp::private::layout::StructReader<'a>,
220 }
221
222 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
223 #[inline]
224 fn type_id() -> u64 {
225 _private::TYPE_ID
226 }
227 }
228 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
229 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
230 Reader { reader }
231 }
232 }
233
234 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
235 fn get_from_pointer(
236 reader: &::capnp::private::layout::PointerReader<'a>,
237 default: ::core::option::Option<&'a [capnp::Word]>,
238 ) -> ::capnp::Result<Reader<'a>> {
239 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
240 reader.get_struct(default)?,
241 ))
242 }
243 }
244
245 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
246 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
247 self.reader
248 }
249 }
250
251 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
252 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
253 self.reader
254 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
255 }
256 }
257
258 impl<'a> Reader<'a> {
259 pub fn reborrow(&self) -> Reader<'_> {
260 Reader { ..*self }
261 }
262
263 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
264 self.reader.total_size()
265 }
266
267 pub fn has_uuid(&self) -> bool {
268 if self.reader.get_data_field::<u16>(0) != 0 {
269 return false;
270 }
271 !self.reader.get_pointer_field(0).is_null()
272 }
273
274 pub fn has_path(&self) -> bool {
275 if self.reader.get_data_field::<u16>(0) != 1 {
276 return false;
277 }
278 !self.reader.get_pointer_field(0).is_null()
279 }
280
281 #[inline]
282 pub fn which(self) -> ::core::result::Result<WhichReader<'a>, ::capnp::NotInSchema> {
283 match self.reader.get_data_field::<u16>(0) {
284 0 => ::core::result::Result::Ok(Uuid(
285 ::capnp::traits::FromPointerReader::get_from_pointer(
286 &self.reader.get_pointer_field(0),
287 ::core::option::Option::None,
288 ),
289 )),
290 1 => ::core::result::Result::Ok(Path(
291 ::capnp::traits::FromPointerReader::get_from_pointer(
292 &self.reader.get_pointer_field(0),
293 ::core::option::Option::None,
294 ),
295 )),
296 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
297 }
298 }
299 }
300
301 pub struct Builder<'a> {
302 builder: ::capnp::private::layout::StructBuilder<'a>,
303 }
304 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
305 #[inline]
306 fn struct_size() -> ::capnp::private::layout::StructSize {
307 _private::STRUCT_SIZE
308 }
309 }
310 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
311 #[inline]
312 fn type_id() -> u64 {
313 _private::TYPE_ID
314 }
315 }
316 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
317 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
318 Builder { builder }
319 }
320 }
321
322 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
323 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
324 self.builder
325 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
326 }
327 }
328
329 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
330 fn init_pointer(
331 builder: ::capnp::private::layout::PointerBuilder<'a>,
332 _size: u32,
333 ) -> Builder<'a> {
334 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
335 }
336
337 fn get_from_pointer(
338 builder: ::capnp::private::layout::PointerBuilder<'a>,
339 default: ::core::option::Option<&'a [capnp::Word]>,
340 ) -> ::capnp::Result<Builder<'a>> {
341 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
342 builder.get_struct(_private::STRUCT_SIZE, default)?,
343 ))
344 }
345 }
346
347 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
348 fn set_pointer_builder<'b>(
349 pointer: ::capnp::private::layout::PointerBuilder<'b>,
350 value: Reader<'a>,
351 canonicalize: bool,
352 ) -> ::capnp::Result<()> {
353 pointer.set_struct(&value.reader, canonicalize)
354 }
355 }
356
357 impl<'a> Builder<'a> {
358 pub fn into_reader(self) -> Reader<'a> {
359 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
360 }
361
362 pub fn reborrow(&mut self) -> Builder<'_> {
363 Builder { ..*self }
364 }
365
366 pub fn reborrow_as_reader(&self) -> Reader<'_> {
367 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
368 }
369
370 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
371 self.builder.into_reader().total_size()
372 }
373
374 #[inline]
375 pub fn set_uuid(
376 &mut self,
377 value: crate::data_capnp::asset_uuid::Reader<'_>,
378 ) -> ::capnp::Result<()> {
379 self.builder.set_data_field::<u16>(0, 0);
380 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
381 self.builder.get_pointer_field(0),
382 value,
383 false,
384 )
385 }
386
387 #[inline]
388 pub fn init_uuid(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
389 self.builder.set_data_field::<u16>(0, 0);
390 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
391 }
392
393 pub fn has_uuid(&self) -> bool {
394 if self.builder.get_data_field::<u16>(0) != 0 {
395 return false;
396 }
397 !self.builder.get_pointer_field(0).is_null()
398 }
399
400 #[inline]
401 pub fn set_path(&mut self, value: ::capnp::data::Reader<'_>) {
402 self.builder.set_data_field::<u16>(0, 1);
403 self.builder.get_pointer_field(0).set_data(value);
404 }
405
406 #[inline]
407 pub fn init_path(self, size: u32) -> ::capnp::data::Builder<'a> {
408 self.builder.set_data_field::<u16>(0, 1);
409 self.builder.get_pointer_field(0).init_data(size)
410 }
411
412 pub fn has_path(&self) -> bool {
413 if self.builder.get_data_field::<u16>(0) != 1 {
414 return false;
415 }
416 !self.builder.get_pointer_field(0).is_null()
417 }
418
419 #[inline]
420 pub fn which(self) -> ::core::result::Result<WhichBuilder<'a>, ::capnp::NotInSchema> {
421 match self.builder.get_data_field::<u16>(0) {
422 0 => ::core::result::Result::Ok(Uuid(
423 ::capnp::traits::FromPointerBuilder::get_from_pointer(
424 self.builder.get_pointer_field(0),
425 ::core::option::Option::None,
426 ),
427 )),
428 1 => ::core::result::Result::Ok(Path(
429 ::capnp::traits::FromPointerBuilder::get_from_pointer(
430 self.builder.get_pointer_field(0),
431 ::core::option::Option::None,
432 ),
433 )),
434 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
435 }
436 }
437 }
438
439 pub struct Pipeline {
440 _typeless: ::capnp::any_pointer::Pipeline,
441 }
442 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
443 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
444 Pipeline {
445 _typeless: typeless,
446 }
447 }
448 }
449 impl Pipeline {}
450 mod _private {
451 use capnp::private::layout;
452 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
453 data: 1,
454 pointers: 1,
455 };
456 pub const TYPE_ID: u64 = 0x96de_6a1f_9774_a2a1;
457 }
458 pub enum Which<A0, A1> {
459 Uuid(A0),
460 Path(A1),
461 }
462 pub type WhichReader<'a> = Which<
463 ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>>,
464 ::capnp::Result<::capnp::data::Reader<'a>>,
465 >;
466 pub type WhichBuilder<'a> = Which<
467 ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>>,
468 ::capnp::Result<::capnp::data::Builder<'a>>,
469 >;
470}
471
472pub mod asset_uuid_list {
473 #[derive(Copy, Clone)]
474 pub struct Owned(());
475 impl<'a> ::capnp::traits::Owned<'a> for Owned {
476 type Builder = Builder<'a>;
477 type Reader = Reader<'a>;
478 }
479 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
480 type Builder = Builder<'a>;
481 type Reader = Reader<'a>;
482 }
483 impl ::capnp::traits::Pipelined for Owned {
484 type Pipeline = Pipeline;
485 }
486
487 #[derive(Clone, Copy)]
488 pub struct Reader<'a> {
489 reader: ::capnp::private::layout::StructReader<'a>,
490 }
491
492 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
493 #[inline]
494 fn type_id() -> u64 {
495 _private::TYPE_ID
496 }
497 }
498 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
499 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
500 Reader { reader }
501 }
502 }
503
504 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
505 fn get_from_pointer(
506 reader: &::capnp::private::layout::PointerReader<'a>,
507 default: ::core::option::Option<&'a [capnp::Word]>,
508 ) -> ::capnp::Result<Reader<'a>> {
509 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
510 reader.get_struct(default)?,
511 ))
512 }
513 }
514
515 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
516 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
517 self.reader
518 }
519 }
520
521 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
522 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
523 self.reader
524 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
525 }
526 }
527
528 impl<'a> Reader<'a> {
529 pub fn reborrow(&self) -> Reader<'_> {
530 Reader { ..*self }
531 }
532
533 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
534 self.reader.total_size()
535 }
536
537 #[inline]
538 pub fn get_list(
539 self,
540 ) -> ::capnp::Result<::capnp::struct_list::Reader<'a, crate::data_capnp::asset_uuid::Owned>>
541 {
542 ::capnp::traits::FromPointerReader::get_from_pointer(
543 &self.reader.get_pointer_field(0),
544 ::core::option::Option::None,
545 )
546 }
547
548 pub fn has_list(&self) -> bool {
549 !self.reader.get_pointer_field(0).is_null()
550 }
551 }
552
553 pub struct Builder<'a> {
554 builder: ::capnp::private::layout::StructBuilder<'a>,
555 }
556 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
557 #[inline]
558 fn struct_size() -> ::capnp::private::layout::StructSize {
559 _private::STRUCT_SIZE
560 }
561 }
562 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
563 #[inline]
564 fn type_id() -> u64 {
565 _private::TYPE_ID
566 }
567 }
568 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
569 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
570 Builder { builder }
571 }
572 }
573
574 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
575 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
576 self.builder
577 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
578 }
579 }
580
581 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
582 fn init_pointer(
583 builder: ::capnp::private::layout::PointerBuilder<'a>,
584 _size: u32,
585 ) -> Builder<'a> {
586 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
587 }
588
589 fn get_from_pointer(
590 builder: ::capnp::private::layout::PointerBuilder<'a>,
591 default: ::core::option::Option<&'a [capnp::Word]>,
592 ) -> ::capnp::Result<Builder<'a>> {
593 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
594 builder.get_struct(_private::STRUCT_SIZE, default)?,
595 ))
596 }
597 }
598
599 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
600 fn set_pointer_builder<'b>(
601 pointer: ::capnp::private::layout::PointerBuilder<'b>,
602 value: Reader<'a>,
603 canonicalize: bool,
604 ) -> ::capnp::Result<()> {
605 pointer.set_struct(&value.reader, canonicalize)
606 }
607 }
608
609 impl<'a> Builder<'a> {
610 pub fn into_reader(self) -> Reader<'a> {
611 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
612 }
613
614 pub fn reborrow(&mut self) -> Builder<'_> {
615 Builder { ..*self }
616 }
617
618 pub fn reborrow_as_reader(&self) -> Reader<'_> {
619 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
620 }
621
622 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
623 self.builder.into_reader().total_size()
624 }
625
626 #[inline]
627 pub fn get_list(
628 self,
629 ) -> ::capnp::Result<::capnp::struct_list::Builder<'a, crate::data_capnp::asset_uuid::Owned>>
630 {
631 ::capnp::traits::FromPointerBuilder::get_from_pointer(
632 self.builder.get_pointer_field(0),
633 ::core::option::Option::None,
634 )
635 }
636
637 #[inline]
638 pub fn set_list(
639 &mut self,
640 value: ::capnp::struct_list::Reader<'a, crate::data_capnp::asset_uuid::Owned>,
641 ) -> ::capnp::Result<()> {
642 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
643 self.builder.get_pointer_field(0),
644 value,
645 false,
646 )
647 }
648
649 #[inline]
650 pub fn init_list(
651 self,
652 size: u32,
653 ) -> ::capnp::struct_list::Builder<'a, crate::data_capnp::asset_uuid::Owned> {
654 ::capnp::traits::FromPointerBuilder::init_pointer(
655 self.builder.get_pointer_field(0),
656 size,
657 )
658 }
659
660 pub fn has_list(&self) -> bool {
661 !self.builder.get_pointer_field(0).is_null()
662 }
663 }
664
665 pub struct Pipeline {
666 _typeless: ::capnp::any_pointer::Pipeline,
667 }
668 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
669 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
670 Pipeline {
671 _typeless: typeless,
672 }
673 }
674 }
675 impl Pipeline {}
676 mod _private {
677 use capnp::private::layout;
678 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
679 data: 0,
680 pointers: 1,
681 };
682 pub const TYPE_ID: u64 = 0x9a9f_890a_2120_783b;
683 }
684}
685
686pub mod key_value {
687 #[derive(Copy, Clone)]
688 pub struct Owned(());
689 impl<'a> ::capnp::traits::Owned<'a> for Owned {
690 type Builder = Builder<'a>;
691 type Reader = Reader<'a>;
692 }
693 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
694 type Builder = Builder<'a>;
695 type Reader = Reader<'a>;
696 }
697 impl ::capnp::traits::Pipelined for Owned {
698 type Pipeline = Pipeline;
699 }
700
701 #[derive(Clone, Copy)]
702 pub struct Reader<'a> {
703 reader: ::capnp::private::layout::StructReader<'a>,
704 }
705
706 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
707 #[inline]
708 fn type_id() -> u64 {
709 _private::TYPE_ID
710 }
711 }
712 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
713 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
714 Reader { reader }
715 }
716 }
717
718 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
719 fn get_from_pointer(
720 reader: &::capnp::private::layout::PointerReader<'a>,
721 default: ::core::option::Option<&'a [capnp::Word]>,
722 ) -> ::capnp::Result<Reader<'a>> {
723 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
724 reader.get_struct(default)?,
725 ))
726 }
727 }
728
729 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
730 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
731 self.reader
732 }
733 }
734
735 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
736 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
737 self.reader
738 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
739 }
740 }
741
742 impl<'a> Reader<'a> {
743 pub fn reborrow(&self) -> Reader<'_> {
744 Reader { ..*self }
745 }
746
747 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
748 self.reader.total_size()
749 }
750
751 #[inline]
752 pub fn get_key(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
753 ::capnp::traits::FromPointerReader::get_from_pointer(
754 &self.reader.get_pointer_field(0),
755 ::core::option::Option::None,
756 )
757 }
758
759 pub fn has_key(&self) -> bool {
760 !self.reader.get_pointer_field(0).is_null()
761 }
762
763 #[inline]
764 pub fn get_value(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
765 ::capnp::traits::FromPointerReader::get_from_pointer(
766 &self.reader.get_pointer_field(1),
767 ::core::option::Option::None,
768 )
769 }
770
771 pub fn has_value(&self) -> bool {
772 !self.reader.get_pointer_field(1).is_null()
773 }
774 }
775
776 pub struct Builder<'a> {
777 builder: ::capnp::private::layout::StructBuilder<'a>,
778 }
779 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
780 #[inline]
781 fn struct_size() -> ::capnp::private::layout::StructSize {
782 _private::STRUCT_SIZE
783 }
784 }
785 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
786 #[inline]
787 fn type_id() -> u64 {
788 _private::TYPE_ID
789 }
790 }
791 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
792 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
793 Builder { builder }
794 }
795 }
796
797 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
798 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
799 self.builder
800 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
801 }
802 }
803
804 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
805 fn init_pointer(
806 builder: ::capnp::private::layout::PointerBuilder<'a>,
807 _size: u32,
808 ) -> Builder<'a> {
809 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
810 }
811
812 fn get_from_pointer(
813 builder: ::capnp::private::layout::PointerBuilder<'a>,
814 default: ::core::option::Option<&'a [capnp::Word]>,
815 ) -> ::capnp::Result<Builder<'a>> {
816 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
817 builder.get_struct(_private::STRUCT_SIZE, default)?,
818 ))
819 }
820 }
821
822 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
823 fn set_pointer_builder<'b>(
824 pointer: ::capnp::private::layout::PointerBuilder<'b>,
825 value: Reader<'a>,
826 canonicalize: bool,
827 ) -> ::capnp::Result<()> {
828 pointer.set_struct(&value.reader, canonicalize)
829 }
830 }
831
832 impl<'a> Builder<'a> {
833 pub fn into_reader(self) -> Reader<'a> {
834 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
835 }
836
837 pub fn reborrow(&mut self) -> Builder<'_> {
838 Builder { ..*self }
839 }
840
841 pub fn reborrow_as_reader(&self) -> Reader<'_> {
842 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
843 }
844
845 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
846 self.builder.into_reader().total_size()
847 }
848
849 #[inline]
850 pub fn get_key(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
851 ::capnp::traits::FromPointerBuilder::get_from_pointer(
852 self.builder.get_pointer_field(0),
853 ::core::option::Option::None,
854 )
855 }
856
857 #[inline]
858 pub fn set_key(&mut self, value: ::capnp::data::Reader<'_>) {
859 self.builder.get_pointer_field(0).set_data(value);
860 }
861
862 #[inline]
863 pub fn init_key(self, size: u32) -> ::capnp::data::Builder<'a> {
864 self.builder.get_pointer_field(0).init_data(size)
865 }
866
867 pub fn has_key(&self) -> bool {
868 !self.builder.get_pointer_field(0).is_null()
869 }
870
871 #[inline]
872 pub fn get_value(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
873 ::capnp::traits::FromPointerBuilder::get_from_pointer(
874 self.builder.get_pointer_field(1),
875 ::core::option::Option::None,
876 )
877 }
878
879 #[inline]
880 pub fn set_value(&mut self, value: ::capnp::data::Reader<'_>) {
881 self.builder.get_pointer_field(1).set_data(value);
882 }
883
884 #[inline]
885 pub fn init_value(self, size: u32) -> ::capnp::data::Builder<'a> {
886 self.builder.get_pointer_field(1).init_data(size)
887 }
888
889 pub fn has_value(&self) -> bool {
890 !self.builder.get_pointer_field(1).is_null()
891 }
892 }
893
894 pub struct Pipeline {
895 _typeless: ::capnp::any_pointer::Pipeline,
896 }
897 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
898 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
899 Pipeline {
900 _typeless: typeless,
901 }
902 }
903 }
904 impl Pipeline {}
905 mod _private {
906 use capnp::private::layout;
907 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
908 data: 0,
909 pointers: 2,
910 };
911 pub const TYPE_ID: u64 = 0xc32e_960b_b955_c573;
912 }
913}
914
915#[repr(u16)]
916#[derive(Clone, Copy, PartialEq)]
917pub enum FileType {
918 File = 0,
919 Directory = 1,
920 Symlink = 2,
921 None = 3,
922}
923impl ::capnp::traits::FromU16 for FileType {
924 #[inline]
925 fn from_u16(value: u16) -> ::core::result::Result<FileType, ::capnp::NotInSchema> {
926 match value {
927 0 => ::core::result::Result::Ok(FileType::File),
928 1 => ::core::result::Result::Ok(FileType::Directory),
929 2 => ::core::result::Result::Ok(FileType::Symlink),
930 3 => ::core::result::Result::Ok(FileType::None),
931 n => ::core::result::Result::Err(::capnp::NotInSchema(n)),
932 }
933 }
934}
935impl ::capnp::traits::ToU16 for FileType {
936 #[inline]
937 fn to_u16(self) -> u16 {
938 self as u16
939 }
940}
941impl ::capnp::traits::HasTypeId for FileType {
942 #[inline]
943 fn type_id() -> u64 {
944 0xa210_b6c7_edd1_949bu64
945 }
946}
947
948#[repr(u16)]
949#[derive(Clone, Copy, PartialEq)]
950pub enum FileState {
951 Exists = 0,
952 Deleted = 1,
953}
954impl ::capnp::traits::FromU16 for FileState {
955 #[inline]
956 fn from_u16(value: u16) -> ::core::result::Result<FileState, ::capnp::NotInSchema> {
957 match value {
958 0 => ::core::result::Result::Ok(FileState::Exists),
959 1 => ::core::result::Result::Ok(FileState::Deleted),
960 n => ::core::result::Result::Err(::capnp::NotInSchema(n)),
961 }
962 }
963}
964impl ::capnp::traits::ToU16 for FileState {
965 #[inline]
966 fn to_u16(self) -> u16 {
967 self as u16
968 }
969}
970impl ::capnp::traits::HasTypeId for FileState {
971 #[inline]
972 fn type_id() -> u64 {
973 0xa9a5_f076_e03d_2e1fu64
974 }
975}
976
977pub mod dirty_file_info {
978 #[derive(Copy, Clone)]
979 pub struct Owned(());
980 impl<'a> ::capnp::traits::Owned<'a> for Owned {
981 type Builder = Builder<'a>;
982 type Reader = Reader<'a>;
983 }
984 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
985 type Builder = Builder<'a>;
986 type Reader = Reader<'a>;
987 }
988 impl ::capnp::traits::Pipelined for Owned {
989 type Pipeline = Pipeline;
990 }
991
992 #[derive(Clone, Copy)]
993 pub struct Reader<'a> {
994 reader: ::capnp::private::layout::StructReader<'a>,
995 }
996
997 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
998 #[inline]
999 fn type_id() -> u64 {
1000 _private::TYPE_ID
1001 }
1002 }
1003 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
1004 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
1005 Reader { reader }
1006 }
1007 }
1008
1009 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
1010 fn get_from_pointer(
1011 reader: &::capnp::private::layout::PointerReader<'a>,
1012 default: ::core::option::Option<&'a [capnp::Word]>,
1013 ) -> ::capnp::Result<Reader<'a>> {
1014 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
1015 reader.get_struct(default)?,
1016 ))
1017 }
1018 }
1019
1020 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
1021 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
1022 self.reader
1023 }
1024 }
1025
1026 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
1027 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
1028 self.reader
1029 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
1030 }
1031 }
1032
1033 impl<'a> Reader<'a> {
1034 pub fn reborrow(&self) -> Reader<'_> {
1035 Reader { ..*self }
1036 }
1037
1038 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1039 self.reader.total_size()
1040 }
1041
1042 #[inline]
1043 pub fn get_state(
1044 self,
1045 ) -> ::core::result::Result<crate::data_capnp::FileState, ::capnp::NotInSchema> {
1046 ::capnp::traits::FromU16::from_u16(self.reader.get_data_field::<u16>(0))
1047 }
1048
1049 #[inline]
1050 pub fn get_source_info(
1051 self,
1052 ) -> ::capnp::Result<crate::data_capnp::source_file_info::Reader<'a>> {
1053 ::capnp::traits::FromPointerReader::get_from_pointer(
1054 &self.reader.get_pointer_field(0),
1055 ::core::option::Option::None,
1056 )
1057 }
1058
1059 pub fn has_source_info(&self) -> bool {
1060 !self.reader.get_pointer_field(0).is_null()
1061 }
1062 }
1063
1064 pub struct Builder<'a> {
1065 builder: ::capnp::private::layout::StructBuilder<'a>,
1066 }
1067 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
1068 #[inline]
1069 fn struct_size() -> ::capnp::private::layout::StructSize {
1070 _private::STRUCT_SIZE
1071 }
1072 }
1073 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
1074 #[inline]
1075 fn type_id() -> u64 {
1076 _private::TYPE_ID
1077 }
1078 }
1079 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
1080 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
1081 Builder { builder }
1082 }
1083 }
1084
1085 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
1086 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
1087 self.builder
1088 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
1089 }
1090 }
1091
1092 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
1093 fn init_pointer(
1094 builder: ::capnp::private::layout::PointerBuilder<'a>,
1095 _size: u32,
1096 ) -> Builder<'a> {
1097 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
1098 }
1099
1100 fn get_from_pointer(
1101 builder: ::capnp::private::layout::PointerBuilder<'a>,
1102 default: ::core::option::Option<&'a [capnp::Word]>,
1103 ) -> ::capnp::Result<Builder<'a>> {
1104 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
1105 builder.get_struct(_private::STRUCT_SIZE, default)?,
1106 ))
1107 }
1108 }
1109
1110 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
1111 fn set_pointer_builder<'b>(
1112 pointer: ::capnp::private::layout::PointerBuilder<'b>,
1113 value: Reader<'a>,
1114 canonicalize: bool,
1115 ) -> ::capnp::Result<()> {
1116 pointer.set_struct(&value.reader, canonicalize)
1117 }
1118 }
1119
1120 impl<'a> Builder<'a> {
1121 pub fn into_reader(self) -> Reader<'a> {
1122 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1123 }
1124
1125 pub fn reborrow(&mut self) -> Builder<'_> {
1126 Builder { ..*self }
1127 }
1128
1129 pub fn reborrow_as_reader(&self) -> Reader<'_> {
1130 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1131 }
1132
1133 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1134 self.builder.into_reader().total_size()
1135 }
1136
1137 #[inline]
1138 pub fn get_state(
1139 self,
1140 ) -> ::core::result::Result<crate::data_capnp::FileState, ::capnp::NotInSchema> {
1141 ::capnp::traits::FromU16::from_u16(self.builder.get_data_field::<u16>(0))
1142 }
1143
1144 #[inline]
1145 pub fn set_state(&mut self, value: crate::data_capnp::FileState) {
1146 self.builder.set_data_field::<u16>(0, value as u16)
1147 }
1148
1149 #[inline]
1150 pub fn get_source_info(
1151 self,
1152 ) -> ::capnp::Result<crate::data_capnp::source_file_info::Builder<'a>> {
1153 ::capnp::traits::FromPointerBuilder::get_from_pointer(
1154 self.builder.get_pointer_field(0),
1155 ::core::option::Option::None,
1156 )
1157 }
1158
1159 #[inline]
1160 pub fn set_source_info(
1161 &mut self,
1162 value: crate::data_capnp::source_file_info::Reader<'_>,
1163 ) -> ::capnp::Result<()> {
1164 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
1165 self.builder.get_pointer_field(0),
1166 value,
1167 false,
1168 )
1169 }
1170
1171 #[inline]
1172 pub fn init_source_info(self) -> crate::data_capnp::source_file_info::Builder<'a> {
1173 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
1174 }
1175
1176 pub fn has_source_info(&self) -> bool {
1177 !self.builder.get_pointer_field(0).is_null()
1178 }
1179 }
1180
1181 pub struct Pipeline {
1182 _typeless: ::capnp::any_pointer::Pipeline,
1183 }
1184 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
1185 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
1186 Pipeline {
1187 _typeless: typeless,
1188 }
1189 }
1190 }
1191 impl Pipeline {
1192 pub fn get_source_info(&self) -> crate::data_capnp::source_file_info::Pipeline {
1193 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
1194 }
1195 }
1196 mod _private {
1197 use capnp::private::layout;
1198 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
1199 data: 1,
1200 pointers: 1,
1201 };
1202 pub const TYPE_ID: u64 = 0xbca5_27ec_30ad_4de6;
1203 }
1204}
1205
1206pub mod source_file_info {
1207 #[derive(Copy, Clone)]
1208 pub struct Owned(());
1209 impl<'a> ::capnp::traits::Owned<'a> for Owned {
1210 type Builder = Builder<'a>;
1211 type Reader = Reader<'a>;
1212 }
1213 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
1214 type Builder = Builder<'a>;
1215 type Reader = Reader<'a>;
1216 }
1217 impl ::capnp::traits::Pipelined for Owned {
1218 type Pipeline = Pipeline;
1219 }
1220
1221 #[derive(Clone, Copy)]
1222 pub struct Reader<'a> {
1223 reader: ::capnp::private::layout::StructReader<'a>,
1224 }
1225
1226 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
1227 #[inline]
1228 fn type_id() -> u64 {
1229 _private::TYPE_ID
1230 }
1231 }
1232 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
1233 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
1234 Reader { reader }
1235 }
1236 }
1237
1238 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
1239 fn get_from_pointer(
1240 reader: &::capnp::private::layout::PointerReader<'a>,
1241 default: ::core::option::Option<&'a [capnp::Word]>,
1242 ) -> ::capnp::Result<Reader<'a>> {
1243 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
1244 reader.get_struct(default)?,
1245 ))
1246 }
1247 }
1248
1249 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
1250 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
1251 self.reader
1252 }
1253 }
1254
1255 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
1256 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
1257 self.reader
1258 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
1259 }
1260 }
1261
1262 impl<'a> Reader<'a> {
1263 pub fn reborrow(&self) -> Reader<'_> {
1264 Reader { ..*self }
1265 }
1266
1267 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1268 self.reader.total_size()
1269 }
1270
1271 #[inline]
1272 pub fn get_type(
1273 self,
1274 ) -> ::core::result::Result<crate::data_capnp::FileType, ::capnp::NotInSchema> {
1275 ::capnp::traits::FromU16::from_u16(self.reader.get_data_field::<u16>(0))
1276 }
1277
1278 #[inline]
1279 pub fn get_last_modified(self) -> u64 {
1280 self.reader.get_data_field::<u64>(1)
1281 }
1282
1283 #[inline]
1284 pub fn get_length(self) -> u64 {
1285 self.reader.get_data_field::<u64>(2)
1286 }
1287 }
1288
1289 pub struct Builder<'a> {
1290 builder: ::capnp::private::layout::StructBuilder<'a>,
1291 }
1292 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
1293 #[inline]
1294 fn struct_size() -> ::capnp::private::layout::StructSize {
1295 _private::STRUCT_SIZE
1296 }
1297 }
1298 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
1299 #[inline]
1300 fn type_id() -> u64 {
1301 _private::TYPE_ID
1302 }
1303 }
1304 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
1305 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
1306 Builder { builder }
1307 }
1308 }
1309
1310 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
1311 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
1312 self.builder
1313 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
1314 }
1315 }
1316
1317 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
1318 fn init_pointer(
1319 builder: ::capnp::private::layout::PointerBuilder<'a>,
1320 _size: u32,
1321 ) -> Builder<'a> {
1322 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
1323 }
1324
1325 fn get_from_pointer(
1326 builder: ::capnp::private::layout::PointerBuilder<'a>,
1327 default: ::core::option::Option<&'a [capnp::Word]>,
1328 ) -> ::capnp::Result<Builder<'a>> {
1329 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
1330 builder.get_struct(_private::STRUCT_SIZE, default)?,
1331 ))
1332 }
1333 }
1334
1335 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
1336 fn set_pointer_builder<'b>(
1337 pointer: ::capnp::private::layout::PointerBuilder<'b>,
1338 value: Reader<'a>,
1339 canonicalize: bool,
1340 ) -> ::capnp::Result<()> {
1341 pointer.set_struct(&value.reader, canonicalize)
1342 }
1343 }
1344
1345 impl<'a> Builder<'a> {
1346 pub fn into_reader(self) -> Reader<'a> {
1347 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1348 }
1349
1350 pub fn reborrow(&mut self) -> Builder<'_> {
1351 Builder { ..*self }
1352 }
1353
1354 pub fn reborrow_as_reader(&self) -> Reader<'_> {
1355 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1356 }
1357
1358 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1359 self.builder.into_reader().total_size()
1360 }
1361
1362 #[inline]
1363 pub fn get_type(
1364 self,
1365 ) -> ::core::result::Result<crate::data_capnp::FileType, ::capnp::NotInSchema> {
1366 ::capnp::traits::FromU16::from_u16(self.builder.get_data_field::<u16>(0))
1367 }
1368
1369 #[inline]
1370 pub fn set_type(&mut self, value: crate::data_capnp::FileType) {
1371 self.builder.set_data_field::<u16>(0, value as u16)
1372 }
1373
1374 #[inline]
1375 pub fn get_last_modified(self) -> u64 {
1376 self.builder.get_data_field::<u64>(1)
1377 }
1378
1379 #[inline]
1380 pub fn set_last_modified(&mut self, value: u64) {
1381 self.builder.set_data_field::<u64>(1, value);
1382 }
1383
1384 #[inline]
1385 pub fn get_length(self) -> u64 {
1386 self.builder.get_data_field::<u64>(2)
1387 }
1388
1389 #[inline]
1390 pub fn set_length(&mut self, value: u64) {
1391 self.builder.set_data_field::<u64>(2, value);
1392 }
1393 }
1394
1395 pub struct Pipeline {
1396 _typeless: ::capnp::any_pointer::Pipeline,
1397 }
1398 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
1399 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
1400 Pipeline {
1401 _typeless: typeless,
1402 }
1403 }
1404 }
1405 impl Pipeline {}
1406 mod _private {
1407 use capnp::private::layout;
1408 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
1409 data: 3,
1410 pointers: 0,
1411 };
1412 pub const TYPE_ID: u64 = 0xe978_0c5c_d98d_9b28;
1413 }
1414}
1415
1416pub mod rename_file_event {
1417 #[derive(Copy, Clone)]
1418 pub struct Owned(());
1419 impl<'a> ::capnp::traits::Owned<'a> for Owned {
1420 type Builder = Builder<'a>;
1421 type Reader = Reader<'a>;
1422 }
1423 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
1424 type Builder = Builder<'a>;
1425 type Reader = Reader<'a>;
1426 }
1427 impl ::capnp::traits::Pipelined for Owned {
1428 type Pipeline = Pipeline;
1429 }
1430
1431 #[derive(Clone, Copy)]
1432 pub struct Reader<'a> {
1433 reader: ::capnp::private::layout::StructReader<'a>,
1434 }
1435
1436 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
1437 #[inline]
1438 fn type_id() -> u64 {
1439 _private::TYPE_ID
1440 }
1441 }
1442 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
1443 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
1444 Reader { reader }
1445 }
1446 }
1447
1448 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
1449 fn get_from_pointer(
1450 reader: &::capnp::private::layout::PointerReader<'a>,
1451 default: ::core::option::Option<&'a [capnp::Word]>,
1452 ) -> ::capnp::Result<Reader<'a>> {
1453 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
1454 reader.get_struct(default)?,
1455 ))
1456 }
1457 }
1458
1459 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
1460 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
1461 self.reader
1462 }
1463 }
1464
1465 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
1466 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
1467 self.reader
1468 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
1469 }
1470 }
1471
1472 impl<'a> Reader<'a> {
1473 pub fn reborrow(&self) -> Reader<'_> {
1474 Reader { ..*self }
1475 }
1476
1477 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1478 self.reader.total_size()
1479 }
1480
1481 #[inline]
1482 pub fn get_src(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
1483 ::capnp::traits::FromPointerReader::get_from_pointer(
1484 &self.reader.get_pointer_field(0),
1485 ::core::option::Option::None,
1486 )
1487 }
1488
1489 pub fn has_src(&self) -> bool {
1490 !self.reader.get_pointer_field(0).is_null()
1491 }
1492
1493 #[inline]
1494 pub fn get_dst(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
1495 ::capnp::traits::FromPointerReader::get_from_pointer(
1496 &self.reader.get_pointer_field(1),
1497 ::core::option::Option::None,
1498 )
1499 }
1500
1501 pub fn has_dst(&self) -> bool {
1502 !self.reader.get_pointer_field(1).is_null()
1503 }
1504 }
1505
1506 pub struct Builder<'a> {
1507 builder: ::capnp::private::layout::StructBuilder<'a>,
1508 }
1509 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
1510 #[inline]
1511 fn struct_size() -> ::capnp::private::layout::StructSize {
1512 _private::STRUCT_SIZE
1513 }
1514 }
1515 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
1516 #[inline]
1517 fn type_id() -> u64 {
1518 _private::TYPE_ID
1519 }
1520 }
1521 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
1522 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
1523 Builder { builder }
1524 }
1525 }
1526
1527 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
1528 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
1529 self.builder
1530 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
1531 }
1532 }
1533
1534 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
1535 fn init_pointer(
1536 builder: ::capnp::private::layout::PointerBuilder<'a>,
1537 _size: u32,
1538 ) -> Builder<'a> {
1539 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
1540 }
1541
1542 fn get_from_pointer(
1543 builder: ::capnp::private::layout::PointerBuilder<'a>,
1544 default: ::core::option::Option<&'a [capnp::Word]>,
1545 ) -> ::capnp::Result<Builder<'a>> {
1546 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
1547 builder.get_struct(_private::STRUCT_SIZE, default)?,
1548 ))
1549 }
1550 }
1551
1552 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
1553 fn set_pointer_builder<'b>(
1554 pointer: ::capnp::private::layout::PointerBuilder<'b>,
1555 value: Reader<'a>,
1556 canonicalize: bool,
1557 ) -> ::capnp::Result<()> {
1558 pointer.set_struct(&value.reader, canonicalize)
1559 }
1560 }
1561
1562 impl<'a> Builder<'a> {
1563 pub fn into_reader(self) -> Reader<'a> {
1564 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1565 }
1566
1567 pub fn reborrow(&mut self) -> Builder<'_> {
1568 Builder { ..*self }
1569 }
1570
1571 pub fn reborrow_as_reader(&self) -> Reader<'_> {
1572 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1573 }
1574
1575 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1576 self.builder.into_reader().total_size()
1577 }
1578
1579 #[inline]
1580 pub fn get_src(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
1581 ::capnp::traits::FromPointerBuilder::get_from_pointer(
1582 self.builder.get_pointer_field(0),
1583 ::core::option::Option::None,
1584 )
1585 }
1586
1587 #[inline]
1588 pub fn set_src(&mut self, value: ::capnp::data::Reader<'_>) {
1589 self.builder.get_pointer_field(0).set_data(value);
1590 }
1591
1592 #[inline]
1593 pub fn init_src(self, size: u32) -> ::capnp::data::Builder<'a> {
1594 self.builder.get_pointer_field(0).init_data(size)
1595 }
1596
1597 pub fn has_src(&self) -> bool {
1598 !self.builder.get_pointer_field(0).is_null()
1599 }
1600
1601 #[inline]
1602 pub fn get_dst(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
1603 ::capnp::traits::FromPointerBuilder::get_from_pointer(
1604 self.builder.get_pointer_field(1),
1605 ::core::option::Option::None,
1606 )
1607 }
1608
1609 #[inline]
1610 pub fn set_dst(&mut self, value: ::capnp::data::Reader<'_>) {
1611 self.builder.get_pointer_field(1).set_data(value);
1612 }
1613
1614 #[inline]
1615 pub fn init_dst(self, size: u32) -> ::capnp::data::Builder<'a> {
1616 self.builder.get_pointer_field(1).init_data(size)
1617 }
1618
1619 pub fn has_dst(&self) -> bool {
1620 !self.builder.get_pointer_field(1).is_null()
1621 }
1622 }
1623
1624 pub struct Pipeline {
1625 _typeless: ::capnp::any_pointer::Pipeline,
1626 }
1627 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
1628 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
1629 Pipeline {
1630 _typeless: typeless,
1631 }
1632 }
1633 }
1634 impl Pipeline {}
1635 mod _private {
1636 use capnp::private::layout;
1637 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
1638 data: 0,
1639 pointers: 2,
1640 };
1641 pub const TYPE_ID: u64 = 0xc77e_63c5_0c77_0460;
1642 }
1643}
1644
1645#[repr(u16)]
1646#[derive(Clone, Copy, PartialEq)]
1647pub enum AssetSource {
1648 File = 0,
1649}
1650impl ::capnp::traits::FromU16 for AssetSource {
1651 #[inline]
1652 fn from_u16(value: u16) -> ::core::result::Result<AssetSource, ::capnp::NotInSchema> {
1653 match value {
1654 0 => ::core::result::Result::Ok(AssetSource::File),
1655 n => ::core::result::Result::Err(::capnp::NotInSchema(n)),
1656 }
1657 }
1658}
1659impl ::capnp::traits::ToU16 for AssetSource {
1660 #[inline]
1661 fn to_u16(self) -> u16 {
1662 self as u16
1663 }
1664}
1665impl ::capnp::traits::HasTypeId for AssetSource {
1666 #[inline]
1667 fn type_id() -> u64 {
1668 0x9f17_17fe_ddca_49fdu64
1669 }
1670}
1671
1672pub mod asset_uuid_pair {
1673 #[derive(Copy, Clone)]
1674 pub struct Owned(());
1675 impl<'a> ::capnp::traits::Owned<'a> for Owned {
1676 type Builder = Builder<'a>;
1677 type Reader = Reader<'a>;
1678 }
1679 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
1680 type Builder = Builder<'a>;
1681 type Reader = Reader<'a>;
1682 }
1683 impl ::capnp::traits::Pipelined for Owned {
1684 type Pipeline = Pipeline;
1685 }
1686
1687 #[derive(Clone, Copy)]
1688 pub struct Reader<'a> {
1689 reader: ::capnp::private::layout::StructReader<'a>,
1690 }
1691
1692 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
1693 #[inline]
1694 fn type_id() -> u64 {
1695 _private::TYPE_ID
1696 }
1697 }
1698 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
1699 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
1700 Reader { reader }
1701 }
1702 }
1703
1704 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
1705 fn get_from_pointer(
1706 reader: &::capnp::private::layout::PointerReader<'a>,
1707 default: ::core::option::Option<&'a [capnp::Word]>,
1708 ) -> ::capnp::Result<Reader<'a>> {
1709 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
1710 reader.get_struct(default)?,
1711 ))
1712 }
1713 }
1714
1715 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
1716 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
1717 self.reader
1718 }
1719 }
1720
1721 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
1722 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
1723 self.reader
1724 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
1725 }
1726 }
1727
1728 impl<'a> Reader<'a> {
1729 pub fn reborrow(&self) -> Reader<'_> {
1730 Reader { ..*self }
1731 }
1732
1733 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1734 self.reader.total_size()
1735 }
1736
1737 #[inline]
1738 pub fn get_key(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>> {
1739 ::capnp::traits::FromPointerReader::get_from_pointer(
1740 &self.reader.get_pointer_field(0),
1741 ::core::option::Option::None,
1742 )
1743 }
1744
1745 pub fn has_key(&self) -> bool {
1746 !self.reader.get_pointer_field(0).is_null()
1747 }
1748
1749 #[inline]
1750 pub fn get_value(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>> {
1751 ::capnp::traits::FromPointerReader::get_from_pointer(
1752 &self.reader.get_pointer_field(1),
1753 ::core::option::Option::None,
1754 )
1755 }
1756
1757 pub fn has_value(&self) -> bool {
1758 !self.reader.get_pointer_field(1).is_null()
1759 }
1760 }
1761
1762 pub struct Builder<'a> {
1763 builder: ::capnp::private::layout::StructBuilder<'a>,
1764 }
1765 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
1766 #[inline]
1767 fn struct_size() -> ::capnp::private::layout::StructSize {
1768 _private::STRUCT_SIZE
1769 }
1770 }
1771 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
1772 #[inline]
1773 fn type_id() -> u64 {
1774 _private::TYPE_ID
1775 }
1776 }
1777 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
1778 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
1779 Builder { builder }
1780 }
1781 }
1782
1783 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
1784 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
1785 self.builder
1786 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
1787 }
1788 }
1789
1790 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
1791 fn init_pointer(
1792 builder: ::capnp::private::layout::PointerBuilder<'a>,
1793 _size: u32,
1794 ) -> Builder<'a> {
1795 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
1796 }
1797
1798 fn get_from_pointer(
1799 builder: ::capnp::private::layout::PointerBuilder<'a>,
1800 default: ::core::option::Option<&'a [capnp::Word]>,
1801 ) -> ::capnp::Result<Builder<'a>> {
1802 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
1803 builder.get_struct(_private::STRUCT_SIZE, default)?,
1804 ))
1805 }
1806 }
1807
1808 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
1809 fn set_pointer_builder<'b>(
1810 pointer: ::capnp::private::layout::PointerBuilder<'b>,
1811 value: Reader<'a>,
1812 canonicalize: bool,
1813 ) -> ::capnp::Result<()> {
1814 pointer.set_struct(&value.reader, canonicalize)
1815 }
1816 }
1817
1818 impl<'a> Builder<'a> {
1819 pub fn into_reader(self) -> Reader<'a> {
1820 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1821 }
1822
1823 pub fn reborrow(&mut self) -> Builder<'_> {
1824 Builder { ..*self }
1825 }
1826
1827 pub fn reborrow_as_reader(&self) -> Reader<'_> {
1828 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
1829 }
1830
1831 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1832 self.builder.into_reader().total_size()
1833 }
1834
1835 #[inline]
1836 pub fn get_key(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>> {
1837 ::capnp::traits::FromPointerBuilder::get_from_pointer(
1838 self.builder.get_pointer_field(0),
1839 ::core::option::Option::None,
1840 )
1841 }
1842
1843 #[inline]
1844 pub fn set_key(
1845 &mut self,
1846 value: crate::data_capnp::asset_uuid::Reader<'_>,
1847 ) -> ::capnp::Result<()> {
1848 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
1849 self.builder.get_pointer_field(0),
1850 value,
1851 false,
1852 )
1853 }
1854
1855 #[inline]
1856 pub fn init_key(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
1857 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
1858 }
1859
1860 pub fn has_key(&self) -> bool {
1861 !self.builder.get_pointer_field(0).is_null()
1862 }
1863
1864 #[inline]
1865 pub fn get_value(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>> {
1866 ::capnp::traits::FromPointerBuilder::get_from_pointer(
1867 self.builder.get_pointer_field(1),
1868 ::core::option::Option::None,
1869 )
1870 }
1871
1872 #[inline]
1873 pub fn set_value(
1874 &mut self,
1875 value: crate::data_capnp::asset_uuid::Reader<'_>,
1876 ) -> ::capnp::Result<()> {
1877 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
1878 self.builder.get_pointer_field(1),
1879 value,
1880 false,
1881 )
1882 }
1883
1884 #[inline]
1885 pub fn init_value(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
1886 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), 0)
1887 }
1888
1889 pub fn has_value(&self) -> bool {
1890 !self.builder.get_pointer_field(1).is_null()
1891 }
1892 }
1893
1894 pub struct Pipeline {
1895 _typeless: ::capnp::any_pointer::Pipeline,
1896 }
1897 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
1898 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
1899 Pipeline {
1900 _typeless: typeless,
1901 }
1902 }
1903 }
1904 impl Pipeline {
1905 pub fn get_key(&self) -> crate::data_capnp::asset_uuid::Pipeline {
1906 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
1907 }
1908
1909 pub fn get_value(&self) -> crate::data_capnp::asset_uuid::Pipeline {
1910 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(1))
1911 }
1912 }
1913 mod _private {
1914 use capnp::private::layout;
1915 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
1916 data: 0,
1917 pointers: 2,
1918 };
1919 pub const TYPE_ID: u64 = 0x8554_b162_a91b_eca6;
1920 }
1921}
1922
1923pub mod source_metadata {
1924 pub use self::Which::{Error, NoError};
1925
1926 #[derive(Copy, Clone)]
1927 pub struct Owned(());
1928 impl<'a> ::capnp::traits::Owned<'a> for Owned {
1929 type Builder = Builder<'a>;
1930 type Reader = Reader<'a>;
1931 }
1932 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
1933 type Builder = Builder<'a>;
1934 type Reader = Reader<'a>;
1935 }
1936 impl ::capnp::traits::Pipelined for Owned {
1937 type Pipeline = Pipeline;
1938 }
1939
1940 #[derive(Clone, Copy)]
1941 pub struct Reader<'a> {
1942 reader: ::capnp::private::layout::StructReader<'a>,
1943 }
1944
1945 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
1946 #[inline]
1947 fn type_id() -> u64 {
1948 _private::TYPE_ID
1949 }
1950 }
1951 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
1952 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
1953 Reader { reader }
1954 }
1955 }
1956
1957 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
1958 fn get_from_pointer(
1959 reader: &::capnp::private::layout::PointerReader<'a>,
1960 default: ::core::option::Option<&'a [capnp::Word]>,
1961 ) -> ::capnp::Result<Reader<'a>> {
1962 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
1963 reader.get_struct(default)?,
1964 ))
1965 }
1966 }
1967
1968 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
1969 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
1970 self.reader
1971 }
1972 }
1973
1974 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
1975 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
1976 self.reader
1977 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
1978 }
1979 }
1980
1981 impl<'a> Reader<'a> {
1982 pub fn reborrow(&self) -> Reader<'_> {
1983 Reader { ..*self }
1984 }
1985
1986 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
1987 self.reader.total_size()
1988 }
1989
1990 #[inline]
1991 pub fn get_assets(
1992 self,
1993 ) -> ::capnp::Result<
1994 ::capnp::struct_list::Reader<'a, crate::data_capnp::asset_metadata::Owned>,
1995 > {
1996 ::capnp::traits::FromPointerReader::get_from_pointer(
1997 &self.reader.get_pointer_field(0),
1998 ::core::option::Option::None,
1999 )
2000 }
2001
2002 pub fn has_assets(&self) -> bool {
2003 !self.reader.get_pointer_field(0).is_null()
2004 }
2005
2006 #[inline]
2007 pub fn get_importer_version(self) -> u32 {
2008 self.reader.get_data_field::<u32>(0)
2009 }
2010
2011 #[inline]
2012 pub fn get_importer_options_type(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
2013 ::capnp::traits::FromPointerReader::get_from_pointer(
2014 &self.reader.get_pointer_field(1),
2015 ::core::option::Option::None,
2016 )
2017 }
2018
2019 pub fn has_importer_options_type(&self) -> bool {
2020 !self.reader.get_pointer_field(1).is_null()
2021 }
2022
2023 #[inline]
2024 pub fn get_importer_options(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
2025 ::capnp::traits::FromPointerReader::get_from_pointer(
2026 &self.reader.get_pointer_field(2),
2027 ::core::option::Option::None,
2028 )
2029 }
2030
2031 pub fn has_importer_options(&self) -> bool {
2032 !self.reader.get_pointer_field(2).is_null()
2033 }
2034
2035 #[inline]
2036 pub fn get_importer_state_type(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
2037 ::capnp::traits::FromPointerReader::get_from_pointer(
2038 &self.reader.get_pointer_field(3),
2039 ::core::option::Option::None,
2040 )
2041 }
2042
2043 pub fn has_importer_state_type(&self) -> bool {
2044 !self.reader.get_pointer_field(3).is_null()
2045 }
2046
2047 #[inline]
2048 pub fn get_importer_state(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
2049 ::capnp::traits::FromPointerReader::get_from_pointer(
2050 &self.reader.get_pointer_field(4),
2051 ::core::option::Option::None,
2052 )
2053 }
2054
2055 pub fn has_importer_state(&self) -> bool {
2056 !self.reader.get_pointer_field(4).is_null()
2057 }
2058
2059 #[inline]
2060 pub fn get_build_pipelines(
2061 self,
2062 ) -> ::capnp::Result<
2063 ::capnp::struct_list::Reader<'a, crate::data_capnp::asset_uuid_pair::Owned>,
2064 > {
2065 ::capnp::traits::FromPointerReader::get_from_pointer(
2066 &self.reader.get_pointer_field(5),
2067 ::core::option::Option::None,
2068 )
2069 }
2070
2071 pub fn has_build_pipelines(&self) -> bool {
2072 !self.reader.get_pointer_field(5).is_null()
2073 }
2074
2075 #[inline]
2076 pub fn get_importer_type(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
2077 ::capnp::traits::FromPointerReader::get_from_pointer(
2078 &self.reader.get_pointer_field(6),
2079 ::core::option::Option::None,
2080 )
2081 }
2082
2083 pub fn has_importer_type(&self) -> bool {
2084 !self.reader.get_pointer_field(6).is_null()
2085 }
2086
2087 pub fn has_error(&self) -> bool {
2088 if self.reader.get_data_field::<u16>(2) != 0 {
2089 return false;
2090 }
2091 !self.reader.get_pointer_field(7).is_null()
2092 }
2093
2094 #[inline]
2095 pub fn get_path_refs(self) -> ::capnp::Result<::capnp::data_list::Reader<'a>> {
2096 ::capnp::traits::FromPointerReader::get_from_pointer(
2097 &self.reader.get_pointer_field(8),
2098 ::core::option::Option::None,
2099 )
2100 }
2101
2102 pub fn has_path_refs(&self) -> bool {
2103 !self.reader.get_pointer_field(8).is_null()
2104 }
2105
2106 #[inline]
2107 pub fn get_import_hash(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
2108 ::capnp::traits::FromPointerReader::get_from_pointer(
2109 &self.reader.get_pointer_field(9),
2110 ::core::option::Option::None,
2111 )
2112 }
2113
2114 pub fn has_import_hash(&self) -> bool {
2115 !self.reader.get_pointer_field(9).is_null()
2116 }
2117
2118 #[inline]
2119 pub fn get_version(self) -> u32 {
2120 self.reader.get_data_field::<u32>(2)
2121 }
2122
2123 #[inline]
2124 pub fn which(self) -> ::core::result::Result<WhichReader<'a>, ::capnp::NotInSchema> {
2125 match self.reader.get_data_field::<u16>(2) {
2126 0 => ::core::result::Result::Ok(Error(
2127 ::capnp::traits::FromPointerReader::get_from_pointer(
2128 &self.reader.get_pointer_field(7),
2129 ::core::option::Option::None,
2130 ),
2131 )),
2132 1 => ::core::result::Result::Ok(NoError(())),
2133 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
2134 }
2135 }
2136 }
2137
2138 pub struct Builder<'a> {
2139 builder: ::capnp::private::layout::StructBuilder<'a>,
2140 }
2141 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
2142 #[inline]
2143 fn struct_size() -> ::capnp::private::layout::StructSize {
2144 _private::STRUCT_SIZE
2145 }
2146 }
2147 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
2148 #[inline]
2149 fn type_id() -> u64 {
2150 _private::TYPE_ID
2151 }
2152 }
2153 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
2154 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
2155 Builder { builder }
2156 }
2157 }
2158
2159 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
2160 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
2161 self.builder
2162 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
2163 }
2164 }
2165
2166 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
2167 fn init_pointer(
2168 builder: ::capnp::private::layout::PointerBuilder<'a>,
2169 _size: u32,
2170 ) -> Builder<'a> {
2171 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
2172 }
2173
2174 fn get_from_pointer(
2175 builder: ::capnp::private::layout::PointerBuilder<'a>,
2176 default: ::core::option::Option<&'a [capnp::Word]>,
2177 ) -> ::capnp::Result<Builder<'a>> {
2178 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
2179 builder.get_struct(_private::STRUCT_SIZE, default)?,
2180 ))
2181 }
2182 }
2183
2184 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
2185 fn set_pointer_builder<'b>(
2186 pointer: ::capnp::private::layout::PointerBuilder<'b>,
2187 value: Reader<'a>,
2188 canonicalize: bool,
2189 ) -> ::capnp::Result<()> {
2190 pointer.set_struct(&value.reader, canonicalize)
2191 }
2192 }
2193
2194 impl<'a> Builder<'a> {
2195 pub fn into_reader(self) -> Reader<'a> {
2196 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
2197 }
2198
2199 pub fn reborrow(&mut self) -> Builder<'_> {
2200 Builder { ..*self }
2201 }
2202
2203 pub fn reborrow_as_reader(&self) -> Reader<'_> {
2204 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
2205 }
2206
2207 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
2208 self.builder.into_reader().total_size()
2209 }
2210
2211 #[inline]
2212 pub fn get_assets(
2213 self,
2214 ) -> ::capnp::Result<
2215 ::capnp::struct_list::Builder<'a, crate::data_capnp::asset_metadata::Owned>,
2216 > {
2217 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2218 self.builder.get_pointer_field(0),
2219 ::core::option::Option::None,
2220 )
2221 }
2222
2223 #[inline]
2224 pub fn set_assets(
2225 &mut self,
2226 value: ::capnp::struct_list::Reader<'a, crate::data_capnp::asset_metadata::Owned>,
2227 ) -> ::capnp::Result<()> {
2228 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
2229 self.builder.get_pointer_field(0),
2230 value,
2231 false,
2232 )
2233 }
2234
2235 #[inline]
2236 pub fn init_assets(
2237 self,
2238 size: u32,
2239 ) -> ::capnp::struct_list::Builder<'a, crate::data_capnp::asset_metadata::Owned> {
2240 ::capnp::traits::FromPointerBuilder::init_pointer(
2241 self.builder.get_pointer_field(0),
2242 size,
2243 )
2244 }
2245
2246 pub fn has_assets(&self) -> bool {
2247 !self.builder.get_pointer_field(0).is_null()
2248 }
2249
2250 #[inline]
2251 pub fn get_importer_version(self) -> u32 {
2252 self.builder.get_data_field::<u32>(0)
2253 }
2254
2255 #[inline]
2256 pub fn set_importer_version(&mut self, value: u32) {
2257 self.builder.set_data_field::<u32>(0, value);
2258 }
2259
2260 #[inline]
2261 pub fn get_importer_options_type(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
2262 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2263 self.builder.get_pointer_field(1),
2264 ::core::option::Option::None,
2265 )
2266 }
2267
2268 #[inline]
2269 pub fn set_importer_options_type(&mut self, value: ::capnp::data::Reader<'_>) {
2270 self.builder.get_pointer_field(1).set_data(value);
2271 }
2272
2273 #[inline]
2274 pub fn init_importer_options_type(self, size: u32) -> ::capnp::data::Builder<'a> {
2275 self.builder.get_pointer_field(1).init_data(size)
2276 }
2277
2278 pub fn has_importer_options_type(&self) -> bool {
2279 !self.builder.get_pointer_field(1).is_null()
2280 }
2281
2282 #[inline]
2283 pub fn get_importer_options(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
2284 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2285 self.builder.get_pointer_field(2),
2286 ::core::option::Option::None,
2287 )
2288 }
2289
2290 #[inline]
2291 pub fn set_importer_options(&mut self, value: ::capnp::data::Reader<'_>) {
2292 self.builder.get_pointer_field(2).set_data(value);
2293 }
2294
2295 #[inline]
2296 pub fn init_importer_options(self, size: u32) -> ::capnp::data::Builder<'a> {
2297 self.builder.get_pointer_field(2).init_data(size)
2298 }
2299
2300 pub fn has_importer_options(&self) -> bool {
2301 !self.builder.get_pointer_field(2).is_null()
2302 }
2303
2304 #[inline]
2305 pub fn get_importer_state_type(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
2306 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2307 self.builder.get_pointer_field(3),
2308 ::core::option::Option::None,
2309 )
2310 }
2311
2312 #[inline]
2313 pub fn set_importer_state_type(&mut self, value: ::capnp::data::Reader<'_>) {
2314 self.builder.get_pointer_field(3).set_data(value);
2315 }
2316
2317 #[inline]
2318 pub fn init_importer_state_type(self, size: u32) -> ::capnp::data::Builder<'a> {
2319 self.builder.get_pointer_field(3).init_data(size)
2320 }
2321
2322 pub fn has_importer_state_type(&self) -> bool {
2323 !self.builder.get_pointer_field(3).is_null()
2324 }
2325
2326 #[inline]
2327 pub fn get_importer_state(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
2328 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2329 self.builder.get_pointer_field(4),
2330 ::core::option::Option::None,
2331 )
2332 }
2333
2334 #[inline]
2335 pub fn set_importer_state(&mut self, value: ::capnp::data::Reader<'_>) {
2336 self.builder.get_pointer_field(4).set_data(value);
2337 }
2338
2339 #[inline]
2340 pub fn init_importer_state(self, size: u32) -> ::capnp::data::Builder<'a> {
2341 self.builder.get_pointer_field(4).init_data(size)
2342 }
2343
2344 pub fn has_importer_state(&self) -> bool {
2345 !self.builder.get_pointer_field(4).is_null()
2346 }
2347
2348 #[inline]
2349 pub fn get_build_pipelines(
2350 self,
2351 ) -> ::capnp::Result<
2352 ::capnp::struct_list::Builder<'a, crate::data_capnp::asset_uuid_pair::Owned>,
2353 > {
2354 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2355 self.builder.get_pointer_field(5),
2356 ::core::option::Option::None,
2357 )
2358 }
2359
2360 #[inline]
2361 pub fn set_build_pipelines(
2362 &mut self,
2363 value: ::capnp::struct_list::Reader<'a, crate::data_capnp::asset_uuid_pair::Owned>,
2364 ) -> ::capnp::Result<()> {
2365 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
2366 self.builder.get_pointer_field(5),
2367 value,
2368 false,
2369 )
2370 }
2371
2372 #[inline]
2373 pub fn init_build_pipelines(
2374 self,
2375 size: u32,
2376 ) -> ::capnp::struct_list::Builder<'a, crate::data_capnp::asset_uuid_pair::Owned> {
2377 ::capnp::traits::FromPointerBuilder::init_pointer(
2378 self.builder.get_pointer_field(5),
2379 size,
2380 )
2381 }
2382
2383 pub fn has_build_pipelines(&self) -> bool {
2384 !self.builder.get_pointer_field(5).is_null()
2385 }
2386
2387 #[inline]
2388 pub fn get_importer_type(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
2389 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2390 self.builder.get_pointer_field(6),
2391 ::core::option::Option::None,
2392 )
2393 }
2394
2395 #[inline]
2396 pub fn set_importer_type(&mut self, value: ::capnp::data::Reader<'_>) {
2397 self.builder.get_pointer_field(6).set_data(value);
2398 }
2399
2400 #[inline]
2401 pub fn init_importer_type(self, size: u32) -> ::capnp::data::Builder<'a> {
2402 self.builder.get_pointer_field(6).init_data(size)
2403 }
2404
2405 pub fn has_importer_type(&self) -> bool {
2406 !self.builder.get_pointer_field(6).is_null()
2407 }
2408
2409 #[inline]
2410 pub fn set_error(
2411 &mut self,
2412 value: crate::data_capnp::error::Reader<'_>,
2413 ) -> ::capnp::Result<()> {
2414 self.builder.set_data_field::<u16>(2, 0);
2415 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
2416 self.builder.get_pointer_field(7),
2417 value,
2418 false,
2419 )
2420 }
2421
2422 #[inline]
2423 pub fn init_error(self) -> crate::data_capnp::error::Builder<'a> {
2424 self.builder.set_data_field::<u16>(2, 0);
2425 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(7), 0)
2426 }
2427
2428 pub fn has_error(&self) -> bool {
2429 if self.builder.get_data_field::<u16>(2) != 0 {
2430 return false;
2431 }
2432 !self.builder.get_pointer_field(7).is_null()
2433 }
2434
2435 #[inline]
2436 pub fn set_no_error(&mut self, _value: ()) {
2437 self.builder.set_data_field::<u16>(2, 1);
2438 }
2439
2440 #[inline]
2441 pub fn get_path_refs(self) -> ::capnp::Result<::capnp::data_list::Builder<'a>> {
2442 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2443 self.builder.get_pointer_field(8),
2444 ::core::option::Option::None,
2445 )
2446 }
2447
2448 #[inline]
2449 pub fn set_path_refs(
2450 &mut self,
2451 value: ::capnp::data_list::Reader<'a>,
2452 ) -> ::capnp::Result<()> {
2453 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
2454 self.builder.get_pointer_field(8),
2455 value,
2456 false,
2457 )
2458 }
2459
2460 #[inline]
2461 pub fn init_path_refs(self, size: u32) -> ::capnp::data_list::Builder<'a> {
2462 ::capnp::traits::FromPointerBuilder::init_pointer(
2463 self.builder.get_pointer_field(8),
2464 size,
2465 )
2466 }
2467
2468 pub fn has_path_refs(&self) -> bool {
2469 !self.builder.get_pointer_field(8).is_null()
2470 }
2471
2472 #[inline]
2473 pub fn get_import_hash(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
2474 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2475 self.builder.get_pointer_field(9),
2476 ::core::option::Option::None,
2477 )
2478 }
2479
2480 #[inline]
2481 pub fn set_import_hash(&mut self, value: ::capnp::data::Reader<'_>) {
2482 self.builder.get_pointer_field(9).set_data(value);
2483 }
2484
2485 #[inline]
2486 pub fn init_import_hash(self, size: u32) -> ::capnp::data::Builder<'a> {
2487 self.builder.get_pointer_field(9).init_data(size)
2488 }
2489
2490 pub fn has_import_hash(&self) -> bool {
2491 !self.builder.get_pointer_field(9).is_null()
2492 }
2493
2494 #[inline]
2495 pub fn get_version(self) -> u32 {
2496 self.builder.get_data_field::<u32>(2)
2497 }
2498
2499 #[inline]
2500 pub fn set_version(&mut self, value: u32) {
2501 self.builder.set_data_field::<u32>(2, value);
2502 }
2503
2504 #[inline]
2505 pub fn which(self) -> ::core::result::Result<WhichBuilder<'a>, ::capnp::NotInSchema> {
2506 match self.builder.get_data_field::<u16>(2) {
2507 0 => ::core::result::Result::Ok(Error(
2508 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2509 self.builder.get_pointer_field(7),
2510 ::core::option::Option::None,
2511 ),
2512 )),
2513 1 => ::core::result::Result::Ok(NoError(())),
2514 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
2515 }
2516 }
2517 }
2518
2519 pub struct Pipeline {
2520 _typeless: ::capnp::any_pointer::Pipeline,
2521 }
2522 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
2523 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
2524 Pipeline {
2525 _typeless: typeless,
2526 }
2527 }
2528 }
2529 impl Pipeline {}
2530 mod _private {
2531 use capnp::private::layout;
2532 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
2533 data: 2,
2534 pointers: 10,
2535 };
2536 pub const TYPE_ID: u64 = 0x8b58_45d1_f338_0aa8;
2537 }
2538 pub enum Which<A0> {
2539 Error(A0),
2540 NoError(()),
2541 }
2542 pub type WhichReader<'a> = Which<::capnp::Result<crate::data_capnp::error::Reader<'a>>>;
2543 pub type WhichBuilder<'a> = Which<::capnp::Result<crate::data_capnp::error::Builder<'a>>>;
2544}
2545
2546pub mod path_refs {
2547 #[derive(Copy, Clone)]
2548 pub struct Owned(());
2549 impl<'a> ::capnp::traits::Owned<'a> for Owned {
2550 type Builder = Builder<'a>;
2551 type Reader = Reader<'a>;
2552 }
2553 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
2554 type Builder = Builder<'a>;
2555 type Reader = Reader<'a>;
2556 }
2557 impl ::capnp::traits::Pipelined for Owned {
2558 type Pipeline = Pipeline;
2559 }
2560
2561 #[derive(Clone, Copy)]
2562 pub struct Reader<'a> {
2563 reader: ::capnp::private::layout::StructReader<'a>,
2564 }
2565
2566 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
2567 #[inline]
2568 fn type_id() -> u64 {
2569 _private::TYPE_ID
2570 }
2571 }
2572 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
2573 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
2574 Reader { reader }
2575 }
2576 }
2577
2578 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
2579 fn get_from_pointer(
2580 reader: &::capnp::private::layout::PointerReader<'a>,
2581 default: ::core::option::Option<&'a [capnp::Word]>,
2582 ) -> ::capnp::Result<Reader<'a>> {
2583 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
2584 reader.get_struct(default)?,
2585 ))
2586 }
2587 }
2588
2589 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
2590 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
2591 self.reader
2592 }
2593 }
2594
2595 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
2596 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
2597 self.reader
2598 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
2599 }
2600 }
2601
2602 impl<'a> Reader<'a> {
2603 pub fn reborrow(&self) -> Reader<'_> {
2604 Reader { ..*self }
2605 }
2606
2607 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
2608 self.reader.total_size()
2609 }
2610
2611 #[inline]
2612 pub fn get_paths(self) -> ::capnp::Result<::capnp::data_list::Reader<'a>> {
2613 ::capnp::traits::FromPointerReader::get_from_pointer(
2614 &self.reader.get_pointer_field(0),
2615 ::core::option::Option::None,
2616 )
2617 }
2618
2619 pub fn has_paths(&self) -> bool {
2620 !self.reader.get_pointer_field(0).is_null()
2621 }
2622 }
2623
2624 pub struct Builder<'a> {
2625 builder: ::capnp::private::layout::StructBuilder<'a>,
2626 }
2627 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
2628 #[inline]
2629 fn struct_size() -> ::capnp::private::layout::StructSize {
2630 _private::STRUCT_SIZE
2631 }
2632 }
2633 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
2634 #[inline]
2635 fn type_id() -> u64 {
2636 _private::TYPE_ID
2637 }
2638 }
2639 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
2640 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
2641 Builder { builder }
2642 }
2643 }
2644
2645 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
2646 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
2647 self.builder
2648 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
2649 }
2650 }
2651
2652 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
2653 fn init_pointer(
2654 builder: ::capnp::private::layout::PointerBuilder<'a>,
2655 _size: u32,
2656 ) -> Builder<'a> {
2657 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
2658 }
2659
2660 fn get_from_pointer(
2661 builder: ::capnp::private::layout::PointerBuilder<'a>,
2662 default: ::core::option::Option<&'a [capnp::Word]>,
2663 ) -> ::capnp::Result<Builder<'a>> {
2664 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
2665 builder.get_struct(_private::STRUCT_SIZE, default)?,
2666 ))
2667 }
2668 }
2669
2670 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
2671 fn set_pointer_builder<'b>(
2672 pointer: ::capnp::private::layout::PointerBuilder<'b>,
2673 value: Reader<'a>,
2674 canonicalize: bool,
2675 ) -> ::capnp::Result<()> {
2676 pointer.set_struct(&value.reader, canonicalize)
2677 }
2678 }
2679
2680 impl<'a> Builder<'a> {
2681 pub fn into_reader(self) -> Reader<'a> {
2682 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
2683 }
2684
2685 pub fn reborrow(&mut self) -> Builder<'_> {
2686 Builder { ..*self }
2687 }
2688
2689 pub fn reborrow_as_reader(&self) -> Reader<'_> {
2690 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
2691 }
2692
2693 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
2694 self.builder.into_reader().total_size()
2695 }
2696
2697 #[inline]
2698 pub fn get_paths(self) -> ::capnp::Result<::capnp::data_list::Builder<'a>> {
2699 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2700 self.builder.get_pointer_field(0),
2701 ::core::option::Option::None,
2702 )
2703 }
2704
2705 #[inline]
2706 pub fn set_paths(&mut self, value: ::capnp::data_list::Reader<'a>) -> ::capnp::Result<()> {
2707 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
2708 self.builder.get_pointer_field(0),
2709 value,
2710 false,
2711 )
2712 }
2713
2714 #[inline]
2715 pub fn init_paths(self, size: u32) -> ::capnp::data_list::Builder<'a> {
2716 ::capnp::traits::FromPointerBuilder::init_pointer(
2717 self.builder.get_pointer_field(0),
2718 size,
2719 )
2720 }
2721
2722 pub fn has_paths(&self) -> bool {
2723 !self.builder.get_pointer_field(0).is_null()
2724 }
2725 }
2726
2727 pub struct Pipeline {
2728 _typeless: ::capnp::any_pointer::Pipeline,
2729 }
2730 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
2731 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
2732 Pipeline {
2733 _typeless: typeless,
2734 }
2735 }
2736 }
2737 impl Pipeline {}
2738 mod _private {
2739 use capnp::private::layout;
2740 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
2741 data: 0,
2742 pointers: 1,
2743 };
2744 pub const TYPE_ID: u64 = 0xfd78_1e49_39f5_8a57;
2745 }
2746}
2747
2748pub mod error {
2749 #[derive(Copy, Clone)]
2750 pub struct Owned(());
2751 impl<'a> ::capnp::traits::Owned<'a> for Owned {
2752 type Builder = Builder<'a>;
2753 type Reader = Reader<'a>;
2754 }
2755 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
2756 type Builder = Builder<'a>;
2757 type Reader = Reader<'a>;
2758 }
2759 impl ::capnp::traits::Pipelined for Owned {
2760 type Pipeline = Pipeline;
2761 }
2762
2763 #[derive(Clone, Copy)]
2764 pub struct Reader<'a> {
2765 reader: ::capnp::private::layout::StructReader<'a>,
2766 }
2767
2768 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
2769 #[inline]
2770 fn type_id() -> u64 {
2771 _private::TYPE_ID
2772 }
2773 }
2774 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
2775 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
2776 Reader { reader }
2777 }
2778 }
2779
2780 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
2781 fn get_from_pointer(
2782 reader: &::capnp::private::layout::PointerReader<'a>,
2783 default: ::core::option::Option<&'a [capnp::Word]>,
2784 ) -> ::capnp::Result<Reader<'a>> {
2785 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
2786 reader.get_struct(default)?,
2787 ))
2788 }
2789 }
2790
2791 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
2792 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
2793 self.reader
2794 }
2795 }
2796
2797 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
2798 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
2799 self.reader
2800 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
2801 }
2802 }
2803
2804 impl<'a> Reader<'a> {
2805 pub fn reborrow(&self) -> Reader<'_> {
2806 Reader { ..*self }
2807 }
2808
2809 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
2810 self.reader.total_size()
2811 }
2812
2813 #[inline]
2814 pub fn get_text(self) -> ::capnp::Result<::capnp::text::Reader<'a>> {
2815 ::capnp::traits::FromPointerReader::get_from_pointer(
2816 &self.reader.get_pointer_field(0),
2817 ::core::option::Option::None,
2818 )
2819 }
2820
2821 pub fn has_text(&self) -> bool {
2822 !self.reader.get_pointer_field(0).is_null()
2823 }
2824 }
2825
2826 pub struct Builder<'a> {
2827 builder: ::capnp::private::layout::StructBuilder<'a>,
2828 }
2829 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
2830 #[inline]
2831 fn struct_size() -> ::capnp::private::layout::StructSize {
2832 _private::STRUCT_SIZE
2833 }
2834 }
2835 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
2836 #[inline]
2837 fn type_id() -> u64 {
2838 _private::TYPE_ID
2839 }
2840 }
2841 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
2842 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
2843 Builder { builder }
2844 }
2845 }
2846
2847 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
2848 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
2849 self.builder
2850 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
2851 }
2852 }
2853
2854 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
2855 fn init_pointer(
2856 builder: ::capnp::private::layout::PointerBuilder<'a>,
2857 _size: u32,
2858 ) -> Builder<'a> {
2859 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
2860 }
2861
2862 fn get_from_pointer(
2863 builder: ::capnp::private::layout::PointerBuilder<'a>,
2864 default: ::core::option::Option<&'a [capnp::Word]>,
2865 ) -> ::capnp::Result<Builder<'a>> {
2866 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
2867 builder.get_struct(_private::STRUCT_SIZE, default)?,
2868 ))
2869 }
2870 }
2871
2872 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
2873 fn set_pointer_builder<'b>(
2874 pointer: ::capnp::private::layout::PointerBuilder<'b>,
2875 value: Reader<'a>,
2876 canonicalize: bool,
2877 ) -> ::capnp::Result<()> {
2878 pointer.set_struct(&value.reader, canonicalize)
2879 }
2880 }
2881
2882 impl<'a> Builder<'a> {
2883 pub fn into_reader(self) -> Reader<'a> {
2884 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
2885 }
2886
2887 pub fn reborrow(&mut self) -> Builder<'_> {
2888 Builder { ..*self }
2889 }
2890
2891 pub fn reborrow_as_reader(&self) -> Reader<'_> {
2892 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
2893 }
2894
2895 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
2896 self.builder.into_reader().total_size()
2897 }
2898
2899 #[inline]
2900 pub fn get_text(self) -> ::capnp::Result<::capnp::text::Builder<'a>> {
2901 ::capnp::traits::FromPointerBuilder::get_from_pointer(
2902 self.builder.get_pointer_field(0),
2903 ::core::option::Option::None,
2904 )
2905 }
2906
2907 #[inline]
2908 pub fn set_text(&mut self, value: ::capnp::text::Reader<'_>) {
2909 self.builder.get_pointer_field(0).set_text(value);
2910 }
2911
2912 #[inline]
2913 pub fn init_text(self, size: u32) -> ::capnp::text::Builder<'a> {
2914 self.builder.get_pointer_field(0).init_text(size)
2915 }
2916
2917 pub fn has_text(&self) -> bool {
2918 !self.builder.get_pointer_field(0).is_null()
2919 }
2920 }
2921
2922 pub struct Pipeline {
2923 _typeless: ::capnp::any_pointer::Pipeline,
2924 }
2925 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
2926 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
2927 Pipeline {
2928 _typeless: typeless,
2929 }
2930 }
2931 }
2932 impl Pipeline {}
2933 mod _private {
2934 use capnp::private::layout;
2935 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
2936 data: 0,
2937 pointers: 1,
2938 };
2939 pub const TYPE_ID: u64 = 0xb4fb_1c2a_2b80_cbd6;
2940 }
2941}
2942
2943pub mod artifact_metadata {
2944 #[derive(Copy, Clone)]
2945 pub struct Owned(());
2946 impl<'a> ::capnp::traits::Owned<'a> for Owned {
2947 type Builder = Builder<'a>;
2948 type Reader = Reader<'a>;
2949 }
2950 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
2951 type Builder = Builder<'a>;
2952 type Reader = Reader<'a>;
2953 }
2954 impl ::capnp::traits::Pipelined for Owned {
2955 type Pipeline = Pipeline;
2956 }
2957
2958 #[derive(Clone, Copy)]
2959 pub struct Reader<'a> {
2960 reader: ::capnp::private::layout::StructReader<'a>,
2961 }
2962
2963 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
2964 #[inline]
2965 fn type_id() -> u64 {
2966 _private::TYPE_ID
2967 }
2968 }
2969 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
2970 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
2971 Reader { reader }
2972 }
2973 }
2974
2975 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
2976 fn get_from_pointer(
2977 reader: &::capnp::private::layout::PointerReader<'a>,
2978 default: ::core::option::Option<&'a [capnp::Word]>,
2979 ) -> ::capnp::Result<Reader<'a>> {
2980 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
2981 reader.get_struct(default)?,
2982 ))
2983 }
2984 }
2985
2986 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
2987 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
2988 self.reader
2989 }
2990 }
2991
2992 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
2993 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
2994 self.reader
2995 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
2996 }
2997 }
2998
2999 impl<'a> Reader<'a> {
3000 pub fn reborrow(&self) -> Reader<'_> {
3001 Reader { ..*self }
3002 }
3003
3004 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
3005 self.reader.total_size()
3006 }
3007
3008 #[inline]
3009 pub fn get_asset_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>> {
3010 ::capnp::traits::FromPointerReader::get_from_pointer(
3011 &self.reader.get_pointer_field(0),
3012 ::core::option::Option::None,
3013 )
3014 }
3015
3016 pub fn has_asset_id(&self) -> bool {
3017 !self.reader.get_pointer_field(0).is_null()
3018 }
3019
3020 #[inline]
3021 pub fn get_hash(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
3022 ::capnp::traits::FromPointerReader::get_from_pointer(
3023 &self.reader.get_pointer_field(1),
3024 ::core::option::Option::None,
3025 )
3026 }
3027
3028 pub fn has_hash(&self) -> bool {
3029 !self.reader.get_pointer_field(1).is_null()
3030 }
3031
3032 #[inline]
3033 pub fn get_load_deps(
3034 self,
3035 ) -> ::capnp::Result<::capnp::struct_list::Reader<'a, crate::data_capnp::asset_ref::Owned>>
3036 {
3037 ::capnp::traits::FromPointerReader::get_from_pointer(
3038 &self.reader.get_pointer_field(2),
3039 ::core::option::Option::None,
3040 )
3041 }
3042
3043 pub fn has_load_deps(&self) -> bool {
3044 !self.reader.get_pointer_field(2).is_null()
3045 }
3046
3047 #[inline]
3048 pub fn get_build_deps(
3049 self,
3050 ) -> ::capnp::Result<::capnp::struct_list::Reader<'a, crate::data_capnp::asset_ref::Owned>>
3051 {
3052 ::capnp::traits::FromPointerReader::get_from_pointer(
3053 &self.reader.get_pointer_field(3),
3054 ::core::option::Option::None,
3055 )
3056 }
3057
3058 pub fn has_build_deps(&self) -> bool {
3059 !self.reader.get_pointer_field(3).is_null()
3060 }
3061
3062 #[inline]
3063 pub fn get_compression(
3064 self,
3065 ) -> ::core::result::Result<crate::data_capnp::CompressionType, ::capnp::NotInSchema>
3066 {
3067 ::capnp::traits::FromU16::from_u16(self.reader.get_data_field::<u16>(0))
3068 }
3069
3070 #[inline]
3071 pub fn get_compressed_size(self) -> u64 {
3072 self.reader.get_data_field::<u64>(1)
3073 }
3074
3075 #[inline]
3076 pub fn get_uncompressed_size(self) -> u64 {
3077 self.reader.get_data_field::<u64>(2)
3078 }
3079
3080 #[inline]
3081 pub fn get_type_id(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
3082 ::capnp::traits::FromPointerReader::get_from_pointer(
3083 &self.reader.get_pointer_field(4),
3084 ::core::option::Option::None,
3085 )
3086 }
3087
3088 pub fn has_type_id(&self) -> bool {
3089 !self.reader.get_pointer_field(4).is_null()
3090 }
3091 }
3092
3093 pub struct Builder<'a> {
3094 builder: ::capnp::private::layout::StructBuilder<'a>,
3095 }
3096 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
3097 #[inline]
3098 fn struct_size() -> ::capnp::private::layout::StructSize {
3099 _private::STRUCT_SIZE
3100 }
3101 }
3102 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
3103 #[inline]
3104 fn type_id() -> u64 {
3105 _private::TYPE_ID
3106 }
3107 }
3108 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
3109 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
3110 Builder { builder }
3111 }
3112 }
3113
3114 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
3115 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
3116 self.builder
3117 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
3118 }
3119 }
3120
3121 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
3122 fn init_pointer(
3123 builder: ::capnp::private::layout::PointerBuilder<'a>,
3124 _size: u32,
3125 ) -> Builder<'a> {
3126 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
3127 }
3128
3129 fn get_from_pointer(
3130 builder: ::capnp::private::layout::PointerBuilder<'a>,
3131 default: ::core::option::Option<&'a [capnp::Word]>,
3132 ) -> ::capnp::Result<Builder<'a>> {
3133 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
3134 builder.get_struct(_private::STRUCT_SIZE, default)?,
3135 ))
3136 }
3137 }
3138
3139 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
3140 fn set_pointer_builder<'b>(
3141 pointer: ::capnp::private::layout::PointerBuilder<'b>,
3142 value: Reader<'a>,
3143 canonicalize: bool,
3144 ) -> ::capnp::Result<()> {
3145 pointer.set_struct(&value.reader, canonicalize)
3146 }
3147 }
3148
3149 impl<'a> Builder<'a> {
3150 pub fn into_reader(self) -> Reader<'a> {
3151 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
3152 }
3153
3154 pub fn reborrow(&mut self) -> Builder<'_> {
3155 Builder { ..*self }
3156 }
3157
3158 pub fn reborrow_as_reader(&self) -> Reader<'_> {
3159 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
3160 }
3161
3162 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
3163 self.builder.into_reader().total_size()
3164 }
3165
3166 #[inline]
3167 pub fn get_asset_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>> {
3168 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3169 self.builder.get_pointer_field(0),
3170 ::core::option::Option::None,
3171 )
3172 }
3173
3174 #[inline]
3175 pub fn set_asset_id(
3176 &mut self,
3177 value: crate::data_capnp::asset_uuid::Reader<'_>,
3178 ) -> ::capnp::Result<()> {
3179 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3180 self.builder.get_pointer_field(0),
3181 value,
3182 false,
3183 )
3184 }
3185
3186 #[inline]
3187 pub fn init_asset_id(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
3188 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
3189 }
3190
3191 pub fn has_asset_id(&self) -> bool {
3192 !self.builder.get_pointer_field(0).is_null()
3193 }
3194
3195 #[inline]
3196 pub fn get_hash(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
3197 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3198 self.builder.get_pointer_field(1),
3199 ::core::option::Option::None,
3200 )
3201 }
3202
3203 #[inline]
3204 pub fn set_hash(&mut self, value: ::capnp::data::Reader<'_>) {
3205 self.builder.get_pointer_field(1).set_data(value);
3206 }
3207
3208 #[inline]
3209 pub fn init_hash(self, size: u32) -> ::capnp::data::Builder<'a> {
3210 self.builder.get_pointer_field(1).init_data(size)
3211 }
3212
3213 pub fn has_hash(&self) -> bool {
3214 !self.builder.get_pointer_field(1).is_null()
3215 }
3216
3217 #[inline]
3218 pub fn get_load_deps(
3219 self,
3220 ) -> ::capnp::Result<::capnp::struct_list::Builder<'a, crate::data_capnp::asset_ref::Owned>>
3221 {
3222 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3223 self.builder.get_pointer_field(2),
3224 ::core::option::Option::None,
3225 )
3226 }
3227
3228 #[inline]
3229 pub fn set_load_deps(
3230 &mut self,
3231 value: ::capnp::struct_list::Reader<'a, crate::data_capnp::asset_ref::Owned>,
3232 ) -> ::capnp::Result<()> {
3233 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3234 self.builder.get_pointer_field(2),
3235 value,
3236 false,
3237 )
3238 }
3239
3240 #[inline]
3241 pub fn init_load_deps(
3242 self,
3243 size: u32,
3244 ) -> ::capnp::struct_list::Builder<'a, crate::data_capnp::asset_ref::Owned> {
3245 ::capnp::traits::FromPointerBuilder::init_pointer(
3246 self.builder.get_pointer_field(2),
3247 size,
3248 )
3249 }
3250
3251 pub fn has_load_deps(&self) -> bool {
3252 !self.builder.get_pointer_field(2).is_null()
3253 }
3254
3255 #[inline]
3256 pub fn get_build_deps(
3257 self,
3258 ) -> ::capnp::Result<::capnp::struct_list::Builder<'a, crate::data_capnp::asset_ref::Owned>>
3259 {
3260 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3261 self.builder.get_pointer_field(3),
3262 ::core::option::Option::None,
3263 )
3264 }
3265
3266 #[inline]
3267 pub fn set_build_deps(
3268 &mut self,
3269 value: ::capnp::struct_list::Reader<'a, crate::data_capnp::asset_ref::Owned>,
3270 ) -> ::capnp::Result<()> {
3271 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3272 self.builder.get_pointer_field(3),
3273 value,
3274 false,
3275 )
3276 }
3277
3278 #[inline]
3279 pub fn init_build_deps(
3280 self,
3281 size: u32,
3282 ) -> ::capnp::struct_list::Builder<'a, crate::data_capnp::asset_ref::Owned> {
3283 ::capnp::traits::FromPointerBuilder::init_pointer(
3284 self.builder.get_pointer_field(3),
3285 size,
3286 )
3287 }
3288
3289 pub fn has_build_deps(&self) -> bool {
3290 !self.builder.get_pointer_field(3).is_null()
3291 }
3292
3293 #[inline]
3294 pub fn get_compression(
3295 self,
3296 ) -> ::core::result::Result<crate::data_capnp::CompressionType, ::capnp::NotInSchema>
3297 {
3298 ::capnp::traits::FromU16::from_u16(self.builder.get_data_field::<u16>(0))
3299 }
3300
3301 #[inline]
3302 pub fn set_compression(&mut self, value: crate::data_capnp::CompressionType) {
3303 self.builder.set_data_field::<u16>(0, value as u16)
3304 }
3305
3306 #[inline]
3307 pub fn get_compressed_size(self) -> u64 {
3308 self.builder.get_data_field::<u64>(1)
3309 }
3310
3311 #[inline]
3312 pub fn set_compressed_size(&mut self, value: u64) {
3313 self.builder.set_data_field::<u64>(1, value);
3314 }
3315
3316 #[inline]
3317 pub fn get_uncompressed_size(self) -> u64 {
3318 self.builder.get_data_field::<u64>(2)
3319 }
3320
3321 #[inline]
3322 pub fn set_uncompressed_size(&mut self, value: u64) {
3323 self.builder.set_data_field::<u64>(2, value);
3324 }
3325
3326 #[inline]
3327 pub fn get_type_id(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
3328 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3329 self.builder.get_pointer_field(4),
3330 ::core::option::Option::None,
3331 )
3332 }
3333
3334 #[inline]
3335 pub fn set_type_id(&mut self, value: ::capnp::data::Reader<'_>) {
3336 self.builder.get_pointer_field(4).set_data(value);
3337 }
3338
3339 #[inline]
3340 pub fn init_type_id(self, size: u32) -> ::capnp::data::Builder<'a> {
3341 self.builder.get_pointer_field(4).init_data(size)
3342 }
3343
3344 pub fn has_type_id(&self) -> bool {
3345 !self.builder.get_pointer_field(4).is_null()
3346 }
3347 }
3348
3349 pub struct Pipeline {
3350 _typeless: ::capnp::any_pointer::Pipeline,
3351 }
3352 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
3353 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
3354 Pipeline {
3355 _typeless: typeless,
3356 }
3357 }
3358 }
3359 impl Pipeline {
3360 pub fn get_asset_id(&self) -> crate::data_capnp::asset_uuid::Pipeline {
3361 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
3362 }
3363 }
3364 mod _private {
3365 use capnp::private::layout;
3366 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
3367 data: 3,
3368 pointers: 5,
3369 };
3370 pub const TYPE_ID: u64 = 0xf0ac_1e9d_bec2_4dbf;
3371 }
3372}
3373
3374pub mod asset_metadata {
3375 pub use self::Which::{Error, NoError};
3376
3377 #[derive(Copy, Clone)]
3378 pub struct Owned(());
3379 impl<'a> ::capnp::traits::Owned<'a> for Owned {
3380 type Builder = Builder<'a>;
3381 type Reader = Reader<'a>;
3382 }
3383 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
3384 type Builder = Builder<'a>;
3385 type Reader = Reader<'a>;
3386 }
3387 impl ::capnp::traits::Pipelined for Owned {
3388 type Pipeline = Pipeline;
3389 }
3390
3391 #[derive(Clone, Copy)]
3392 pub struct Reader<'a> {
3393 reader: ::capnp::private::layout::StructReader<'a>,
3394 }
3395
3396 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
3397 #[inline]
3398 fn type_id() -> u64 {
3399 _private::TYPE_ID
3400 }
3401 }
3402 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
3403 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
3404 Reader { reader }
3405 }
3406 }
3407
3408 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
3409 fn get_from_pointer(
3410 reader: &::capnp::private::layout::PointerReader<'a>,
3411 default: ::core::option::Option<&'a [capnp::Word]>,
3412 ) -> ::capnp::Result<Reader<'a>> {
3413 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
3414 reader.get_struct(default)?,
3415 ))
3416 }
3417 }
3418
3419 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
3420 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
3421 self.reader
3422 }
3423 }
3424
3425 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
3426 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
3427 self.reader
3428 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
3429 }
3430 }
3431
3432 impl<'a> Reader<'a> {
3433 pub fn reborrow(&self) -> Reader<'_> {
3434 Reader { ..*self }
3435 }
3436
3437 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
3438 self.reader.total_size()
3439 }
3440
3441 #[inline]
3442 pub fn get_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>> {
3443 ::capnp::traits::FromPointerReader::get_from_pointer(
3444 &self.reader.get_pointer_field(0),
3445 ::core::option::Option::None,
3446 )
3447 }
3448
3449 pub fn has_id(&self) -> bool {
3450 !self.reader.get_pointer_field(0).is_null()
3451 }
3452
3453 #[inline]
3454 pub fn get_search_tags(
3455 self,
3456 ) -> ::capnp::Result<::capnp::struct_list::Reader<'a, crate::data_capnp::key_value::Owned>>
3457 {
3458 ::capnp::traits::FromPointerReader::get_from_pointer(
3459 &self.reader.get_pointer_field(1),
3460 ::core::option::Option::None,
3461 )
3462 }
3463
3464 pub fn has_search_tags(&self) -> bool {
3465 !self.reader.get_pointer_field(1).is_null()
3466 }
3467
3468 #[inline]
3469 pub fn get_build_pipeline(
3470 self,
3471 ) -> ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>> {
3472 ::capnp::traits::FromPointerReader::get_from_pointer(
3473 &self.reader.get_pointer_field(2),
3474 ::core::option::Option::None,
3475 )
3476 }
3477
3478 pub fn has_build_pipeline(&self) -> bool {
3479 !self.reader.get_pointer_field(2).is_null()
3480 }
3481
3482 #[inline]
3483 pub fn get_latest_artifact(
3484 self,
3485 ) -> crate::data_capnp::asset_metadata::latest_artifact::Reader<'a> {
3486 ::capnp::traits::FromStructReader::new(self.reader)
3487 }
3488
3489 #[inline]
3490 pub fn get_source(
3491 self,
3492 ) -> ::core::result::Result<crate::data_capnp::AssetSource, ::capnp::NotInSchema> {
3493 ::capnp::traits::FromU16::from_u16(self.reader.get_data_field::<u16>(1))
3494 }
3495
3496 pub fn has_error(&self) -> bool {
3497 if self.reader.get_data_field::<u16>(2) != 0 {
3498 return false;
3499 }
3500 !self.reader.get_pointer_field(4).is_null()
3501 }
3502
3503 #[inline]
3504 pub fn which(self) -> ::core::result::Result<WhichReader<'a>, ::capnp::NotInSchema> {
3505 match self.reader.get_data_field::<u16>(2) {
3506 0 => ::core::result::Result::Ok(Error(
3507 ::capnp::traits::FromPointerReader::get_from_pointer(
3508 &self.reader.get_pointer_field(4),
3509 ::core::option::Option::None,
3510 ),
3511 )),
3512 1 => ::core::result::Result::Ok(NoError(())),
3513 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
3514 }
3515 }
3516 }
3517
3518 pub struct Builder<'a> {
3519 builder: ::capnp::private::layout::StructBuilder<'a>,
3520 }
3521 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
3522 #[inline]
3523 fn struct_size() -> ::capnp::private::layout::StructSize {
3524 _private::STRUCT_SIZE
3525 }
3526 }
3527 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
3528 #[inline]
3529 fn type_id() -> u64 {
3530 _private::TYPE_ID
3531 }
3532 }
3533 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
3534 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
3535 Builder { builder }
3536 }
3537 }
3538
3539 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
3540 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
3541 self.builder
3542 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
3543 }
3544 }
3545
3546 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
3547 fn init_pointer(
3548 builder: ::capnp::private::layout::PointerBuilder<'a>,
3549 _size: u32,
3550 ) -> Builder<'a> {
3551 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
3552 }
3553
3554 fn get_from_pointer(
3555 builder: ::capnp::private::layout::PointerBuilder<'a>,
3556 default: ::core::option::Option<&'a [capnp::Word]>,
3557 ) -> ::capnp::Result<Builder<'a>> {
3558 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
3559 builder.get_struct(_private::STRUCT_SIZE, default)?,
3560 ))
3561 }
3562 }
3563
3564 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
3565 fn set_pointer_builder<'b>(
3566 pointer: ::capnp::private::layout::PointerBuilder<'b>,
3567 value: Reader<'a>,
3568 canonicalize: bool,
3569 ) -> ::capnp::Result<()> {
3570 pointer.set_struct(&value.reader, canonicalize)
3571 }
3572 }
3573
3574 impl<'a> Builder<'a> {
3575 pub fn into_reader(self) -> Reader<'a> {
3576 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
3577 }
3578
3579 pub fn reborrow(&mut self) -> Builder<'_> {
3580 Builder { ..*self }
3581 }
3582
3583 pub fn reborrow_as_reader(&self) -> Reader<'_> {
3584 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
3585 }
3586
3587 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
3588 self.builder.into_reader().total_size()
3589 }
3590
3591 #[inline]
3592 pub fn get_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>> {
3593 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3594 self.builder.get_pointer_field(0),
3595 ::core::option::Option::None,
3596 )
3597 }
3598
3599 #[inline]
3600 pub fn set_id(
3601 &mut self,
3602 value: crate::data_capnp::asset_uuid::Reader<'_>,
3603 ) -> ::capnp::Result<()> {
3604 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3605 self.builder.get_pointer_field(0),
3606 value,
3607 false,
3608 )
3609 }
3610
3611 #[inline]
3612 pub fn init_id(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
3613 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
3614 }
3615
3616 pub fn has_id(&self) -> bool {
3617 !self.builder.get_pointer_field(0).is_null()
3618 }
3619
3620 #[inline]
3621 pub fn get_search_tags(
3622 self,
3623 ) -> ::capnp::Result<::capnp::struct_list::Builder<'a, crate::data_capnp::key_value::Owned>>
3624 {
3625 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3626 self.builder.get_pointer_field(1),
3627 ::core::option::Option::None,
3628 )
3629 }
3630
3631 #[inline]
3632 pub fn set_search_tags(
3633 &mut self,
3634 value: ::capnp::struct_list::Reader<'a, crate::data_capnp::key_value::Owned>,
3635 ) -> ::capnp::Result<()> {
3636 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3637 self.builder.get_pointer_field(1),
3638 value,
3639 false,
3640 )
3641 }
3642
3643 #[inline]
3644 pub fn init_search_tags(
3645 self,
3646 size: u32,
3647 ) -> ::capnp::struct_list::Builder<'a, crate::data_capnp::key_value::Owned> {
3648 ::capnp::traits::FromPointerBuilder::init_pointer(
3649 self.builder.get_pointer_field(1),
3650 size,
3651 )
3652 }
3653
3654 pub fn has_search_tags(&self) -> bool {
3655 !self.builder.get_pointer_field(1).is_null()
3656 }
3657
3658 #[inline]
3659 pub fn get_build_pipeline(
3660 self,
3661 ) -> ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>> {
3662 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3663 self.builder.get_pointer_field(2),
3664 ::core::option::Option::None,
3665 )
3666 }
3667
3668 #[inline]
3669 pub fn set_build_pipeline(
3670 &mut self,
3671 value: crate::data_capnp::asset_uuid::Reader<'_>,
3672 ) -> ::capnp::Result<()> {
3673 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3674 self.builder.get_pointer_field(2),
3675 value,
3676 false,
3677 )
3678 }
3679
3680 #[inline]
3681 pub fn init_build_pipeline(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
3682 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(2), 0)
3683 }
3684
3685 pub fn has_build_pipeline(&self) -> bool {
3686 !self.builder.get_pointer_field(2).is_null()
3687 }
3688
3689 #[inline]
3690 pub fn get_latest_artifact(
3691 self,
3692 ) -> crate::data_capnp::asset_metadata::latest_artifact::Builder<'a> {
3693 ::capnp::traits::FromStructBuilder::new(self.builder)
3694 }
3695
3696 #[inline]
3697 pub fn init_latest_artifact(
3698 self,
3699 ) -> crate::data_capnp::asset_metadata::latest_artifact::Builder<'a> {
3700 self.builder.set_data_field::<u16>(0, 0);
3701 self.builder.get_pointer_field(3).clear();
3702 ::capnp::traits::FromStructBuilder::new(self.builder)
3703 }
3704
3705 #[inline]
3706 pub fn get_source(
3707 self,
3708 ) -> ::core::result::Result<crate::data_capnp::AssetSource, ::capnp::NotInSchema> {
3709 ::capnp::traits::FromU16::from_u16(self.builder.get_data_field::<u16>(1))
3710 }
3711
3712 #[inline]
3713 pub fn set_source(&mut self, value: crate::data_capnp::AssetSource) {
3714 self.builder.set_data_field::<u16>(1, value as u16)
3715 }
3716
3717 #[inline]
3718 pub fn set_error(
3719 &mut self,
3720 value: crate::data_capnp::error::Reader<'_>,
3721 ) -> ::capnp::Result<()> {
3722 self.builder.set_data_field::<u16>(2, 0);
3723 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3724 self.builder.get_pointer_field(4),
3725 value,
3726 false,
3727 )
3728 }
3729
3730 #[inline]
3731 pub fn init_error(self) -> crate::data_capnp::error::Builder<'a> {
3732 self.builder.set_data_field::<u16>(2, 0);
3733 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(4), 0)
3734 }
3735
3736 pub fn has_error(&self) -> bool {
3737 if self.builder.get_data_field::<u16>(2) != 0 {
3738 return false;
3739 }
3740 !self.builder.get_pointer_field(4).is_null()
3741 }
3742
3743 #[inline]
3744 pub fn set_no_error(&mut self, _value: ()) {
3745 self.builder.set_data_field::<u16>(2, 1);
3746 }
3747
3748 #[inline]
3749 pub fn which(self) -> ::core::result::Result<WhichBuilder<'a>, ::capnp::NotInSchema> {
3750 match self.builder.get_data_field::<u16>(2) {
3751 0 => ::core::result::Result::Ok(Error(
3752 ::capnp::traits::FromPointerBuilder::get_from_pointer(
3753 self.builder.get_pointer_field(4),
3754 ::core::option::Option::None,
3755 ),
3756 )),
3757 1 => ::core::result::Result::Ok(NoError(())),
3758 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
3759 }
3760 }
3761 }
3762
3763 pub struct Pipeline {
3764 _typeless: ::capnp::any_pointer::Pipeline,
3765 }
3766 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
3767 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
3768 Pipeline {
3769 _typeless: typeless,
3770 }
3771 }
3772 }
3773 impl Pipeline {
3774 pub fn get_id(&self) -> crate::data_capnp::asset_uuid::Pipeline {
3775 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
3776 }
3777
3778 pub fn get_build_pipeline(&self) -> crate::data_capnp::asset_uuid::Pipeline {
3779 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(2))
3780 }
3781
3782 pub fn get_latest_artifact(
3783 &self,
3784 ) -> crate::data_capnp::asset_metadata::latest_artifact::Pipeline {
3785 ::capnp::capability::FromTypelessPipeline::new(self._typeless.noop())
3786 }
3787 }
3788 mod _private {
3789 use capnp::private::layout;
3790 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
3791 data: 1,
3792 pointers: 5,
3793 };
3794 pub const TYPE_ID: u64 = 0xd390_2cad_76fc_fde0;
3795 }
3796 pub enum Which<A0> {
3797 Error(A0),
3798 NoError(()),
3799 }
3800 pub type WhichReader<'a> = Which<::capnp::Result<crate::data_capnp::error::Reader<'a>>>;
3801 pub type WhichBuilder<'a> = Which<::capnp::Result<crate::data_capnp::error::Builder<'a>>>;
3802
3803 pub mod latest_artifact {
3804 pub use self::Which::{Artifact, None};
3805
3806 #[derive(Copy, Clone)]
3807 pub struct Owned(());
3808 impl<'a> ::capnp::traits::Owned<'a> for Owned {
3809 type Builder = Builder<'a>;
3810 type Reader = Reader<'a>;
3811 }
3812 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
3813 type Builder = Builder<'a>;
3814 type Reader = Reader<'a>;
3815 }
3816 impl ::capnp::traits::Pipelined for Owned {
3817 type Pipeline = Pipeline;
3818 }
3819
3820 #[derive(Clone, Copy)]
3821 pub struct Reader<'a> {
3822 reader: ::capnp::private::layout::StructReader<'a>,
3823 }
3824
3825 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
3826 #[inline]
3827 fn type_id() -> u64 {
3828 _private::TYPE_ID
3829 }
3830 }
3831 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
3832 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
3833 Reader { reader }
3834 }
3835 }
3836
3837 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
3838 fn get_from_pointer(
3839 reader: &::capnp::private::layout::PointerReader<'a>,
3840 default: ::core::option::Option<&'a [capnp::Word]>,
3841 ) -> ::capnp::Result<Reader<'a>> {
3842 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
3843 reader.get_struct(default)?,
3844 ))
3845 }
3846 }
3847
3848 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
3849 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
3850 self.reader
3851 }
3852 }
3853
3854 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
3855 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
3856 self.reader
3857 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
3858 }
3859 }
3860
3861 impl<'a> Reader<'a> {
3862 pub fn reborrow(&self) -> Reader<'_> {
3863 Reader { ..*self }
3864 }
3865
3866 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
3867 self.reader.total_size()
3868 }
3869
3870 pub fn has_artifact(&self) -> bool {
3871 if self.reader.get_data_field::<u16>(0) != 0 {
3872 return false;
3873 }
3874 !self.reader.get_pointer_field(3).is_null()
3875 }
3876
3877 #[inline]
3878 pub fn which(self) -> ::core::result::Result<WhichReader<'a>, ::capnp::NotInSchema> {
3879 match self.reader.get_data_field::<u16>(0) {
3880 0 => ::core::result::Result::Ok(Artifact(
3881 ::capnp::traits::FromPointerReader::get_from_pointer(
3882 &self.reader.get_pointer_field(3),
3883 ::core::option::Option::None,
3884 ),
3885 )),
3886 1 => ::core::result::Result::Ok(None(())),
3887 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
3888 }
3889 }
3890 }
3891
3892 pub struct Builder<'a> {
3893 builder: ::capnp::private::layout::StructBuilder<'a>,
3894 }
3895 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
3896 #[inline]
3897 fn struct_size() -> ::capnp::private::layout::StructSize {
3898 _private::STRUCT_SIZE
3899 }
3900 }
3901 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
3902 #[inline]
3903 fn type_id() -> u64 {
3904 _private::TYPE_ID
3905 }
3906 }
3907 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
3908 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
3909 Builder { builder }
3910 }
3911 }
3912
3913 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
3914 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
3915 self.builder
3916 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
3917 }
3918 }
3919
3920 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
3921 fn init_pointer(
3922 builder: ::capnp::private::layout::PointerBuilder<'a>,
3923 _size: u32,
3924 ) -> Builder<'a> {
3925 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
3926 }
3927
3928 fn get_from_pointer(
3929 builder: ::capnp::private::layout::PointerBuilder<'a>,
3930 default: ::core::option::Option<&'a [capnp::Word]>,
3931 ) -> ::capnp::Result<Builder<'a>> {
3932 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
3933 builder.get_struct(_private::STRUCT_SIZE, default)?,
3934 ))
3935 }
3936 }
3937
3938 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
3939 fn set_pointer_builder<'b>(
3940 pointer: ::capnp::private::layout::PointerBuilder<'b>,
3941 value: Reader<'a>,
3942 canonicalize: bool,
3943 ) -> ::capnp::Result<()> {
3944 pointer.set_struct(&value.reader, canonicalize)
3945 }
3946 }
3947
3948 impl<'a> Builder<'a> {
3949 pub fn into_reader(self) -> Reader<'a> {
3950 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
3951 }
3952
3953 pub fn reborrow(&mut self) -> Builder<'_> {
3954 Builder { ..*self }
3955 }
3956
3957 pub fn reborrow_as_reader(&self) -> Reader<'_> {
3958 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
3959 }
3960
3961 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
3962 self.builder.into_reader().total_size()
3963 }
3964
3965 #[inline]
3966 pub fn set_artifact(
3967 &mut self,
3968 value: crate::data_capnp::artifact_metadata::Reader<'_>,
3969 ) -> ::capnp::Result<()> {
3970 self.builder.set_data_field::<u16>(0, 0);
3971 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
3972 self.builder.get_pointer_field(3),
3973 value,
3974 false,
3975 )
3976 }
3977
3978 #[inline]
3979 pub fn init_artifact(self) -> crate::data_capnp::artifact_metadata::Builder<'a> {
3980 self.builder.set_data_field::<u16>(0, 0);
3981 ::capnp::traits::FromPointerBuilder::init_pointer(
3982 self.builder.get_pointer_field(3),
3983 0,
3984 )
3985 }
3986
3987 pub fn has_artifact(&self) -> bool {
3988 if self.builder.get_data_field::<u16>(0) != 0 {
3989 return false;
3990 }
3991 !self.builder.get_pointer_field(3).is_null()
3992 }
3993
3994 #[inline]
3995 pub fn set_none(&mut self, _value: ()) {
3996 self.builder.set_data_field::<u16>(0, 1);
3997 }
3998
3999 #[inline]
4000 pub fn which(self) -> ::core::result::Result<WhichBuilder<'a>, ::capnp::NotInSchema> {
4001 match self.builder.get_data_field::<u16>(0) {
4002 0 => ::core::result::Result::Ok(Artifact(
4003 ::capnp::traits::FromPointerBuilder::get_from_pointer(
4004 self.builder.get_pointer_field(3),
4005 ::core::option::Option::None,
4006 ),
4007 )),
4008 1 => ::core::result::Result::Ok(None(())),
4009 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
4010 }
4011 }
4012 }
4013
4014 pub struct Pipeline {
4015 _typeless: ::capnp::any_pointer::Pipeline,
4016 }
4017 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
4018 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
4019 Pipeline {
4020 _typeless: typeless,
4021 }
4022 }
4023 }
4024 impl Pipeline {}
4025 mod _private {
4026 use capnp::private::layout;
4027 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
4028 data: 1,
4029 pointers: 5,
4030 };
4031 pub const TYPE_ID: u64 = 0xf89b_546a_e93a_b93d;
4032 }
4033 pub enum Which<A0> {
4034 Artifact(A0),
4035 None(()),
4036 }
4037 pub type WhichReader<'a> =
4038 Which<::capnp::Result<crate::data_capnp::artifact_metadata::Reader<'a>>>;
4039 pub type WhichBuilder<'a> =
4040 Which<::capnp::Result<crate::data_capnp::artifact_metadata::Builder<'a>>>;
4041 }
4042}
4043
4044pub mod artifact {
4045 #[derive(Copy, Clone)]
4046 pub struct Owned(());
4047 impl<'a> ::capnp::traits::Owned<'a> for Owned {
4048 type Builder = Builder<'a>;
4049 type Reader = Reader<'a>;
4050 }
4051 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
4052 type Builder = Builder<'a>;
4053 type Reader = Reader<'a>;
4054 }
4055 impl ::capnp::traits::Pipelined for Owned {
4056 type Pipeline = Pipeline;
4057 }
4058
4059 #[derive(Clone, Copy)]
4060 pub struct Reader<'a> {
4061 reader: ::capnp::private::layout::StructReader<'a>,
4062 }
4063
4064 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
4065 #[inline]
4066 fn type_id() -> u64 {
4067 _private::TYPE_ID
4068 }
4069 }
4070 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
4071 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
4072 Reader { reader }
4073 }
4074 }
4075
4076 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
4077 fn get_from_pointer(
4078 reader: &::capnp::private::layout::PointerReader<'a>,
4079 default: ::core::option::Option<&'a [capnp::Word]>,
4080 ) -> ::capnp::Result<Reader<'a>> {
4081 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
4082 reader.get_struct(default)?,
4083 ))
4084 }
4085 }
4086
4087 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
4088 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
4089 self.reader
4090 }
4091 }
4092
4093 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
4094 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
4095 self.reader
4096 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
4097 }
4098 }
4099
4100 impl<'a> Reader<'a> {
4101 pub fn reborrow(&self) -> Reader<'_> {
4102 Reader { ..*self }
4103 }
4104
4105 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4106 self.reader.total_size()
4107 }
4108
4109 #[inline]
4110 pub fn get_metadata(
4111 self,
4112 ) -> ::capnp::Result<crate::data_capnp::artifact_metadata::Reader<'a>> {
4113 ::capnp::traits::FromPointerReader::get_from_pointer(
4114 &self.reader.get_pointer_field(0),
4115 ::core::option::Option::None,
4116 )
4117 }
4118
4119 pub fn has_metadata(&self) -> bool {
4120 !self.reader.get_pointer_field(0).is_null()
4121 }
4122
4123 #[inline]
4124 pub fn get_data(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
4125 ::capnp::traits::FromPointerReader::get_from_pointer(
4126 &self.reader.get_pointer_field(1),
4127 ::core::option::Option::None,
4128 )
4129 }
4130
4131 pub fn has_data(&self) -> bool {
4132 !self.reader.get_pointer_field(1).is_null()
4133 }
4134 }
4135
4136 pub struct Builder<'a> {
4137 builder: ::capnp::private::layout::StructBuilder<'a>,
4138 }
4139 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
4140 #[inline]
4141 fn struct_size() -> ::capnp::private::layout::StructSize {
4142 _private::STRUCT_SIZE
4143 }
4144 }
4145 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
4146 #[inline]
4147 fn type_id() -> u64 {
4148 _private::TYPE_ID
4149 }
4150 }
4151 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
4152 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
4153 Builder { builder }
4154 }
4155 }
4156
4157 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
4158 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
4159 self.builder
4160 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
4161 }
4162 }
4163
4164 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
4165 fn init_pointer(
4166 builder: ::capnp::private::layout::PointerBuilder<'a>,
4167 _size: u32,
4168 ) -> Builder<'a> {
4169 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
4170 }
4171
4172 fn get_from_pointer(
4173 builder: ::capnp::private::layout::PointerBuilder<'a>,
4174 default: ::core::option::Option<&'a [capnp::Word]>,
4175 ) -> ::capnp::Result<Builder<'a>> {
4176 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
4177 builder.get_struct(_private::STRUCT_SIZE, default)?,
4178 ))
4179 }
4180 }
4181
4182 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
4183 fn set_pointer_builder<'b>(
4184 pointer: ::capnp::private::layout::PointerBuilder<'b>,
4185 value: Reader<'a>,
4186 canonicalize: bool,
4187 ) -> ::capnp::Result<()> {
4188 pointer.set_struct(&value.reader, canonicalize)
4189 }
4190 }
4191
4192 impl<'a> Builder<'a> {
4193 pub fn into_reader(self) -> Reader<'a> {
4194 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4195 }
4196
4197 pub fn reborrow(&mut self) -> Builder<'_> {
4198 Builder { ..*self }
4199 }
4200
4201 pub fn reborrow_as_reader(&self) -> Reader<'_> {
4202 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4203 }
4204
4205 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4206 self.builder.into_reader().total_size()
4207 }
4208
4209 #[inline]
4210 pub fn get_metadata(
4211 self,
4212 ) -> ::capnp::Result<crate::data_capnp::artifact_metadata::Builder<'a>> {
4213 ::capnp::traits::FromPointerBuilder::get_from_pointer(
4214 self.builder.get_pointer_field(0),
4215 ::core::option::Option::None,
4216 )
4217 }
4218
4219 #[inline]
4220 pub fn set_metadata(
4221 &mut self,
4222 value: crate::data_capnp::artifact_metadata::Reader<'_>,
4223 ) -> ::capnp::Result<()> {
4224 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
4225 self.builder.get_pointer_field(0),
4226 value,
4227 false,
4228 )
4229 }
4230
4231 #[inline]
4232 pub fn init_metadata(self) -> crate::data_capnp::artifact_metadata::Builder<'a> {
4233 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
4234 }
4235
4236 pub fn has_metadata(&self) -> bool {
4237 !self.builder.get_pointer_field(0).is_null()
4238 }
4239
4240 #[inline]
4241 pub fn get_data(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
4242 ::capnp::traits::FromPointerBuilder::get_from_pointer(
4243 self.builder.get_pointer_field(1),
4244 ::core::option::Option::None,
4245 )
4246 }
4247
4248 #[inline]
4249 pub fn set_data(&mut self, value: ::capnp::data::Reader<'_>) {
4250 self.builder.get_pointer_field(1).set_data(value);
4251 }
4252
4253 #[inline]
4254 pub fn init_data(self, size: u32) -> ::capnp::data::Builder<'a> {
4255 self.builder.get_pointer_field(1).init_data(size)
4256 }
4257
4258 pub fn has_data(&self) -> bool {
4259 !self.builder.get_pointer_field(1).is_null()
4260 }
4261 }
4262
4263 pub struct Pipeline {
4264 _typeless: ::capnp::any_pointer::Pipeline,
4265 }
4266 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
4267 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
4268 Pipeline {
4269 _typeless: typeless,
4270 }
4271 }
4272 }
4273 impl Pipeline {
4274 pub fn get_metadata(&self) -> crate::data_capnp::artifact_metadata::Pipeline {
4275 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
4276 }
4277 }
4278 mod _private {
4279 use capnp::private::layout;
4280 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
4281 data: 0,
4282 pointers: 2,
4283 };
4284 pub const TYPE_ID: u64 = 0xc13f_9a65_1275_14eb;
4285 }
4286}
4287
4288pub mod build_parameters {
4289 #[derive(Copy, Clone)]
4290 pub struct Owned(());
4291 impl<'a> ::capnp::traits::Owned<'a> for Owned {
4292 type Builder = Builder<'a>;
4293 type Reader = Reader<'a>;
4294 }
4295 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
4296 type Builder = Builder<'a>;
4297 type Reader = Reader<'a>;
4298 }
4299 impl ::capnp::traits::Pipelined for Owned {
4300 type Pipeline = Pipeline;
4301 }
4302
4303 #[derive(Clone, Copy)]
4304 pub struct Reader<'a> {
4305 reader: ::capnp::private::layout::StructReader<'a>,
4306 }
4307
4308 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
4309 #[inline]
4310 fn type_id() -> u64 {
4311 _private::TYPE_ID
4312 }
4313 }
4314 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
4315 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
4316 Reader { reader }
4317 }
4318 }
4319
4320 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
4321 fn get_from_pointer(
4322 reader: &::capnp::private::layout::PointerReader<'a>,
4323 default: ::core::option::Option<&'a [capnp::Word]>,
4324 ) -> ::capnp::Result<Reader<'a>> {
4325 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
4326 reader.get_struct(default)?,
4327 ))
4328 }
4329 }
4330
4331 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
4332 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
4333 self.reader
4334 }
4335 }
4336
4337 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
4338 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
4339 self.reader
4340 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
4341 }
4342 }
4343
4344 impl<'a> Reader<'a> {
4345 pub fn reborrow(&self) -> Reader<'_> {
4346 Reader { ..*self }
4347 }
4348
4349 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4350 self.reader.total_size()
4351 }
4352 }
4353
4354 pub struct Builder<'a> {
4355 builder: ::capnp::private::layout::StructBuilder<'a>,
4356 }
4357 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
4358 #[inline]
4359 fn struct_size() -> ::capnp::private::layout::StructSize {
4360 _private::STRUCT_SIZE
4361 }
4362 }
4363 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
4364 #[inline]
4365 fn type_id() -> u64 {
4366 _private::TYPE_ID
4367 }
4368 }
4369 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
4370 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
4371 Builder { builder }
4372 }
4373 }
4374
4375 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
4376 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
4377 self.builder
4378 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
4379 }
4380 }
4381
4382 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
4383 fn init_pointer(
4384 builder: ::capnp::private::layout::PointerBuilder<'a>,
4385 _size: u32,
4386 ) -> Builder<'a> {
4387 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
4388 }
4389
4390 fn get_from_pointer(
4391 builder: ::capnp::private::layout::PointerBuilder<'a>,
4392 default: ::core::option::Option<&'a [capnp::Word]>,
4393 ) -> ::capnp::Result<Builder<'a>> {
4394 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
4395 builder.get_struct(_private::STRUCT_SIZE, default)?,
4396 ))
4397 }
4398 }
4399
4400 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
4401 fn set_pointer_builder<'b>(
4402 pointer: ::capnp::private::layout::PointerBuilder<'b>,
4403 value: Reader<'a>,
4404 canonicalize: bool,
4405 ) -> ::capnp::Result<()> {
4406 pointer.set_struct(&value.reader, canonicalize)
4407 }
4408 }
4409
4410 impl<'a> Builder<'a> {
4411 pub fn into_reader(self) -> Reader<'a> {
4412 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4413 }
4414
4415 pub fn reborrow(&mut self) -> Builder<'_> {
4416 Builder { ..*self }
4417 }
4418
4419 pub fn reborrow_as_reader(&self) -> Reader<'_> {
4420 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4421 }
4422
4423 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4424 self.builder.into_reader().total_size()
4425 }
4426 }
4427
4428 pub struct Pipeline {
4429 _typeless: ::capnp::any_pointer::Pipeline,
4430 }
4431 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
4432 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
4433 Pipeline {
4434 _typeless: typeless,
4435 }
4436 }
4437 }
4438 impl Pipeline {}
4439 mod _private {
4440 use capnp::private::layout;
4441 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
4442 data: 0,
4443 pointers: 0,
4444 };
4445 pub const TYPE_ID: u64 = 0x9027_cefe_4d39_7129;
4446 }
4447}
4448
4449pub mod asset_change_log_entry {
4450 #[derive(Copy, Clone)]
4451 pub struct Owned(());
4452 impl<'a> ::capnp::traits::Owned<'a> for Owned {
4453 type Builder = Builder<'a>;
4454 type Reader = Reader<'a>;
4455 }
4456 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
4457 type Builder = Builder<'a>;
4458 type Reader = Reader<'a>;
4459 }
4460 impl ::capnp::traits::Pipelined for Owned {
4461 type Pipeline = Pipeline;
4462 }
4463
4464 #[derive(Clone, Copy)]
4465 pub struct Reader<'a> {
4466 reader: ::capnp::private::layout::StructReader<'a>,
4467 }
4468
4469 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
4470 #[inline]
4471 fn type_id() -> u64 {
4472 _private::TYPE_ID
4473 }
4474 }
4475 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
4476 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
4477 Reader { reader }
4478 }
4479 }
4480
4481 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
4482 fn get_from_pointer(
4483 reader: &::capnp::private::layout::PointerReader<'a>,
4484 default: ::core::option::Option<&'a [capnp::Word]>,
4485 ) -> ::capnp::Result<Reader<'a>> {
4486 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
4487 reader.get_struct(default)?,
4488 ))
4489 }
4490 }
4491
4492 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
4493 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
4494 self.reader
4495 }
4496 }
4497
4498 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
4499 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
4500 self.reader
4501 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
4502 }
4503 }
4504
4505 impl<'a> Reader<'a> {
4506 pub fn reborrow(&self) -> Reader<'_> {
4507 Reader { ..*self }
4508 }
4509
4510 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4511 self.reader.total_size()
4512 }
4513
4514 #[inline]
4515 pub fn get_num(self) -> u64 {
4516 self.reader.get_data_field::<u64>(0)
4517 }
4518
4519 #[inline]
4520 pub fn get_event(
4521 self,
4522 ) -> ::capnp::Result<crate::data_capnp::asset_change_event::Reader<'a>> {
4523 ::capnp::traits::FromPointerReader::get_from_pointer(
4524 &self.reader.get_pointer_field(0),
4525 ::core::option::Option::None,
4526 )
4527 }
4528
4529 pub fn has_event(&self) -> bool {
4530 !self.reader.get_pointer_field(0).is_null()
4531 }
4532 }
4533
4534 pub struct Builder<'a> {
4535 builder: ::capnp::private::layout::StructBuilder<'a>,
4536 }
4537 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
4538 #[inline]
4539 fn struct_size() -> ::capnp::private::layout::StructSize {
4540 _private::STRUCT_SIZE
4541 }
4542 }
4543 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
4544 #[inline]
4545 fn type_id() -> u64 {
4546 _private::TYPE_ID
4547 }
4548 }
4549 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
4550 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
4551 Builder { builder }
4552 }
4553 }
4554
4555 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
4556 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
4557 self.builder
4558 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
4559 }
4560 }
4561
4562 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
4563 fn init_pointer(
4564 builder: ::capnp::private::layout::PointerBuilder<'a>,
4565 _size: u32,
4566 ) -> Builder<'a> {
4567 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
4568 }
4569
4570 fn get_from_pointer(
4571 builder: ::capnp::private::layout::PointerBuilder<'a>,
4572 default: ::core::option::Option<&'a [capnp::Word]>,
4573 ) -> ::capnp::Result<Builder<'a>> {
4574 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
4575 builder.get_struct(_private::STRUCT_SIZE, default)?,
4576 ))
4577 }
4578 }
4579
4580 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
4581 fn set_pointer_builder<'b>(
4582 pointer: ::capnp::private::layout::PointerBuilder<'b>,
4583 value: Reader<'a>,
4584 canonicalize: bool,
4585 ) -> ::capnp::Result<()> {
4586 pointer.set_struct(&value.reader, canonicalize)
4587 }
4588 }
4589
4590 impl<'a> Builder<'a> {
4591 pub fn into_reader(self) -> Reader<'a> {
4592 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4593 }
4594
4595 pub fn reborrow(&mut self) -> Builder<'_> {
4596 Builder { ..*self }
4597 }
4598
4599 pub fn reborrow_as_reader(&self) -> Reader<'_> {
4600 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4601 }
4602
4603 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4604 self.builder.into_reader().total_size()
4605 }
4606
4607 #[inline]
4608 pub fn get_num(self) -> u64 {
4609 self.builder.get_data_field::<u64>(0)
4610 }
4611
4612 #[inline]
4613 pub fn set_num(&mut self, value: u64) {
4614 self.builder.set_data_field::<u64>(0, value);
4615 }
4616
4617 #[inline]
4618 pub fn get_event(
4619 self,
4620 ) -> ::capnp::Result<crate::data_capnp::asset_change_event::Builder<'a>> {
4621 ::capnp::traits::FromPointerBuilder::get_from_pointer(
4622 self.builder.get_pointer_field(0),
4623 ::core::option::Option::None,
4624 )
4625 }
4626
4627 #[inline]
4628 pub fn set_event(
4629 &mut self,
4630 value: crate::data_capnp::asset_change_event::Reader<'_>,
4631 ) -> ::capnp::Result<()> {
4632 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
4633 self.builder.get_pointer_field(0),
4634 value,
4635 false,
4636 )
4637 }
4638
4639 #[inline]
4640 pub fn init_event(self) -> crate::data_capnp::asset_change_event::Builder<'a> {
4641 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
4642 }
4643
4644 pub fn has_event(&self) -> bool {
4645 !self.builder.get_pointer_field(0).is_null()
4646 }
4647 }
4648
4649 pub struct Pipeline {
4650 _typeless: ::capnp::any_pointer::Pipeline,
4651 }
4652 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
4653 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
4654 Pipeline {
4655 _typeless: typeless,
4656 }
4657 }
4658 }
4659 impl Pipeline {
4660 pub fn get_event(&self) -> crate::data_capnp::asset_change_event::Pipeline {
4661 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
4662 }
4663 }
4664 mod _private {
4665 use capnp::private::layout;
4666 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
4667 data: 1,
4668 pointers: 1,
4669 };
4670 pub const TYPE_ID: u64 = 0xf189_c967_ba85_a619;
4671 }
4672}
4673
4674pub mod asset_change_event {
4675 pub use self::Which::{ContentUpdateEvent, PathRemoveEvent, PathUpdateEvent, RemoveEvent};
4676
4677 #[derive(Copy, Clone)]
4678 pub struct Owned(());
4679 impl<'a> ::capnp::traits::Owned<'a> for Owned {
4680 type Builder = Builder<'a>;
4681 type Reader = Reader<'a>;
4682 }
4683 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
4684 type Builder = Builder<'a>;
4685 type Reader = Reader<'a>;
4686 }
4687 impl ::capnp::traits::Pipelined for Owned {
4688 type Pipeline = Pipeline;
4689 }
4690
4691 #[derive(Clone, Copy)]
4692 pub struct Reader<'a> {
4693 reader: ::capnp::private::layout::StructReader<'a>,
4694 }
4695
4696 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
4697 #[inline]
4698 fn type_id() -> u64 {
4699 _private::TYPE_ID
4700 }
4701 }
4702 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
4703 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
4704 Reader { reader }
4705 }
4706 }
4707
4708 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
4709 fn get_from_pointer(
4710 reader: &::capnp::private::layout::PointerReader<'a>,
4711 default: ::core::option::Option<&'a [capnp::Word]>,
4712 ) -> ::capnp::Result<Reader<'a>> {
4713 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
4714 reader.get_struct(default)?,
4715 ))
4716 }
4717 }
4718
4719 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
4720 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
4721 self.reader
4722 }
4723 }
4724
4725 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
4726 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
4727 self.reader
4728 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
4729 }
4730 }
4731
4732 impl<'a> Reader<'a> {
4733 pub fn reborrow(&self) -> Reader<'_> {
4734 Reader { ..*self }
4735 }
4736
4737 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4738 self.reader.total_size()
4739 }
4740
4741 pub fn has_content_update_event(&self) -> bool {
4742 if self.reader.get_data_field::<u16>(0) != 0 {
4743 return false;
4744 }
4745 !self.reader.get_pointer_field(0).is_null()
4746 }
4747
4748 pub fn has_remove_event(&self) -> bool {
4749 if self.reader.get_data_field::<u16>(0) != 1 {
4750 return false;
4751 }
4752 !self.reader.get_pointer_field(0).is_null()
4753 }
4754
4755 pub fn has_path_update_event(&self) -> bool {
4756 if self.reader.get_data_field::<u16>(0) != 2 {
4757 return false;
4758 }
4759 !self.reader.get_pointer_field(0).is_null()
4760 }
4761
4762 pub fn has_path_remove_event(&self) -> bool {
4763 if self.reader.get_data_field::<u16>(0) != 3 {
4764 return false;
4765 }
4766 !self.reader.get_pointer_field(0).is_null()
4767 }
4768
4769 #[inline]
4770 pub fn which(self) -> ::core::result::Result<WhichReader<'a>, ::capnp::NotInSchema> {
4771 match self.reader.get_data_field::<u16>(0) {
4772 0 => ::core::result::Result::Ok(ContentUpdateEvent(
4773 ::capnp::traits::FromPointerReader::get_from_pointer(
4774 &self.reader.get_pointer_field(0),
4775 ::core::option::Option::None,
4776 ),
4777 )),
4778 1 => ::core::result::Result::Ok(RemoveEvent(
4779 ::capnp::traits::FromPointerReader::get_from_pointer(
4780 &self.reader.get_pointer_field(0),
4781 ::core::option::Option::None,
4782 ),
4783 )),
4784 2 => ::core::result::Result::Ok(PathUpdateEvent(
4785 ::capnp::traits::FromPointerReader::get_from_pointer(
4786 &self.reader.get_pointer_field(0),
4787 ::core::option::Option::None,
4788 ),
4789 )),
4790 3 => ::core::result::Result::Ok(PathRemoveEvent(
4791 ::capnp::traits::FromPointerReader::get_from_pointer(
4792 &self.reader.get_pointer_field(0),
4793 ::core::option::Option::None,
4794 ),
4795 )),
4796 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
4797 }
4798 }
4799 }
4800
4801 pub struct Builder<'a> {
4802 builder: ::capnp::private::layout::StructBuilder<'a>,
4803 }
4804 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
4805 #[inline]
4806 fn struct_size() -> ::capnp::private::layout::StructSize {
4807 _private::STRUCT_SIZE
4808 }
4809 }
4810 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
4811 #[inline]
4812 fn type_id() -> u64 {
4813 _private::TYPE_ID
4814 }
4815 }
4816 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
4817 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
4818 Builder { builder }
4819 }
4820 }
4821
4822 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
4823 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
4824 self.builder
4825 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
4826 }
4827 }
4828
4829 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
4830 fn init_pointer(
4831 builder: ::capnp::private::layout::PointerBuilder<'a>,
4832 _size: u32,
4833 ) -> Builder<'a> {
4834 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
4835 }
4836
4837 fn get_from_pointer(
4838 builder: ::capnp::private::layout::PointerBuilder<'a>,
4839 default: ::core::option::Option<&'a [capnp::Word]>,
4840 ) -> ::capnp::Result<Builder<'a>> {
4841 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
4842 builder.get_struct(_private::STRUCT_SIZE, default)?,
4843 ))
4844 }
4845 }
4846
4847 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
4848 fn set_pointer_builder<'b>(
4849 pointer: ::capnp::private::layout::PointerBuilder<'b>,
4850 value: Reader<'a>,
4851 canonicalize: bool,
4852 ) -> ::capnp::Result<()> {
4853 pointer.set_struct(&value.reader, canonicalize)
4854 }
4855 }
4856
4857 impl<'a> Builder<'a> {
4858 pub fn into_reader(self) -> Reader<'a> {
4859 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4860 }
4861
4862 pub fn reborrow(&mut self) -> Builder<'_> {
4863 Builder { ..*self }
4864 }
4865
4866 pub fn reborrow_as_reader(&self) -> Reader<'_> {
4867 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
4868 }
4869
4870 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
4871 self.builder.into_reader().total_size()
4872 }
4873
4874 #[inline]
4875 pub fn set_content_update_event(
4876 &mut self,
4877 value: crate::data_capnp::asset_content_update_event::Reader<'_>,
4878 ) -> ::capnp::Result<()> {
4879 self.builder.set_data_field::<u16>(0, 0);
4880 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
4881 self.builder.get_pointer_field(0),
4882 value,
4883 false,
4884 )
4885 }
4886
4887 #[inline]
4888 pub fn init_content_update_event(
4889 self,
4890 ) -> crate::data_capnp::asset_content_update_event::Builder<'a> {
4891 self.builder.set_data_field::<u16>(0, 0);
4892 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
4893 }
4894
4895 pub fn has_content_update_event(&self) -> bool {
4896 if self.builder.get_data_field::<u16>(0) != 0 {
4897 return false;
4898 }
4899 !self.builder.get_pointer_field(0).is_null()
4900 }
4901
4902 #[inline]
4903 pub fn set_remove_event(
4904 &mut self,
4905 value: crate::data_capnp::asset_remove_event::Reader<'_>,
4906 ) -> ::capnp::Result<()> {
4907 self.builder.set_data_field::<u16>(0, 1);
4908 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
4909 self.builder.get_pointer_field(0),
4910 value,
4911 false,
4912 )
4913 }
4914
4915 #[inline]
4916 pub fn init_remove_event(self) -> crate::data_capnp::asset_remove_event::Builder<'a> {
4917 self.builder.set_data_field::<u16>(0, 1);
4918 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
4919 }
4920
4921 pub fn has_remove_event(&self) -> bool {
4922 if self.builder.get_data_field::<u16>(0) != 1 {
4923 return false;
4924 }
4925 !self.builder.get_pointer_field(0).is_null()
4926 }
4927
4928 #[inline]
4929 pub fn set_path_update_event(
4930 &mut self,
4931 value: crate::data_capnp::path_update_event::Reader<'_>,
4932 ) -> ::capnp::Result<()> {
4933 self.builder.set_data_field::<u16>(0, 2);
4934 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
4935 self.builder.get_pointer_field(0),
4936 value,
4937 false,
4938 )
4939 }
4940
4941 #[inline]
4942 pub fn init_path_update_event(self) -> crate::data_capnp::path_update_event::Builder<'a> {
4943 self.builder.set_data_field::<u16>(0, 2);
4944 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
4945 }
4946
4947 pub fn has_path_update_event(&self) -> bool {
4948 if self.builder.get_data_field::<u16>(0) != 2 {
4949 return false;
4950 }
4951 !self.builder.get_pointer_field(0).is_null()
4952 }
4953
4954 #[inline]
4955 pub fn set_path_remove_event(
4956 &mut self,
4957 value: crate::data_capnp::path_remove_event::Reader<'_>,
4958 ) -> ::capnp::Result<()> {
4959 self.builder.set_data_field::<u16>(0, 3);
4960 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
4961 self.builder.get_pointer_field(0),
4962 value,
4963 false,
4964 )
4965 }
4966
4967 #[inline]
4968 pub fn init_path_remove_event(self) -> crate::data_capnp::path_remove_event::Builder<'a> {
4969 self.builder.set_data_field::<u16>(0, 3);
4970 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
4971 }
4972
4973 pub fn has_path_remove_event(&self) -> bool {
4974 if self.builder.get_data_field::<u16>(0) != 3 {
4975 return false;
4976 }
4977 !self.builder.get_pointer_field(0).is_null()
4978 }
4979
4980 #[inline]
4981 pub fn which(self) -> ::core::result::Result<WhichBuilder<'a>, ::capnp::NotInSchema> {
4982 match self.builder.get_data_field::<u16>(0) {
4983 0 => ::core::result::Result::Ok(ContentUpdateEvent(
4984 ::capnp::traits::FromPointerBuilder::get_from_pointer(
4985 self.builder.get_pointer_field(0),
4986 ::core::option::Option::None,
4987 ),
4988 )),
4989 1 => ::core::result::Result::Ok(RemoveEvent(
4990 ::capnp::traits::FromPointerBuilder::get_from_pointer(
4991 self.builder.get_pointer_field(0),
4992 ::core::option::Option::None,
4993 ),
4994 )),
4995 2 => ::core::result::Result::Ok(PathUpdateEvent(
4996 ::capnp::traits::FromPointerBuilder::get_from_pointer(
4997 self.builder.get_pointer_field(0),
4998 ::core::option::Option::None,
4999 ),
5000 )),
5001 3 => ::core::result::Result::Ok(PathRemoveEvent(
5002 ::capnp::traits::FromPointerBuilder::get_from_pointer(
5003 self.builder.get_pointer_field(0),
5004 ::core::option::Option::None,
5005 ),
5006 )),
5007 x => ::core::result::Result::Err(::capnp::NotInSchema(x)),
5008 }
5009 }
5010 }
5011
5012 pub struct Pipeline {
5013 _typeless: ::capnp::any_pointer::Pipeline,
5014 }
5015 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
5016 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
5017 Pipeline {
5018 _typeless: typeless,
5019 }
5020 }
5021 }
5022 impl Pipeline {}
5023 mod _private {
5024 use capnp::private::layout;
5025 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
5026 data: 1,
5027 pointers: 1,
5028 };
5029 pub const TYPE_ID: u64 = 0xec9c_7eea_f6c3_be43;
5030 }
5031 pub enum Which<A0, A1, A2, A3> {
5032 ContentUpdateEvent(A0),
5033 RemoveEvent(A1),
5034 PathUpdateEvent(A2),
5035 PathRemoveEvent(A3),
5036 }
5037 pub type WhichReader<'a> = Which<
5038 ::capnp::Result<crate::data_capnp::asset_content_update_event::Reader<'a>>,
5039 ::capnp::Result<crate::data_capnp::asset_remove_event::Reader<'a>>,
5040 ::capnp::Result<crate::data_capnp::path_update_event::Reader<'a>>,
5041 ::capnp::Result<crate::data_capnp::path_remove_event::Reader<'a>>,
5042 >;
5043 pub type WhichBuilder<'a> = Which<
5044 ::capnp::Result<crate::data_capnp::asset_content_update_event::Builder<'a>>,
5045 ::capnp::Result<crate::data_capnp::asset_remove_event::Builder<'a>>,
5046 ::capnp::Result<crate::data_capnp::path_update_event::Builder<'a>>,
5047 ::capnp::Result<crate::data_capnp::path_remove_event::Builder<'a>>,
5048 >;
5049}
5050
5051pub mod asset_content_update_event {
5052 #[derive(Copy, Clone)]
5053 pub struct Owned(());
5054 impl<'a> ::capnp::traits::Owned<'a> for Owned {
5055 type Builder = Builder<'a>;
5056 type Reader = Reader<'a>;
5057 }
5058 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
5059 type Builder = Builder<'a>;
5060 type Reader = Reader<'a>;
5061 }
5062 impl ::capnp::traits::Pipelined for Owned {
5063 type Pipeline = Pipeline;
5064 }
5065
5066 #[derive(Clone, Copy)]
5067 pub struct Reader<'a> {
5068 reader: ::capnp::private::layout::StructReader<'a>,
5069 }
5070
5071 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
5072 #[inline]
5073 fn type_id() -> u64 {
5074 _private::TYPE_ID
5075 }
5076 }
5077 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
5078 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
5079 Reader { reader }
5080 }
5081 }
5082
5083 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
5084 fn get_from_pointer(
5085 reader: &::capnp::private::layout::PointerReader<'a>,
5086 default: ::core::option::Option<&'a [capnp::Word]>,
5087 ) -> ::capnp::Result<Reader<'a>> {
5088 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
5089 reader.get_struct(default)?,
5090 ))
5091 }
5092 }
5093
5094 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
5095 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
5096 self.reader
5097 }
5098 }
5099
5100 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
5101 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
5102 self.reader
5103 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
5104 }
5105 }
5106
5107 impl<'a> Reader<'a> {
5108 pub fn reborrow(&self) -> Reader<'_> {
5109 Reader { ..*self }
5110 }
5111
5112 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5113 self.reader.total_size()
5114 }
5115
5116 #[inline]
5117 pub fn get_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>> {
5118 ::capnp::traits::FromPointerReader::get_from_pointer(
5119 &self.reader.get_pointer_field(0),
5120 ::core::option::Option::None,
5121 )
5122 }
5123
5124 pub fn has_id(&self) -> bool {
5125 !self.reader.get_pointer_field(0).is_null()
5126 }
5127
5128 #[inline]
5129 pub fn get_import_hash(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
5130 ::capnp::traits::FromPointerReader::get_from_pointer(
5131 &self.reader.get_pointer_field(1),
5132 ::core::option::Option::None,
5133 )
5134 }
5135
5136 pub fn has_import_hash(&self) -> bool {
5137 !self.reader.get_pointer_field(1).is_null()
5138 }
5139
5140 #[inline]
5141 pub fn get_build_dep_hash(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
5142 ::capnp::traits::FromPointerReader::get_from_pointer(
5143 &self.reader.get_pointer_field(2),
5144 ::core::option::Option::None,
5145 )
5146 }
5147
5148 pub fn has_build_dep_hash(&self) -> bool {
5149 !self.reader.get_pointer_field(2).is_null()
5150 }
5151 }
5152
5153 pub struct Builder<'a> {
5154 builder: ::capnp::private::layout::StructBuilder<'a>,
5155 }
5156 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
5157 #[inline]
5158 fn struct_size() -> ::capnp::private::layout::StructSize {
5159 _private::STRUCT_SIZE
5160 }
5161 }
5162 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
5163 #[inline]
5164 fn type_id() -> u64 {
5165 _private::TYPE_ID
5166 }
5167 }
5168 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
5169 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
5170 Builder { builder }
5171 }
5172 }
5173
5174 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
5175 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
5176 self.builder
5177 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
5178 }
5179 }
5180
5181 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
5182 fn init_pointer(
5183 builder: ::capnp::private::layout::PointerBuilder<'a>,
5184 _size: u32,
5185 ) -> Builder<'a> {
5186 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
5187 }
5188
5189 fn get_from_pointer(
5190 builder: ::capnp::private::layout::PointerBuilder<'a>,
5191 default: ::core::option::Option<&'a [capnp::Word]>,
5192 ) -> ::capnp::Result<Builder<'a>> {
5193 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
5194 builder.get_struct(_private::STRUCT_SIZE, default)?,
5195 ))
5196 }
5197 }
5198
5199 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
5200 fn set_pointer_builder<'b>(
5201 pointer: ::capnp::private::layout::PointerBuilder<'b>,
5202 value: Reader<'a>,
5203 canonicalize: bool,
5204 ) -> ::capnp::Result<()> {
5205 pointer.set_struct(&value.reader, canonicalize)
5206 }
5207 }
5208
5209 impl<'a> Builder<'a> {
5210 pub fn into_reader(self) -> Reader<'a> {
5211 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5212 }
5213
5214 pub fn reborrow(&mut self) -> Builder<'_> {
5215 Builder { ..*self }
5216 }
5217
5218 pub fn reborrow_as_reader(&self) -> Reader<'_> {
5219 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5220 }
5221
5222 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5223 self.builder.into_reader().total_size()
5224 }
5225
5226 #[inline]
5227 pub fn get_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>> {
5228 ::capnp::traits::FromPointerBuilder::get_from_pointer(
5229 self.builder.get_pointer_field(0),
5230 ::core::option::Option::None,
5231 )
5232 }
5233
5234 #[inline]
5235 pub fn set_id(
5236 &mut self,
5237 value: crate::data_capnp::asset_uuid::Reader<'_>,
5238 ) -> ::capnp::Result<()> {
5239 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
5240 self.builder.get_pointer_field(0),
5241 value,
5242 false,
5243 )
5244 }
5245
5246 #[inline]
5247 pub fn init_id(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
5248 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
5249 }
5250
5251 pub fn has_id(&self) -> bool {
5252 !self.builder.get_pointer_field(0).is_null()
5253 }
5254
5255 #[inline]
5256 pub fn get_import_hash(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
5257 ::capnp::traits::FromPointerBuilder::get_from_pointer(
5258 self.builder.get_pointer_field(1),
5259 ::core::option::Option::None,
5260 )
5261 }
5262
5263 #[inline]
5264 pub fn set_import_hash(&mut self, value: ::capnp::data::Reader<'_>) {
5265 self.builder.get_pointer_field(1).set_data(value);
5266 }
5267
5268 #[inline]
5269 pub fn init_import_hash(self, size: u32) -> ::capnp::data::Builder<'a> {
5270 self.builder.get_pointer_field(1).init_data(size)
5271 }
5272
5273 pub fn has_import_hash(&self) -> bool {
5274 !self.builder.get_pointer_field(1).is_null()
5275 }
5276
5277 #[inline]
5278 pub fn get_build_dep_hash(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
5279 ::capnp::traits::FromPointerBuilder::get_from_pointer(
5280 self.builder.get_pointer_field(2),
5281 ::core::option::Option::None,
5282 )
5283 }
5284
5285 #[inline]
5286 pub fn set_build_dep_hash(&mut self, value: ::capnp::data::Reader<'_>) {
5287 self.builder.get_pointer_field(2).set_data(value);
5288 }
5289
5290 #[inline]
5291 pub fn init_build_dep_hash(self, size: u32) -> ::capnp::data::Builder<'a> {
5292 self.builder.get_pointer_field(2).init_data(size)
5293 }
5294
5295 pub fn has_build_dep_hash(&self) -> bool {
5296 !self.builder.get_pointer_field(2).is_null()
5297 }
5298 }
5299
5300 pub struct Pipeline {
5301 _typeless: ::capnp::any_pointer::Pipeline,
5302 }
5303 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
5304 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
5305 Pipeline {
5306 _typeless: typeless,
5307 }
5308 }
5309 }
5310 impl Pipeline {
5311 pub fn get_id(&self) -> crate::data_capnp::asset_uuid::Pipeline {
5312 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
5313 }
5314 }
5315 mod _private {
5316 use capnp::private::layout;
5317 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
5318 data: 0,
5319 pointers: 3,
5320 };
5321 pub const TYPE_ID: u64 = 0xd656_a19c_63c1_2b5d;
5322 }
5323}
5324
5325pub mod path_update_event {
5326 #[derive(Copy, Clone)]
5327 pub struct Owned(());
5328 impl<'a> ::capnp::traits::Owned<'a> for Owned {
5329 type Builder = Builder<'a>;
5330 type Reader = Reader<'a>;
5331 }
5332 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
5333 type Builder = Builder<'a>;
5334 type Reader = Reader<'a>;
5335 }
5336 impl ::capnp::traits::Pipelined for Owned {
5337 type Pipeline = Pipeline;
5338 }
5339
5340 #[derive(Clone, Copy)]
5341 pub struct Reader<'a> {
5342 reader: ::capnp::private::layout::StructReader<'a>,
5343 }
5344
5345 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
5346 #[inline]
5347 fn type_id() -> u64 {
5348 _private::TYPE_ID
5349 }
5350 }
5351 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
5352 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
5353 Reader { reader }
5354 }
5355 }
5356
5357 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
5358 fn get_from_pointer(
5359 reader: &::capnp::private::layout::PointerReader<'a>,
5360 default: ::core::option::Option<&'a [capnp::Word]>,
5361 ) -> ::capnp::Result<Reader<'a>> {
5362 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
5363 reader.get_struct(default)?,
5364 ))
5365 }
5366 }
5367
5368 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
5369 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
5370 self.reader
5371 }
5372 }
5373
5374 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
5375 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
5376 self.reader
5377 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
5378 }
5379 }
5380
5381 impl<'a> Reader<'a> {
5382 pub fn reborrow(&self) -> Reader<'_> {
5383 Reader { ..*self }
5384 }
5385
5386 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5387 self.reader.total_size()
5388 }
5389
5390 #[inline]
5391 pub fn get_path(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
5392 ::capnp::traits::FromPointerReader::get_from_pointer(
5393 &self.reader.get_pointer_field(0),
5394 ::core::option::Option::None,
5395 )
5396 }
5397
5398 pub fn has_path(&self) -> bool {
5399 !self.reader.get_pointer_field(0).is_null()
5400 }
5401 }
5402
5403 pub struct Builder<'a> {
5404 builder: ::capnp::private::layout::StructBuilder<'a>,
5405 }
5406 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
5407 #[inline]
5408 fn struct_size() -> ::capnp::private::layout::StructSize {
5409 _private::STRUCT_SIZE
5410 }
5411 }
5412 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
5413 #[inline]
5414 fn type_id() -> u64 {
5415 _private::TYPE_ID
5416 }
5417 }
5418 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
5419 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
5420 Builder { builder }
5421 }
5422 }
5423
5424 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
5425 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
5426 self.builder
5427 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
5428 }
5429 }
5430
5431 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
5432 fn init_pointer(
5433 builder: ::capnp::private::layout::PointerBuilder<'a>,
5434 _size: u32,
5435 ) -> Builder<'a> {
5436 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
5437 }
5438
5439 fn get_from_pointer(
5440 builder: ::capnp::private::layout::PointerBuilder<'a>,
5441 default: ::core::option::Option<&'a [capnp::Word]>,
5442 ) -> ::capnp::Result<Builder<'a>> {
5443 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
5444 builder.get_struct(_private::STRUCT_SIZE, default)?,
5445 ))
5446 }
5447 }
5448
5449 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
5450 fn set_pointer_builder<'b>(
5451 pointer: ::capnp::private::layout::PointerBuilder<'b>,
5452 value: Reader<'a>,
5453 canonicalize: bool,
5454 ) -> ::capnp::Result<()> {
5455 pointer.set_struct(&value.reader, canonicalize)
5456 }
5457 }
5458
5459 impl<'a> Builder<'a> {
5460 pub fn into_reader(self) -> Reader<'a> {
5461 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5462 }
5463
5464 pub fn reborrow(&mut self) -> Builder<'_> {
5465 Builder { ..*self }
5466 }
5467
5468 pub fn reborrow_as_reader(&self) -> Reader<'_> {
5469 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5470 }
5471
5472 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5473 self.builder.into_reader().total_size()
5474 }
5475
5476 #[inline]
5477 pub fn get_path(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
5478 ::capnp::traits::FromPointerBuilder::get_from_pointer(
5479 self.builder.get_pointer_field(0),
5480 ::core::option::Option::None,
5481 )
5482 }
5483
5484 #[inline]
5485 pub fn set_path(&mut self, value: ::capnp::data::Reader<'_>) {
5486 self.builder.get_pointer_field(0).set_data(value);
5487 }
5488
5489 #[inline]
5490 pub fn init_path(self, size: u32) -> ::capnp::data::Builder<'a> {
5491 self.builder.get_pointer_field(0).init_data(size)
5492 }
5493
5494 pub fn has_path(&self) -> bool {
5495 !self.builder.get_pointer_field(0).is_null()
5496 }
5497 }
5498
5499 pub struct Pipeline {
5500 _typeless: ::capnp::any_pointer::Pipeline,
5501 }
5502 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
5503 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
5504 Pipeline {
5505 _typeless: typeless,
5506 }
5507 }
5508 }
5509 impl Pipeline {}
5510 mod _private {
5511 use capnp::private::layout;
5512 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
5513 data: 0,
5514 pointers: 1,
5515 };
5516 pub const TYPE_ID: u64 = 0xfbcb_e73c_071f_8bba;
5517 }
5518}
5519
5520pub mod asset_remove_event {
5521 #[derive(Copy, Clone)]
5522 pub struct Owned(());
5523 impl<'a> ::capnp::traits::Owned<'a> for Owned {
5524 type Builder = Builder<'a>;
5525 type Reader = Reader<'a>;
5526 }
5527 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
5528 type Builder = Builder<'a>;
5529 type Reader = Reader<'a>;
5530 }
5531 impl ::capnp::traits::Pipelined for Owned {
5532 type Pipeline = Pipeline;
5533 }
5534
5535 #[derive(Clone, Copy)]
5536 pub struct Reader<'a> {
5537 reader: ::capnp::private::layout::StructReader<'a>,
5538 }
5539
5540 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
5541 #[inline]
5542 fn type_id() -> u64 {
5543 _private::TYPE_ID
5544 }
5545 }
5546 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
5547 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
5548 Reader { reader }
5549 }
5550 }
5551
5552 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
5553 fn get_from_pointer(
5554 reader: &::capnp::private::layout::PointerReader<'a>,
5555 default: ::core::option::Option<&'a [capnp::Word]>,
5556 ) -> ::capnp::Result<Reader<'a>> {
5557 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
5558 reader.get_struct(default)?,
5559 ))
5560 }
5561 }
5562
5563 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
5564 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
5565 self.reader
5566 }
5567 }
5568
5569 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
5570 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
5571 self.reader
5572 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
5573 }
5574 }
5575
5576 impl<'a> Reader<'a> {
5577 pub fn reborrow(&self) -> Reader<'_> {
5578 Reader { ..*self }
5579 }
5580
5581 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5582 self.reader.total_size()
5583 }
5584
5585 #[inline]
5586 pub fn get_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Reader<'a>> {
5587 ::capnp::traits::FromPointerReader::get_from_pointer(
5588 &self.reader.get_pointer_field(0),
5589 ::core::option::Option::None,
5590 )
5591 }
5592
5593 pub fn has_id(&self) -> bool {
5594 !self.reader.get_pointer_field(0).is_null()
5595 }
5596 }
5597
5598 pub struct Builder<'a> {
5599 builder: ::capnp::private::layout::StructBuilder<'a>,
5600 }
5601 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
5602 #[inline]
5603 fn struct_size() -> ::capnp::private::layout::StructSize {
5604 _private::STRUCT_SIZE
5605 }
5606 }
5607 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
5608 #[inline]
5609 fn type_id() -> u64 {
5610 _private::TYPE_ID
5611 }
5612 }
5613 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
5614 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
5615 Builder { builder }
5616 }
5617 }
5618
5619 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
5620 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
5621 self.builder
5622 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
5623 }
5624 }
5625
5626 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
5627 fn init_pointer(
5628 builder: ::capnp::private::layout::PointerBuilder<'a>,
5629 _size: u32,
5630 ) -> Builder<'a> {
5631 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
5632 }
5633
5634 fn get_from_pointer(
5635 builder: ::capnp::private::layout::PointerBuilder<'a>,
5636 default: ::core::option::Option<&'a [capnp::Word]>,
5637 ) -> ::capnp::Result<Builder<'a>> {
5638 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
5639 builder.get_struct(_private::STRUCT_SIZE, default)?,
5640 ))
5641 }
5642 }
5643
5644 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
5645 fn set_pointer_builder<'b>(
5646 pointer: ::capnp::private::layout::PointerBuilder<'b>,
5647 value: Reader<'a>,
5648 canonicalize: bool,
5649 ) -> ::capnp::Result<()> {
5650 pointer.set_struct(&value.reader, canonicalize)
5651 }
5652 }
5653
5654 impl<'a> Builder<'a> {
5655 pub fn into_reader(self) -> Reader<'a> {
5656 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5657 }
5658
5659 pub fn reborrow(&mut self) -> Builder<'_> {
5660 Builder { ..*self }
5661 }
5662
5663 pub fn reborrow_as_reader(&self) -> Reader<'_> {
5664 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5665 }
5666
5667 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5668 self.builder.into_reader().total_size()
5669 }
5670
5671 #[inline]
5672 pub fn get_id(self) -> ::capnp::Result<crate::data_capnp::asset_uuid::Builder<'a>> {
5673 ::capnp::traits::FromPointerBuilder::get_from_pointer(
5674 self.builder.get_pointer_field(0),
5675 ::core::option::Option::None,
5676 )
5677 }
5678
5679 #[inline]
5680 pub fn set_id(
5681 &mut self,
5682 value: crate::data_capnp::asset_uuid::Reader<'_>,
5683 ) -> ::capnp::Result<()> {
5684 ::capnp::traits::SetPointerBuilder::set_pointer_builder(
5685 self.builder.get_pointer_field(0),
5686 value,
5687 false,
5688 )
5689 }
5690
5691 #[inline]
5692 pub fn init_id(self) -> crate::data_capnp::asset_uuid::Builder<'a> {
5693 ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0)
5694 }
5695
5696 pub fn has_id(&self) -> bool {
5697 !self.builder.get_pointer_field(0).is_null()
5698 }
5699 }
5700
5701 pub struct Pipeline {
5702 _typeless: ::capnp::any_pointer::Pipeline,
5703 }
5704 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
5705 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
5706 Pipeline {
5707 _typeless: typeless,
5708 }
5709 }
5710 }
5711 impl Pipeline {
5712 pub fn get_id(&self) -> crate::data_capnp::asset_uuid::Pipeline {
5713 ::capnp::capability::FromTypelessPipeline::new(self._typeless.get_pointer_field(0))
5714 }
5715 }
5716 mod _private {
5717 use capnp::private::layout;
5718 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
5719 data: 0,
5720 pointers: 1,
5721 };
5722 pub const TYPE_ID: u64 = 0xcc8d_878c_eae5_a1b2;
5723 }
5724}
5725
5726pub mod path_remove_event {
5727 #[derive(Copy, Clone)]
5728 pub struct Owned(());
5729 impl<'a> ::capnp::traits::Owned<'a> for Owned {
5730 type Builder = Builder<'a>;
5731 type Reader = Reader<'a>;
5732 }
5733 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
5734 type Builder = Builder<'a>;
5735 type Reader = Reader<'a>;
5736 }
5737 impl ::capnp::traits::Pipelined for Owned {
5738 type Pipeline = Pipeline;
5739 }
5740
5741 #[derive(Clone, Copy)]
5742 pub struct Reader<'a> {
5743 reader: ::capnp::private::layout::StructReader<'a>,
5744 }
5745
5746 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
5747 #[inline]
5748 fn type_id() -> u64 {
5749 _private::TYPE_ID
5750 }
5751 }
5752 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
5753 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
5754 Reader { reader }
5755 }
5756 }
5757
5758 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
5759 fn get_from_pointer(
5760 reader: &::capnp::private::layout::PointerReader<'a>,
5761 default: ::core::option::Option<&'a [capnp::Word]>,
5762 ) -> ::capnp::Result<Reader<'a>> {
5763 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
5764 reader.get_struct(default)?,
5765 ))
5766 }
5767 }
5768
5769 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
5770 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
5771 self.reader
5772 }
5773 }
5774
5775 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
5776 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
5777 self.reader
5778 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
5779 }
5780 }
5781
5782 impl<'a> Reader<'a> {
5783 pub fn reborrow(&self) -> Reader<'_> {
5784 Reader { ..*self }
5785 }
5786
5787 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5788 self.reader.total_size()
5789 }
5790
5791 #[inline]
5792 pub fn get_path(self) -> ::capnp::Result<::capnp::data::Reader<'a>> {
5793 ::capnp::traits::FromPointerReader::get_from_pointer(
5794 &self.reader.get_pointer_field(0),
5795 ::core::option::Option::None,
5796 )
5797 }
5798
5799 pub fn has_path(&self) -> bool {
5800 !self.reader.get_pointer_field(0).is_null()
5801 }
5802 }
5803
5804 pub struct Builder<'a> {
5805 builder: ::capnp::private::layout::StructBuilder<'a>,
5806 }
5807 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
5808 #[inline]
5809 fn struct_size() -> ::capnp::private::layout::StructSize {
5810 _private::STRUCT_SIZE
5811 }
5812 }
5813 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
5814 #[inline]
5815 fn type_id() -> u64 {
5816 _private::TYPE_ID
5817 }
5818 }
5819 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
5820 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
5821 Builder { builder }
5822 }
5823 }
5824
5825 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
5826 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
5827 self.builder
5828 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
5829 }
5830 }
5831
5832 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
5833 fn init_pointer(
5834 builder: ::capnp::private::layout::PointerBuilder<'a>,
5835 _size: u32,
5836 ) -> Builder<'a> {
5837 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
5838 }
5839
5840 fn get_from_pointer(
5841 builder: ::capnp::private::layout::PointerBuilder<'a>,
5842 default: ::core::option::Option<&'a [capnp::Word]>,
5843 ) -> ::capnp::Result<Builder<'a>> {
5844 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
5845 builder.get_struct(_private::STRUCT_SIZE, default)?,
5846 ))
5847 }
5848 }
5849
5850 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
5851 fn set_pointer_builder<'b>(
5852 pointer: ::capnp::private::layout::PointerBuilder<'b>,
5853 value: Reader<'a>,
5854 canonicalize: bool,
5855 ) -> ::capnp::Result<()> {
5856 pointer.set_struct(&value.reader, canonicalize)
5857 }
5858 }
5859
5860 impl<'a> Builder<'a> {
5861 pub fn into_reader(self) -> Reader<'a> {
5862 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5863 }
5864
5865 pub fn reborrow(&mut self) -> Builder<'_> {
5866 Builder { ..*self }
5867 }
5868
5869 pub fn reborrow_as_reader(&self) -> Reader<'_> {
5870 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
5871 }
5872
5873 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
5874 self.builder.into_reader().total_size()
5875 }
5876
5877 #[inline]
5878 pub fn get_path(self) -> ::capnp::Result<::capnp::data::Builder<'a>> {
5879 ::capnp::traits::FromPointerBuilder::get_from_pointer(
5880 self.builder.get_pointer_field(0),
5881 ::core::option::Option::None,
5882 )
5883 }
5884
5885 #[inline]
5886 pub fn set_path(&mut self, value: ::capnp::data::Reader<'_>) {
5887 self.builder.get_pointer_field(0).set_data(value);
5888 }
5889
5890 #[inline]
5891 pub fn init_path(self, size: u32) -> ::capnp::data::Builder<'a> {
5892 self.builder.get_pointer_field(0).init_data(size)
5893 }
5894
5895 pub fn has_path(&self) -> bool {
5896 !self.builder.get_pointer_field(0).is_null()
5897 }
5898 }
5899
5900 pub struct Pipeline {
5901 _typeless: ::capnp::any_pointer::Pipeline,
5902 }
5903 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
5904 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
5905 Pipeline {
5906 _typeless: typeless,
5907 }
5908 }
5909 }
5910 impl Pipeline {}
5911 mod _private {
5912 use capnp::private::layout;
5913 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
5914 data: 0,
5915 pointers: 1,
5916 };
5917 pub const TYPE_ID: u64 = 0x9df7_4b48_86ac_8d92;
5918 }
5919}
5920
5921#[repr(u16)]
5922#[derive(Clone, Copy, PartialEq)]
5923pub enum CompressionType {
5924 None = 0,
5925 Lz4 = 1,
5926}
5927impl ::capnp::traits::FromU16 for CompressionType {
5928 #[inline]
5929 fn from_u16(value: u16) -> ::core::result::Result<CompressionType, ::capnp::NotInSchema> {
5930 match value {
5931 0 => ::core::result::Result::Ok(CompressionType::None),
5932 1 => ::core::result::Result::Ok(CompressionType::Lz4),
5933 n => ::core::result::Result::Err(::capnp::NotInSchema(n)),
5934 }
5935 }
5936}
5937impl ::capnp::traits::ToU16 for CompressionType {
5938 #[inline]
5939 fn to_u16(self) -> u16 {
5940 self as u16
5941 }
5942}
5943impl ::capnp::traits::HasTypeId for CompressionType {
5944 #[inline]
5945 fn type_id() -> u64 {
5946 0xb107_ee10_2573_84c9u64
5947 }
5948}
5949
5950pub mod daemon_info {
5951 #[derive(Copy, Clone)]
5952 pub struct Owned(());
5953 impl<'a> ::capnp::traits::Owned<'a> for Owned {
5954 type Builder = Builder<'a>;
5955 type Reader = Reader<'a>;
5956 }
5957 impl<'a> ::capnp::traits::OwnedStruct<'a> for Owned {
5958 type Builder = Builder<'a>;
5959 type Reader = Reader<'a>;
5960 }
5961 impl ::capnp::traits::Pipelined for Owned {
5962 type Pipeline = Pipeline;
5963 }
5964
5965 #[derive(Clone, Copy)]
5966 pub struct Reader<'a> {
5967 reader: ::capnp::private::layout::StructReader<'a>,
5968 }
5969
5970 impl<'a> ::capnp::traits::HasTypeId for Reader<'a> {
5971 #[inline]
5972 fn type_id() -> u64 {
5973 _private::TYPE_ID
5974 }
5975 }
5976 impl<'a> ::capnp::traits::FromStructReader<'a> for Reader<'a> {
5977 fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a> {
5978 Reader { reader }
5979 }
5980 }
5981
5982 impl<'a> ::capnp::traits::FromPointerReader<'a> for Reader<'a> {
5983 fn get_from_pointer(
5984 reader: &::capnp::private::layout::PointerReader<'a>,
5985 default: ::core::option::Option<&'a [capnp::Word]>,
5986 ) -> ::capnp::Result<Reader<'a>> {
5987 ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(
5988 reader.get_struct(default)?,
5989 ))
5990 }
5991 }
5992
5993 impl<'a> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a> {
5994 fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {
5995 self.reader
5996 }
5997 }
5998
5999 impl<'a> ::capnp::traits::Imbue<'a> for Reader<'a> {
6000 fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) {
6001 self.reader
6002 .imbue(::capnp::private::layout::CapTableReader::Plain(cap_table))
6003 }
6004 }
6005
6006 impl<'a> Reader<'a> {
6007 pub fn reborrow(&self) -> Reader<'_> {
6008 Reader { ..*self }
6009 }
6010
6011 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
6012 self.reader.total_size()
6013 }
6014
6015 #[inline]
6016 pub fn get_version(self) -> u32 {
6017 self.reader.get_data_field::<u32>(0)
6018 }
6019 }
6020
6021 pub struct Builder<'a> {
6022 builder: ::capnp::private::layout::StructBuilder<'a>,
6023 }
6024 impl<'a> ::capnp::traits::HasStructSize for Builder<'a> {
6025 #[inline]
6026 fn struct_size() -> ::capnp::private::layout::StructSize {
6027 _private::STRUCT_SIZE
6028 }
6029 }
6030 impl<'a> ::capnp::traits::HasTypeId for Builder<'a> {
6031 #[inline]
6032 fn type_id() -> u64 {
6033 _private::TYPE_ID
6034 }
6035 }
6036 impl<'a> ::capnp::traits::FromStructBuilder<'a> for Builder<'a> {
6037 fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a> {
6038 Builder { builder }
6039 }
6040 }
6041
6042 impl<'a> ::capnp::traits::ImbueMut<'a> for Builder<'a> {
6043 fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) {
6044 self.builder
6045 .imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table))
6046 }
6047 }
6048
6049 impl<'a> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a> {
6050 fn init_pointer(
6051 builder: ::capnp::private::layout::PointerBuilder<'a>,
6052 _size: u32,
6053 ) -> Builder<'a> {
6054 ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))
6055 }
6056
6057 fn get_from_pointer(
6058 builder: ::capnp::private::layout::PointerBuilder<'a>,
6059 default: ::core::option::Option<&'a [capnp::Word]>,
6060 ) -> ::capnp::Result<Builder<'a>> {
6061 ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(
6062 builder.get_struct(_private::STRUCT_SIZE, default)?,
6063 ))
6064 }
6065 }
6066
6067 impl<'a> ::capnp::traits::SetPointerBuilder for Reader<'a> {
6068 fn set_pointer_builder<'b>(
6069 pointer: ::capnp::private::layout::PointerBuilder<'b>,
6070 value: Reader<'a>,
6071 canonicalize: bool,
6072 ) -> ::capnp::Result<()> {
6073 pointer.set_struct(&value.reader, canonicalize)
6074 }
6075 }
6076
6077 impl<'a> Builder<'a> {
6078 pub fn into_reader(self) -> Reader<'a> {
6079 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
6080 }
6081
6082 pub fn reborrow(&mut self) -> Builder<'_> {
6083 Builder { ..*self }
6084 }
6085
6086 pub fn reborrow_as_reader(&self) -> Reader<'_> {
6087 ::capnp::traits::FromStructReader::new(self.builder.into_reader())
6088 }
6089
6090 pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {
6091 self.builder.into_reader().total_size()
6092 }
6093
6094 #[inline]
6095 pub fn get_version(self) -> u32 {
6096 self.builder.get_data_field::<u32>(0)
6097 }
6098
6099 #[inline]
6100 pub fn set_version(&mut self, value: u32) {
6101 self.builder.set_data_field::<u32>(0, value);
6102 }
6103 }
6104
6105 pub struct Pipeline {
6106 _typeless: ::capnp::any_pointer::Pipeline,
6107 }
6108 impl ::capnp::capability::FromTypelessPipeline for Pipeline {
6109 fn new(typeless: ::capnp::any_pointer::Pipeline) -> Pipeline {
6110 Pipeline {
6111 _typeless: typeless,
6112 }
6113 }
6114 }
6115 impl Pipeline {}
6116 mod _private {
6117 use capnp::private::layout;
6118 pub const STRUCT_SIZE: layout::StructSize = layout::StructSize {
6119 data: 1,
6120 pointers: 0,
6121 };
6122 pub const TYPE_ID: u64 = 0xfb47_4a44_2e6a_1a86;
6123 }
6124}