1#[rustfmt::skip]
3#[doc(hidden)]
4static __BOXOLOGY_CONTRACT_DESCRIPTOR: ::std::sync::LazyLock<
5 ::boxology_contract::ContractDescriptor,
6> = ::std::sync::LazyLock::new(|| {
7 let box_id = ::boxology_contract::BoxId::new("classifier")
8 .expect("generated box identity is valid");
9 let error = ::boxology_contract::TypeDescriptor::enumeration([
10 ::boxology_contract::VariantDescriptor::new(
11 "Internal",
12 ::boxology_contract::VariantPayload::Unit,
13 None,
14 ),
15 ])
16 .expect("generated error descriptor is valid");
17 let capability = ::boxology_contract::CapabilityDescriptor::new(
18 ::boxology_contract::CapabilityId::new(
19 box_id.clone(),
20 ::boxology_contract::CapabilityName::new("classify")
21 .expect("generated capability name is valid"),
22 ),
23 ::boxology_contract::TypeDescriptor::structure([
24 ::boxology_contract::FieldDescriptor::new(
25 "base",
26 ::boxology_contract::TypeDescriptor::optional(
27 ::boxology_contract::TypeDescriptor::list(
28 ::boxology_contract::TypeDescriptor::u8(),
29 )
30 .expect("generated list descriptor is valid"),
31 )
32 .expect("generated optional descriptor is valid"),
33 None,
34 ),
35 ::boxology_contract::FieldDescriptor::new(
36 "submitted",
37 ::boxology_contract::TypeDescriptor::list(
38 ::boxology_contract::TypeDescriptor::u8(),
39 )
40 .expect("generated list descriptor is valid"),
41 None,
42 ),
43 ])
44 .expect("generated struct descriptor is valid"),
45 ::boxology_contract::TypeDescriptor::structure([
46 ::boxology_contract::FieldDescriptor::new(
47 "report",
48 ::boxology_contract::TypeDescriptor::optional(
49 ::boxology_contract::TypeDescriptor::structure([
50 ::boxology_contract::FieldDescriptor::new(
51 "verdict",
52 ::boxology_contract::TypeDescriptor::enumeration([
53 ::boxology_contract::VariantDescriptor::new(
54 "Unchanged",
55 ::boxology_contract::VariantPayload::Unit,
56 None,
57 ),
58 ::boxology_contract::VariantDescriptor::new(
59 "Documentation",
60 ::boxology_contract::VariantPayload::Unit,
61 None,
62 ),
63 ::boxology_contract::VariantDescriptor::new(
64 "Deprecation",
65 ::boxology_contract::VariantPayload::Unit,
66 None,
67 ),
68 ::boxology_contract::VariantDescriptor::new(
69 "Additive",
70 ::boxology_contract::VariantPayload::Unit,
71 None,
72 ),
73 ::boxology_contract::VariantDescriptor::new(
74 "CompatibleWithConditions",
75 ::boxology_contract::VariantPayload::Unit,
76 None,
77 ),
78 ::boxology_contract::VariantDescriptor::new(
79 "Incompatible",
80 ::boxology_contract::VariantPayload::Unit,
81 None,
82 ),
83 ])
84 .expect("generated enum descriptor is valid"),
85 None,
86 ),
87 ::boxology_contract::FieldDescriptor::new(
88 "findings",
89 ::boxology_contract::TypeDescriptor::list(
90 ::boxology_contract::TypeDescriptor::structure([
91 ::boxology_contract::FieldDescriptor::new(
92 "code",
93 ::boxology_contract::TypeDescriptor::string(),
94 None,
95 ),
96 ::boxology_contract::FieldDescriptor::new(
97 "path",
98 ::boxology_contract::TypeDescriptor::string(),
99 None,
100 ),
101 ::boxology_contract::FieldDescriptor::new(
102 "kind",
103 ::boxology_contract::TypeDescriptor::string(),
104 None,
105 ),
106 ::boxology_contract::FieldDescriptor::new(
107 "class",
108 ::boxology_contract::TypeDescriptor::enumeration([
109 ::boxology_contract::VariantDescriptor::new(
110 "Unchanged",
111 ::boxology_contract::VariantPayload::Unit,
112 None,
113 ),
114 ::boxology_contract::VariantDescriptor::new(
115 "Documentation",
116 ::boxology_contract::VariantPayload::Unit,
117 None,
118 ),
119 ::boxology_contract::VariantDescriptor::new(
120 "Deprecation",
121 ::boxology_contract::VariantPayload::Unit,
122 None,
123 ),
124 ::boxology_contract::VariantDescriptor::new(
125 "Additive",
126 ::boxology_contract::VariantPayload::Unit,
127 None,
128 ),
129 ::boxology_contract::VariantDescriptor::new(
130 "CompatibleWithConditions",
131 ::boxology_contract::VariantPayload::Unit,
132 None,
133 ),
134 ::boxology_contract::VariantDescriptor::new(
135 "Incompatible",
136 ::boxology_contract::VariantPayload::Unit,
137 None,
138 ),
139 ])
140 .expect("generated enum descriptor is valid"),
141 None,
142 ),
143 ::boxology_contract::FieldDescriptor::new(
144 "base_excerpt",
145 ::boxology_contract::TypeDescriptor::optional(
146 ::boxology_contract::TypeDescriptor::string(),
147 )
148 .expect("generated optional descriptor is valid"),
149 None,
150 ),
151 ::boxology_contract::FieldDescriptor::new(
152 "submitted_excerpt",
153 ::boxology_contract::TypeDescriptor::optional(
154 ::boxology_contract::TypeDescriptor::string(),
155 )
156 .expect("generated optional descriptor is valid"),
157 None,
158 ),
159 ::boxology_contract::FieldDescriptor::new(
160 "condition",
161 ::boxology_contract::TypeDescriptor::optional(
162 ::boxology_contract::TypeDescriptor::string(),
163 )
164 .expect("generated optional descriptor is valid"),
165 None,
166 ),
167 ])
168 .expect("generated struct descriptor is valid"),
169 )
170 .expect("generated list descriptor is valid"),
171 None,
172 ),
173 ::boxology_contract::FieldDescriptor::new(
174 "rendered_text",
175 ::boxology_contract::TypeDescriptor::string(),
176 None,
177 ),
178 ])
179 .expect("generated struct descriptor is valid"),
180 )
181 .expect("generated optional descriptor is valid"),
182 None,
183 ),
184 ::boxology_contract::FieldDescriptor::new(
185 "failure",
186 ::boxology_contract::TypeDescriptor::optional(
187 ::boxology_contract::TypeDescriptor::structure([
188 ::boxology_contract::FieldDescriptor::new(
189 "stage",
190 ::boxology_contract::TypeDescriptor::enumeration([
191 ::boxology_contract::VariantDescriptor::new(
192 "Base",
193 ::boxology_contract::VariantPayload::Unit,
194 None,
195 ),
196 ::boxology_contract::VariantDescriptor::new(
197 "Submitted",
198 ::boxology_contract::VariantPayload::Unit,
199 None,
200 ),
201 ::boxology_contract::VariantDescriptor::new(
202 "Pairing",
203 ::boxology_contract::VariantPayload::Unit,
204 None,
205 ),
206 ])
207 .expect("generated enum descriptor is valid"),
208 None,
209 ),
210 ::boxology_contract::FieldDescriptor::new(
211 "diagnostics",
212 ::boxology_contract::TypeDescriptor::string(),
213 None,
214 ),
215 ])
216 .expect("generated struct descriptor is valid"),
217 )
218 .expect("generated optional descriptor is valid"),
219 None,
220 ),
221 ])
222 .expect("generated struct descriptor is valid"),
223 error,
224 ::boxology_contract::CapabilityShape::Unary,
225 ::boxology_contract::ExposureLevel::CodeOnly,
226 ::boxology_contract::Idempotency::None,
227 None,
228 );
229 ::boxology_contract::ContractDescriptor::new(
230 box_id,
231 [capability],
232 ::boxology_contract::ContractRevision::new(
233 "sha256:c615a71958fd24f37973ef962d34a3c349bd87901bf92e83712a9e6ba367a536",
234 )
235 .expect("generated contract revision is non-empty"),
236 )
237 .expect("generated contract descriptor is valid")
238});
239#[rustfmt::skip]
240pub fn contract_descriptor() -> &'static ::boxology_contract::ContractDescriptor {
242 &__BOXOLOGY_CONTRACT_DESCRIPTOR
243}
244#[rustfmt::skip]
245use std::future::Future;
246#[rustfmt::skip]
247use std::pin::Pin;
248#[rustfmt::skip]
249use std::sync::{Arc, LazyLock};
250#[rustfmt::skip]
251use ::boxology_contract::{
252 BoxId, CallContext, CallError, CapabilityId, CapabilityName, ContractType,
253 DecodeRole, Detail, ErasedCallTarget, TypeDescriptor,
254};
255#[rustfmt::skip]
256pub trait ClassifierDispatch: Send + Sync + 'static {
257 fn classify<'a>(
258 &'a self,
259 context: CallContext,
260 request: ClassifyRequest,
261 ) -> Pin<
262 Box<dyn Future<Output = Result<ClassifyOutcome, ClassifierError>> + Send + 'a>,
263 >;
264}
265#[rustfmt::skip]
266#[derive(Clone)]
267pub struct ClassifierHandle {
268 target: Arc<dyn ErasedCallTarget>,
269}
270#[rustfmt::skip]
271impl ClassifierHandle {
272 #[doc(hidden)]
273 pub fn from_erased(target: Arc<dyn ErasedCallTarget>) -> Self {
274 Self { target }
275 }
276 pub async fn classify(
277 &self,
278 context: CallContext,
279 request: ClassifyRequest,
280 ) -> Result<ClassifyOutcome, CallError<ClassifierError>> {
281 let input = request
282 .encode()
283 .map_err(|error| conversion_detail("input_encode", error))
284 .map_err(CallError::ContractViolation)?;
285 let output = self
286 .target
287 .call(&CLASSIFIER_CLASSIFY, context, input)
288 .await
289 .map_err(|error| {
290 error.into_typed::<ClassifierError>(&CLASSIFIER_ERROR_DESCRIPTOR)
291 })?;
292 let output = TypeDescriptor::structure([
293 ::boxology_contract::FieldDescriptor::new(
294 "report",
295 TypeDescriptor::optional(
296 TypeDescriptor::structure([
297 ::boxology_contract::FieldDescriptor::new(
298 "verdict",
299 TypeDescriptor::enumeration([
300 ::boxology_contract::VariantDescriptor::new(
301 "Unchanged",
302 ::boxology_contract::VariantPayload::Unit,
303 None,
304 ),
305 ::boxology_contract::VariantDescriptor::new(
306 "Documentation",
307 ::boxology_contract::VariantPayload::Unit,
308 None,
309 ),
310 ::boxology_contract::VariantDescriptor::new(
311 "Deprecation",
312 ::boxology_contract::VariantPayload::Unit,
313 None,
314 ),
315 ::boxology_contract::VariantDescriptor::new(
316 "Additive",
317 ::boxology_contract::VariantPayload::Unit,
318 None,
319 ),
320 ::boxology_contract::VariantDescriptor::new(
321 "CompatibleWithConditions",
322 ::boxology_contract::VariantPayload::Unit,
323 None,
324 ),
325 ::boxology_contract::VariantDescriptor::new(
326 "Incompatible",
327 ::boxology_contract::VariantPayload::Unit,
328 None,
329 ),
330 ])
331 .expect("generated enum descriptor is valid"),
332 None,
333 ),
334 ::boxology_contract::FieldDescriptor::new(
335 "findings",
336 TypeDescriptor::list(
337 TypeDescriptor::structure([
338 ::boxology_contract::FieldDescriptor::new(
339 "code",
340 TypeDescriptor::string(),
341 None,
342 ),
343 ::boxology_contract::FieldDescriptor::new(
344 "path",
345 TypeDescriptor::string(),
346 None,
347 ),
348 ::boxology_contract::FieldDescriptor::new(
349 "kind",
350 TypeDescriptor::string(),
351 None,
352 ),
353 ::boxology_contract::FieldDescriptor::new(
354 "class",
355 TypeDescriptor::enumeration([
356 ::boxology_contract::VariantDescriptor::new(
357 "Unchanged",
358 ::boxology_contract::VariantPayload::Unit,
359 None,
360 ),
361 ::boxology_contract::VariantDescriptor::new(
362 "Documentation",
363 ::boxology_contract::VariantPayload::Unit,
364 None,
365 ),
366 ::boxology_contract::VariantDescriptor::new(
367 "Deprecation",
368 ::boxology_contract::VariantPayload::Unit,
369 None,
370 ),
371 ::boxology_contract::VariantDescriptor::new(
372 "Additive",
373 ::boxology_contract::VariantPayload::Unit,
374 None,
375 ),
376 ::boxology_contract::VariantDescriptor::new(
377 "CompatibleWithConditions",
378 ::boxology_contract::VariantPayload::Unit,
379 None,
380 ),
381 ::boxology_contract::VariantDescriptor::new(
382 "Incompatible",
383 ::boxology_contract::VariantPayload::Unit,
384 None,
385 ),
386 ])
387 .expect("generated enum descriptor is valid"),
388 None,
389 ),
390 ::boxology_contract::FieldDescriptor::new(
391 "base_excerpt",
392 TypeDescriptor::optional(TypeDescriptor::string())
393 .expect("generated optional descriptor is valid"),
394 None,
395 ),
396 ::boxology_contract::FieldDescriptor::new(
397 "submitted_excerpt",
398 TypeDescriptor::optional(TypeDescriptor::string())
399 .expect("generated optional descriptor is valid"),
400 None,
401 ),
402 ::boxology_contract::FieldDescriptor::new(
403 "condition",
404 TypeDescriptor::optional(TypeDescriptor::string())
405 .expect("generated optional descriptor is valid"),
406 None,
407 ),
408 ])
409 .expect("generated struct descriptor is valid"),
410 )
411 .expect("generated list descriptor is valid"),
412 None,
413 ),
414 ::boxology_contract::FieldDescriptor::new(
415 "rendered_text",
416 TypeDescriptor::string(),
417 None,
418 ),
419 ])
420 .expect("generated struct descriptor is valid"),
421 )
422 .expect("generated optional descriptor is valid"),
423 None,
424 ),
425 ::boxology_contract::FieldDescriptor::new(
426 "failure",
427 TypeDescriptor::optional(
428 TypeDescriptor::structure([
429 ::boxology_contract::FieldDescriptor::new(
430 "stage",
431 TypeDescriptor::enumeration([
432 ::boxology_contract::VariantDescriptor::new(
433 "Base",
434 ::boxology_contract::VariantPayload::Unit,
435 None,
436 ),
437 ::boxology_contract::VariantDescriptor::new(
438 "Submitted",
439 ::boxology_contract::VariantPayload::Unit,
440 None,
441 ),
442 ::boxology_contract::VariantDescriptor::new(
443 "Pairing",
444 ::boxology_contract::VariantPayload::Unit,
445 None,
446 ),
447 ])
448 .expect("generated enum descriptor is valid"),
449 None,
450 ),
451 ::boxology_contract::FieldDescriptor::new(
452 "diagnostics",
453 TypeDescriptor::string(),
454 None,
455 ),
456 ])
457 .expect("generated struct descriptor is valid"),
458 )
459 .expect("generated optional descriptor is valid"),
460 None,
461 ),
462 ])
463 .expect("generated struct descriptor is valid")
464 .conform(DecodeRole::ConsumerOutput, output)
465 .map_err(|error| conversion_detail("output_decode", error))
466 .map_err(CallError::InvalidResponse)?;
467 <ClassifyOutcome as ContractType>::decode(&output)
468 .map_err(|error| conversion_detail("output_decode", error))
469 .map_err(CallError::InvalidResponse)
470 }
471}
472#[rustfmt::skip]
473impl ::boxology_contract::BoxHandle for ClassifierHandle {
474 fn from_erased(target: Arc<dyn ErasedCallTarget>) -> Self {
475 Self::from_erased(target)
476 }
477}
478#[rustfmt::skip]
479static CLASSIFIER_CLASSIFY: LazyLock<CapabilityId> = LazyLock::new(|| {
480 CapabilityId::new(
481 BoxId::new("classifier").expect("generated box identity is valid"),
482 CapabilityName::new("classify").expect("generated capability name is valid"),
483 )
484});
485#[rustfmt::skip]
486static CLASSIFIER_ERROR_DESCRIPTOR: LazyLock<TypeDescriptor> = LazyLock::new(|| {
487 TypeDescriptor::enumeration([
488 ::boxology_contract::VariantDescriptor::new(
489 "Internal",
490 ::boxology_contract::VariantPayload::Unit,
491 None,
492 ),
493 ])
494 .expect("generated classifier error descriptor is valid")
495});
496#[rustfmt::skip]
497fn conversion_detail(code: &'static str, error: impl std::fmt::Display) -> Detail {
498 Detail::new(code).with_message(error.to_string())
499}
500#[rustfmt::skip]
501#[derive(Debug, Clone, PartialEq, Default)]
502pub enum CompatibilityClass {
503 #[default]
504 Unchanged,
505 Documentation,
506 Deprecation,
507 Additive,
508 CompatibleWithConditions,
509 Incompatible,
510 Unknown { tag: ::std::string::String, payload: ::boxology_contract::OpaquePayload },
511}
512#[rustfmt::skip]
513impl ::boxology_contract::ContractType for CompatibilityClass {
514 fn encode_value(
515 &self,
516 ) -> ::core::result::Result<
517 ::boxology_contract::ContractValue,
518 ::boxology_contract::EncodeError,
519 > {
520 let (tag, payload) = match self {
521 Self::Unchanged => ("Unchanged".into(), ::boxology_contract::SlotValue::Null),
522 Self::Documentation => {
523 ("Documentation".into(), ::boxology_contract::SlotValue::Null)
524 }
525 Self::Deprecation => {
526 ("Deprecation".into(), ::boxology_contract::SlotValue::Null)
527 }
528 Self::Additive => ("Additive".into(), ::boxology_contract::SlotValue::Null),
529 Self::CompatibleWithConditions => {
530 ("CompatibleWithConditions".into(), ::boxology_contract::SlotValue::Null)
531 }
532 Self::Incompatible => {
533 ("Incompatible".into(), ::boxology_contract::SlotValue::Null)
534 }
535 Self::Unknown { tag, payload } => {
536 (
537 tag.clone(),
538 ::boxology_contract::SlotValue::Value(
539 ::boxology_contract::ContractValue::opaque(payload.forward()),
540 ),
541 )
542 }
543 };
544 Ok(::boxology_contract::ContractValue::enum_value(tag, payload))
545 }
546 fn decode_value(
547 value: &::boxology_contract::ContractValue,
548 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
549 let ::boxology_contract::ValueRef::Enum { tag, payload } = value.view() else {
550 return Err(
551 ::boxology_contract::DecodeError::new(
552 ::boxology_contract::DecodeErrorKind::KindMismatch,
553 ),
554 );
555 };
556 match tag {
557 "Unchanged" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
558 Ok(Self::Unchanged)
559 }
560 "Unchanged" => {
561 Err(
562 ::boxology_contract::DecodeError::new(
563 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
564 )
565 .under(::boxology_contract::PathSegment::Variant(tag.into())),
566 )
567 }
568 "Documentation" if matches!(
569 payload, ::boxology_contract::SlotValue::Null
570 ) => Ok(Self::Documentation),
571 "Documentation" => {
572 Err(
573 ::boxology_contract::DecodeError::new(
574 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
575 )
576 .under(::boxology_contract::PathSegment::Variant(tag.into())),
577 )
578 }
579 "Deprecation" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
580 Ok(Self::Deprecation)
581 }
582 "Deprecation" => {
583 Err(
584 ::boxology_contract::DecodeError::new(
585 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
586 )
587 .under(::boxology_contract::PathSegment::Variant(tag.into())),
588 )
589 }
590 "Additive" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
591 Ok(Self::Additive)
592 }
593 "Additive" => {
594 Err(
595 ::boxology_contract::DecodeError::new(
596 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
597 )
598 .under(::boxology_contract::PathSegment::Variant(tag.into())),
599 )
600 }
601 "CompatibleWithConditions" if matches!(
602 payload, ::boxology_contract::SlotValue::Null
603 ) => Ok(Self::CompatibleWithConditions),
604 "CompatibleWithConditions" => {
605 Err(
606 ::boxology_contract::DecodeError::new(
607 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
608 )
609 .under(::boxology_contract::PathSegment::Variant(tag.into())),
610 )
611 }
612 "Incompatible" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
613 Ok(Self::Incompatible)
614 }
615 "Incompatible" => {
616 Err(
617 ::boxology_contract::DecodeError::new(
618 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
619 )
620 .under(::boxology_contract::PathSegment::Variant(tag.into())),
621 )
622 }
623 _ => {
624 match payload {
625 ::boxology_contract::SlotValue::Value(value) => {
626 match value.view() {
627 ::boxology_contract::ValueRef::Opaque(payload) => {
628 Ok(Self::Unknown {
629 tag: tag.into(),
630 payload: payload.forward(),
631 })
632 }
633 _ => {
634 Err(
635 ::boxology_contract::DecodeError::new(
636 ::boxology_contract::DecodeErrorKind::UnknownVariant(
637 tag.into(),
638 ),
639 )
640 .under(
641 ::boxology_contract::PathSegment::Variant(tag.into()),
642 ),
643 )
644 }
645 }
646 }
647 _ => {
648 Err(
649 ::boxology_contract::DecodeError::new(
650 ::boxology_contract::DecodeErrorKind::UnknownVariant(
651 tag.into(),
652 ),
653 )
654 .under(
655 ::boxology_contract::PathSegment::Variant(tag.into()),
656 ),
657 )
658 }
659 }
660 }
661 }
662 }
663}
664#[rustfmt::skip]
665#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
666pub struct ClassifyRequest {
667 pub base: ::core::option::Option<::std::vec::Vec<u8>>,
668 pub submitted: ::std::vec::Vec<u8>,
669}
670#[rustfmt::skip]
671impl ::boxology_contract::ContractType for ClassifyRequest {
672 fn encode_value(
673 &self,
674 ) -> ::core::result::Result<
675 ::boxology_contract::ContractValue,
676 ::boxology_contract::EncodeError,
677 > {
678 let mut fields = ::std::vec::Vec::new();
679 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.base)
680 .map_err(|error| {
681 error.under(::boxology_contract::PathSegment::Field("base".into()))
682 })?
683 {
684 fields.push(("base".into(), value));
685 }
686 if let Some(value) = ::boxology_contract::ContractType::encode_field(
687 &self.submitted,
688 )
689 .map_err(|error| {
690 error.under(::boxology_contract::PathSegment::Field("submitted".into()))
691 })?
692 {
693 fields.push(("submitted".into(), value));
694 }
695 ::boxology_contract::ContractValue::object(fields)
696 .map_err(|_| unreachable!("validated generated field identities are unique"))
697 }
698 fn decode_value(
699 value: &::boxology_contract::ContractValue,
700 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
701 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
702 return Err(
703 ::boxology_contract::DecodeError::new(
704 ::boxology_contract::DecodeErrorKind::KindMismatch,
705 ),
706 );
707 };
708 for (field, _) in fields.entries() {
709 match field {
710 "base" | "submitted" => {}
711 _ => {
712 return Err(
713 ::boxology_contract::DecodeError::new(
714 ::boxology_contract::DecodeErrorKind::UnknownField(
715 field.into(),
716 ),
717 )
718 .under(::boxology_contract::PathSegment::Field(field.into())),
719 );
720 }
721 }
722 }
723 Ok(Self {
724 base: <::core::option::Option<
725 ::std::vec::Vec<u8>,
726 > as ::boxology_contract::ContractType>::decode_field(fields.get("base"))
727 .map_err(|error| {
728 error.under(::boxology_contract::PathSegment::Field("base".into()))
729 })?,
730 submitted: <::std::vec::Vec<
731 u8,
732 > as ::boxology_contract::ContractType>::decode_field(
733 fields.get("submitted"),
734 )
735 .map_err(|error| {
736 error
737 .under(
738 ::boxology_contract::PathSegment::Field("submitted".into()),
739 )
740 })?,
741 })
742 }
743}
744#[rustfmt::skip]
745#[derive(Debug, Clone, PartialEq, Default)]
746pub struct ClassifyFinding {
747 pub code: ::std::string::String,
748 pub path: ::std::string::String,
749 pub kind: ::std::string::String,
750 pub class: CompatibilityClass,
751 pub base_excerpt: ::core::option::Option<::std::string::String>,
752 pub submitted_excerpt: ::core::option::Option<::std::string::String>,
753 pub condition: ::core::option::Option<::std::string::String>,
754}
755#[rustfmt::skip]
756impl ::boxology_contract::ContractType for ClassifyFinding {
757 fn encode_value(
758 &self,
759 ) -> ::core::result::Result<
760 ::boxology_contract::ContractValue,
761 ::boxology_contract::EncodeError,
762 > {
763 let mut fields = ::std::vec::Vec::new();
764 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.code)
765 .map_err(|error| {
766 error.under(::boxology_contract::PathSegment::Field("code".into()))
767 })?
768 {
769 fields.push(("code".into(), value));
770 }
771 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.path)
772 .map_err(|error| {
773 error.under(::boxology_contract::PathSegment::Field("path".into()))
774 })?
775 {
776 fields.push(("path".into(), value));
777 }
778 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.kind)
779 .map_err(|error| {
780 error.under(::boxology_contract::PathSegment::Field("kind".into()))
781 })?
782 {
783 fields.push(("kind".into(), value));
784 }
785 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.class)
786 .map_err(|error| {
787 error.under(::boxology_contract::PathSegment::Field("class".into()))
788 })?
789 {
790 fields.push(("class".into(), value));
791 }
792 if let Some(value) = ::boxology_contract::ContractType::encode_field(
793 &self.base_excerpt,
794 )
795 .map_err(|error| {
796 error
797 .under(
798 ::boxology_contract::PathSegment::Field("base_excerpt".into()),
799 )
800 })?
801 {
802 fields.push(("base_excerpt".into(), value));
803 }
804 if let Some(value) = ::boxology_contract::ContractType::encode_field(
805 &self.submitted_excerpt,
806 )
807 .map_err(|error| {
808 error
809 .under(
810 ::boxology_contract::PathSegment::Field(
811 "submitted_excerpt".into(),
812 ),
813 )
814 })?
815 {
816 fields.push(("submitted_excerpt".into(), value));
817 }
818 if let Some(value) = ::boxology_contract::ContractType::encode_field(
819 &self.condition,
820 )
821 .map_err(|error| {
822 error.under(::boxology_contract::PathSegment::Field("condition".into()))
823 })?
824 {
825 fields.push(("condition".into(), value));
826 }
827 ::boxology_contract::ContractValue::object(fields)
828 .map_err(|_| unreachable!("validated generated field identities are unique"))
829 }
830 fn decode_value(
831 value: &::boxology_contract::ContractValue,
832 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
833 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
834 return Err(
835 ::boxology_contract::DecodeError::new(
836 ::boxology_contract::DecodeErrorKind::KindMismatch,
837 ),
838 );
839 };
840 for (field, _) in fields.entries() {
841 match field {
842 "code" | "path" | "kind" | "class" | "base_excerpt" | "submitted_excerpt"
843 | "condition" => {}
844 _ => {
845 return Err(
846 ::boxology_contract::DecodeError::new(
847 ::boxology_contract::DecodeErrorKind::UnknownField(
848 field.into(),
849 ),
850 )
851 .under(::boxology_contract::PathSegment::Field(field.into())),
852 );
853 }
854 }
855 }
856 Ok(Self {
857 code: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
858 fields.get("code"),
859 )
860 .map_err(|error| {
861 error.under(::boxology_contract::PathSegment::Field("code".into()))
862 })?,
863 path: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
864 fields.get("path"),
865 )
866 .map_err(|error| {
867 error.under(::boxology_contract::PathSegment::Field("path".into()))
868 })?,
869 kind: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
870 fields.get("kind"),
871 )
872 .map_err(|error| {
873 error.under(::boxology_contract::PathSegment::Field("kind".into()))
874 })?,
875 class: <CompatibilityClass as ::boxology_contract::ContractType>::decode_field(
876 fields.get("class"),
877 )
878 .map_err(|error| {
879 error.under(::boxology_contract::PathSegment::Field("class".into()))
880 })?,
881 base_excerpt: <::core::option::Option<
882 ::std::string::String,
883 > as ::boxology_contract::ContractType>::decode_field(
884 fields.get("base_excerpt"),
885 )
886 .map_err(|error| {
887 error
888 .under(
889 ::boxology_contract::PathSegment::Field(
890 "base_excerpt".into(),
891 ),
892 )
893 })?,
894 submitted_excerpt: <::core::option::Option<
895 ::std::string::String,
896 > as ::boxology_contract::ContractType>::decode_field(
897 fields.get("submitted_excerpt"),
898 )
899 .map_err(|error| {
900 error
901 .under(
902 ::boxology_contract::PathSegment::Field(
903 "submitted_excerpt".into(),
904 ),
905 )
906 })?,
907 condition: <::core::option::Option<
908 ::std::string::String,
909 > as ::boxology_contract::ContractType>::decode_field(
910 fields.get("condition"),
911 )
912 .map_err(|error| {
913 error
914 .under(
915 ::boxology_contract::PathSegment::Field("condition".into()),
916 )
917 })?,
918 })
919 }
920}
921#[rustfmt::skip]
922#[derive(Debug, Clone, PartialEq, Default)]
923pub struct ClassifyReport {
924 pub verdict: CompatibilityClass,
925 pub findings: ::std::vec::Vec<ClassifyFinding>,
926 pub rendered_text: ::std::string::String,
927}
928#[rustfmt::skip]
929impl ::boxology_contract::ContractType for ClassifyReport {
930 fn encode_value(
931 &self,
932 ) -> ::core::result::Result<
933 ::boxology_contract::ContractValue,
934 ::boxology_contract::EncodeError,
935 > {
936 let mut fields = ::std::vec::Vec::new();
937 if let Some(value) = ::boxology_contract::ContractType::encode_field(
938 &self.verdict,
939 )
940 .map_err(|error| {
941 error.under(::boxology_contract::PathSegment::Field("verdict".into()))
942 })?
943 {
944 fields.push(("verdict".into(), value));
945 }
946 if let Some(value) = ::boxology_contract::ContractType::encode_field(
947 &self.findings,
948 )
949 .map_err(|error| {
950 error.under(::boxology_contract::PathSegment::Field("findings".into()))
951 })?
952 {
953 fields.push(("findings".into(), value));
954 }
955 if let Some(value) = ::boxology_contract::ContractType::encode_field(
956 &self.rendered_text,
957 )
958 .map_err(|error| {
959 error
960 .under(
961 ::boxology_contract::PathSegment::Field("rendered_text".into()),
962 )
963 })?
964 {
965 fields.push(("rendered_text".into(), value));
966 }
967 ::boxology_contract::ContractValue::object(fields)
968 .map_err(|_| unreachable!("validated generated field identities are unique"))
969 }
970 fn decode_value(
971 value: &::boxology_contract::ContractValue,
972 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
973 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
974 return Err(
975 ::boxology_contract::DecodeError::new(
976 ::boxology_contract::DecodeErrorKind::KindMismatch,
977 ),
978 );
979 };
980 for (field, _) in fields.entries() {
981 match field {
982 "verdict" | "findings" | "rendered_text" => {}
983 _ => {
984 return Err(
985 ::boxology_contract::DecodeError::new(
986 ::boxology_contract::DecodeErrorKind::UnknownField(
987 field.into(),
988 ),
989 )
990 .under(::boxology_contract::PathSegment::Field(field.into())),
991 );
992 }
993 }
994 }
995 Ok(Self {
996 verdict: <CompatibilityClass as ::boxology_contract::ContractType>::decode_field(
997 fields.get("verdict"),
998 )
999 .map_err(|error| {
1000 error
1001 .under(::boxology_contract::PathSegment::Field("verdict".into()))
1002 })?,
1003 findings: <::std::vec::Vec<
1004 ClassifyFinding,
1005 > as ::boxology_contract::ContractType>::decode_field(fields.get("findings"))
1006 .map_err(|error| {
1007 error
1008 .under(
1009 ::boxology_contract::PathSegment::Field("findings".into()),
1010 )
1011 })?,
1012 rendered_text: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
1013 fields.get("rendered_text"),
1014 )
1015 .map_err(|error| {
1016 error
1017 .under(
1018 ::boxology_contract::PathSegment::Field(
1019 "rendered_text".into(),
1020 ),
1021 )
1022 })?,
1023 })
1024 }
1025}
1026#[rustfmt::skip]
1027#[derive(Debug, Clone, PartialEq, Default)]
1028pub enum ClassifyFailureStage {
1029 #[default]
1030 Base,
1031 Submitted,
1032 Pairing,
1033 Unknown { tag: ::std::string::String, payload: ::boxology_contract::OpaquePayload },
1034}
1035#[rustfmt::skip]
1036impl ::boxology_contract::ContractType for ClassifyFailureStage {
1037 fn encode_value(
1038 &self,
1039 ) -> ::core::result::Result<
1040 ::boxology_contract::ContractValue,
1041 ::boxology_contract::EncodeError,
1042 > {
1043 let (tag, payload) = match self {
1044 Self::Base => ("Base".into(), ::boxology_contract::SlotValue::Null),
1045 Self::Submitted => ("Submitted".into(), ::boxology_contract::SlotValue::Null),
1046 Self::Pairing => ("Pairing".into(), ::boxology_contract::SlotValue::Null),
1047 Self::Unknown { tag, payload } => {
1048 (
1049 tag.clone(),
1050 ::boxology_contract::SlotValue::Value(
1051 ::boxology_contract::ContractValue::opaque(payload.forward()),
1052 ),
1053 )
1054 }
1055 };
1056 Ok(::boxology_contract::ContractValue::enum_value(tag, payload))
1057 }
1058 fn decode_value(
1059 value: &::boxology_contract::ContractValue,
1060 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1061 let ::boxology_contract::ValueRef::Enum { tag, payload } = value.view() else {
1062 return Err(
1063 ::boxology_contract::DecodeError::new(
1064 ::boxology_contract::DecodeErrorKind::KindMismatch,
1065 ),
1066 );
1067 };
1068 match tag {
1069 "Base" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
1070 Ok(Self::Base)
1071 }
1072 "Base" => {
1073 Err(
1074 ::boxology_contract::DecodeError::new(
1075 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
1076 )
1077 .under(::boxology_contract::PathSegment::Variant(tag.into())),
1078 )
1079 }
1080 "Submitted" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
1081 Ok(Self::Submitted)
1082 }
1083 "Submitted" => {
1084 Err(
1085 ::boxology_contract::DecodeError::new(
1086 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
1087 )
1088 .under(::boxology_contract::PathSegment::Variant(tag.into())),
1089 )
1090 }
1091 "Pairing" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
1092 Ok(Self::Pairing)
1093 }
1094 "Pairing" => {
1095 Err(
1096 ::boxology_contract::DecodeError::new(
1097 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
1098 )
1099 .under(::boxology_contract::PathSegment::Variant(tag.into())),
1100 )
1101 }
1102 _ => {
1103 match payload {
1104 ::boxology_contract::SlotValue::Value(value) => {
1105 match value.view() {
1106 ::boxology_contract::ValueRef::Opaque(payload) => {
1107 Ok(Self::Unknown {
1108 tag: tag.into(),
1109 payload: payload.forward(),
1110 })
1111 }
1112 _ => {
1113 Err(
1114 ::boxology_contract::DecodeError::new(
1115 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1116 tag.into(),
1117 ),
1118 )
1119 .under(
1120 ::boxology_contract::PathSegment::Variant(tag.into()),
1121 ),
1122 )
1123 }
1124 }
1125 }
1126 _ => {
1127 Err(
1128 ::boxology_contract::DecodeError::new(
1129 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1130 tag.into(),
1131 ),
1132 )
1133 .under(
1134 ::boxology_contract::PathSegment::Variant(tag.into()),
1135 ),
1136 )
1137 }
1138 }
1139 }
1140 }
1141 }
1142}
1143#[rustfmt::skip]
1144#[derive(Debug, Clone, PartialEq, Default)]
1145pub struct ClassifyFailure {
1146 pub stage: ClassifyFailureStage,
1147 pub diagnostics: ::std::string::String,
1148}
1149#[rustfmt::skip]
1150impl ::boxology_contract::ContractType for ClassifyFailure {
1151 fn encode_value(
1152 &self,
1153 ) -> ::core::result::Result<
1154 ::boxology_contract::ContractValue,
1155 ::boxology_contract::EncodeError,
1156 > {
1157 let mut fields = ::std::vec::Vec::new();
1158 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.stage)
1159 .map_err(|error| {
1160 error.under(::boxology_contract::PathSegment::Field("stage".into()))
1161 })?
1162 {
1163 fields.push(("stage".into(), value));
1164 }
1165 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1166 &self.diagnostics,
1167 )
1168 .map_err(|error| {
1169 error
1170 .under(::boxology_contract::PathSegment::Field("diagnostics".into()))
1171 })?
1172 {
1173 fields.push(("diagnostics".into(), value));
1174 }
1175 ::boxology_contract::ContractValue::object(fields)
1176 .map_err(|_| unreachable!("validated generated field identities are unique"))
1177 }
1178 fn decode_value(
1179 value: &::boxology_contract::ContractValue,
1180 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1181 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
1182 return Err(
1183 ::boxology_contract::DecodeError::new(
1184 ::boxology_contract::DecodeErrorKind::KindMismatch,
1185 ),
1186 );
1187 };
1188 for (field, _) in fields.entries() {
1189 match field {
1190 "stage" | "diagnostics" => {}
1191 _ => {
1192 return Err(
1193 ::boxology_contract::DecodeError::new(
1194 ::boxology_contract::DecodeErrorKind::UnknownField(
1195 field.into(),
1196 ),
1197 )
1198 .under(::boxology_contract::PathSegment::Field(field.into())),
1199 );
1200 }
1201 }
1202 }
1203 Ok(Self {
1204 stage: <ClassifyFailureStage as ::boxology_contract::ContractType>::decode_field(
1205 fields.get("stage"),
1206 )
1207 .map_err(|error| {
1208 error.under(::boxology_contract::PathSegment::Field("stage".into()))
1209 })?,
1210 diagnostics: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
1211 fields.get("diagnostics"),
1212 )
1213 .map_err(|error| {
1214 error
1215 .under(
1216 ::boxology_contract::PathSegment::Field("diagnostics".into()),
1217 )
1218 })?,
1219 })
1220 }
1221}
1222#[rustfmt::skip]
1223#[derive(Debug, Clone, PartialEq, Default)]
1224pub struct ClassifyOutcome {
1225 pub report: ::core::option::Option<ClassifyReport>,
1226 pub failure: ::core::option::Option<ClassifyFailure>,
1227}
1228#[rustfmt::skip]
1229impl ::boxology_contract::ContractType for ClassifyOutcome {
1230 fn encode_value(
1231 &self,
1232 ) -> ::core::result::Result<
1233 ::boxology_contract::ContractValue,
1234 ::boxology_contract::EncodeError,
1235 > {
1236 let mut fields = ::std::vec::Vec::new();
1237 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1238 &self.report,
1239 )
1240 .map_err(|error| {
1241 error.under(::boxology_contract::PathSegment::Field("report".into()))
1242 })?
1243 {
1244 fields.push(("report".into(), value));
1245 }
1246 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1247 &self.failure,
1248 )
1249 .map_err(|error| {
1250 error.under(::boxology_contract::PathSegment::Field("failure".into()))
1251 })?
1252 {
1253 fields.push(("failure".into(), value));
1254 }
1255 ::boxology_contract::ContractValue::object(fields)
1256 .map_err(|_| unreachable!("validated generated field identities are unique"))
1257 }
1258 fn decode_value(
1259 value: &::boxology_contract::ContractValue,
1260 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1261 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
1262 return Err(
1263 ::boxology_contract::DecodeError::new(
1264 ::boxology_contract::DecodeErrorKind::KindMismatch,
1265 ),
1266 );
1267 };
1268 for (field, _) in fields.entries() {
1269 match field {
1270 "report" | "failure" => {}
1271 _ => {
1272 return Err(
1273 ::boxology_contract::DecodeError::new(
1274 ::boxology_contract::DecodeErrorKind::UnknownField(
1275 field.into(),
1276 ),
1277 )
1278 .under(::boxology_contract::PathSegment::Field(field.into())),
1279 );
1280 }
1281 }
1282 }
1283 Ok(Self {
1284 report: <::core::option::Option<
1285 ClassifyReport,
1286 > as ::boxology_contract::ContractType>::decode_field(fields.get("report"))
1287 .map_err(|error| {
1288 error.under(::boxology_contract::PathSegment::Field("report".into()))
1289 })?,
1290 failure: <::core::option::Option<
1291 ClassifyFailure,
1292 > as ::boxology_contract::ContractType>::decode_field(fields.get("failure"))
1293 .map_err(|error| {
1294 error
1295 .under(::boxology_contract::PathSegment::Field("failure".into()))
1296 })?,
1297 })
1298 }
1299}
1300#[rustfmt::skip]
1301#[derive(Debug, Clone, PartialEq, Default)]
1302pub enum ClassifierError {
1303 #[default]
1304 Internal,
1305 Unknown { tag: ::std::string::String, payload: ::boxology_contract::OpaquePayload },
1306}
1307#[rustfmt::skip]
1308impl ::boxology_contract::ContractType for ClassifierError {
1309 fn encode_value(
1310 &self,
1311 ) -> ::core::result::Result<
1312 ::boxology_contract::ContractValue,
1313 ::boxology_contract::EncodeError,
1314 > {
1315 let (tag, payload) = match self {
1316 Self::Internal => ("Internal".into(), ::boxology_contract::SlotValue::Null),
1317 Self::Unknown { tag, payload } => {
1318 (
1319 tag.clone(),
1320 ::boxology_contract::SlotValue::Value(
1321 ::boxology_contract::ContractValue::opaque(payload.forward()),
1322 ),
1323 )
1324 }
1325 };
1326 Ok(::boxology_contract::ContractValue::enum_value(tag, payload))
1327 }
1328 fn decode_value(
1329 value: &::boxology_contract::ContractValue,
1330 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1331 let ::boxology_contract::ValueRef::Enum { tag, payload } = value.view() else {
1332 return Err(
1333 ::boxology_contract::DecodeError::new(
1334 ::boxology_contract::DecodeErrorKind::KindMismatch,
1335 ),
1336 );
1337 };
1338 match tag {
1339 "Internal" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
1340 Ok(Self::Internal)
1341 }
1342 "Internal" => {
1343 Err(
1344 ::boxology_contract::DecodeError::new(
1345 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
1346 )
1347 .under(::boxology_contract::PathSegment::Variant(tag.into())),
1348 )
1349 }
1350 _ => {
1351 match payload {
1352 ::boxology_contract::SlotValue::Value(value) => {
1353 match value.view() {
1354 ::boxology_contract::ValueRef::Opaque(payload) => {
1355 Ok(Self::Unknown {
1356 tag: tag.into(),
1357 payload: payload.forward(),
1358 })
1359 }
1360 _ => {
1361 Err(
1362 ::boxology_contract::DecodeError::new(
1363 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1364 tag.into(),
1365 ),
1366 )
1367 .under(
1368 ::boxology_contract::PathSegment::Variant(tag.into()),
1369 ),
1370 )
1371 }
1372 }
1373 }
1374 _ => {
1375 Err(
1376 ::boxology_contract::DecodeError::new(
1377 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1378 tag.into(),
1379 ),
1380 )
1381 .under(
1382 ::boxology_contract::PathSegment::Variant(tag.into()),
1383 ),
1384 )
1385 }
1386 }
1387 }
1388 }
1389 }
1390}
1391#[rustfmt::skip]
1392impl ::boxology_contract::ContractError for ClassifierError {
1393 fn error_tag(&self) -> &str {
1394 match self {
1395 Self::Internal => "Internal",
1396 Self::Unknown { tag, .. } => tag,
1397 }
1398 }
1399}
1400#[rustfmt::skip]
1401#[cfg(feature = "test-support")]
1402pub mod test_support {
1403 use std::future::{Future, ready};
1404 use std::pin::Pin;
1405 use std::sync::Arc;
1406 use ::boxology_contract::{
1407 CallContext, CapabilityId, ContractType, DecodeRole, Detail, ErasedCallError,
1408 ErasedCallTarget, SlotValue, TypeDescriptor,
1409 };
1410 use super::{
1411 ClassifierError, CLASSIFIER_CLASSIFY, ClassifierHandle, conversion_detail,
1412 };
1413 type ClassifyFuture = Pin<
1414 Box<
1415 dyn Future<
1416 Output = Result<super::ClassifyOutcome, ClassifierError>,
1417 > + Send + 'static,
1418 >,
1419 >;
1420 type ClassifyResponder = dyn Fn(
1421 CallContext,
1422 super::ClassifyRequest,
1423 ) -> ClassifyFuture + Send + Sync + 'static;
1424 #[derive(Clone, Default)]
1425 pub struct ClassifierFake {
1426 classify: Option<Arc<ClassifyResponder>>,
1427 }
1428 impl ClassifierFake {
1429 pub fn new() -> Self {
1430 Self::default()
1431 }
1432 pub fn with_classify<F, Fut>(mut self, responder: F) -> Self
1433 where
1434 F: Fn(CallContext, super::ClassifyRequest) -> Fut + Send + Sync + 'static,
1435 Fut: Future<Output = Result<super::ClassifyOutcome, ClassifierError>> + Send
1436 + 'static,
1437 {
1438 self.classify = Some(
1439 Arc::new(move |context, request| {
1440 Box::pin(responder(context, request))
1441 }),
1442 );
1443 self
1444 }
1445 pub fn handle(&self) -> ClassifierHandle {
1446 ClassifierHandle::from_erased(Arc::new(self.clone()))
1447 }
1448 }
1449 impl ErasedCallTarget for ClassifierFake {
1450 fn call<'a>(
1451 &'a self,
1452 capability: &'a CapabilityId,
1453 context: CallContext,
1454 input: SlotValue,
1455 ) -> Pin<
1456 Box<dyn Future<Output = Result<SlotValue, ErasedCallError>> + Send + 'a>,
1457 > {
1458 if capability != &*CLASSIFIER_CLASSIFY {
1459 return Box::pin(ready(Err(unprogrammed())));
1460 }
1461 let Some(responder) = self.classify.clone() else {
1462 return Box::pin(ready(Err(unprogrammed())));
1463 };
1464 Box::pin(async move {
1465 let input = TypeDescriptor::structure([
1466 ::boxology_contract::FieldDescriptor::new(
1467 "base",
1468 TypeDescriptor::optional(
1469 TypeDescriptor::list(TypeDescriptor::u8())
1470 .expect("generated list descriptor is valid"),
1471 )
1472 .expect("generated optional descriptor is valid"),
1473 None,
1474 ),
1475 ::boxology_contract::FieldDescriptor::new(
1476 "submitted",
1477 TypeDescriptor::list(TypeDescriptor::u8())
1478 .expect("generated list descriptor is valid"),
1479 None,
1480 ),
1481 ])
1482 .expect("generated struct descriptor is valid")
1483 .conform(DecodeRole::ProviderInput, input)
1484 .map_err(|error| {
1485 ErasedCallError::ContractViolation(
1486 conversion_detail("input_decode", error),
1487 )
1488 })?;
1489 let request = <super::ClassifyRequest as ContractType>::decode(&input)
1490 .map_err(|error| {
1491 ErasedCallError::ContractViolation(
1492 conversion_detail("input_decode", error),
1493 )
1494 })?;
1495 match responder(context, request).await {
1496 Ok(output) => {
1497 output
1498 .encode()
1499 .map_err(|error| {
1500 ErasedCallError::InvalidResponse(
1501 conversion_detail("output_encode", error),
1502 )
1503 })
1504 }
1505 Err(error) => Err(ErasedCallError::from_domain(&error)),
1506 }
1507 })
1508 }
1509 }
1510 fn unprogrammed() -> ErasedCallError {
1511 ErasedCallError::Internal(Detail::new("unprogrammed_capability"))
1512 }
1513}
1514#[rustfmt::skip]
1515#[doc(hidden)]
1516pub const __BOXOLOGY_SEMANTIC_DIGEST: [u8; 32] = [
1517 109, 184, 18, 42, 31, 151, 168, 155, 0, 129, 107, 38, 231, 98, 215, 88, 240, 163, 42,
1518 234, 254, 59, 212, 168, 89, 246, 169, 255, 100, 153, 180, 91,
1519];
1520#[rustfmt::skip]
1521#[doc(hidden)]
1522#[macro_export]
1523macro_rules! __boxology_check_implementation {
1524 ($receiver:ty; $($method:ident $validity:ident;)*) => {
1525 $crate::__boxology_check_implementation!(@ find $receiver; $($method
1526 $validity;)*);
1527 };
1528 (@ find $receiver:ty; classify valid; $($rest:tt)*) => {
1529 const _ : () = { fn require_service < T : ::core::marker::Send +
1530 ::core::marker::Sync + 'static > () {} fn require_future < F :
1531 ::core::future::Future < Output = ::core::result::Result
1532 <$crate::ClassifyOutcome, $crate::ClassifierError >> + ::core::marker::Send > (_
1533 : F) {} fn check(receiver : &$receiver, context : ::boxology::CallContext, input
1534 : $crate::ClassifyRequest) { require_service::<$receiver > ();
1535 require_future(receiver.classify(context, input)); } }; impl
1536 $crate::ClassifierDispatch for $receiver { fn classify <'a > (&'a self, context :
1537 ::boxology::CallContext, input : $crate::ClassifyRequest,) -> ::std::pin::Pin <
1538 ::std::boxed::Box < dyn ::core::future::Future < Output = ::core::result::Result
1539 < $crate::ClassifyOutcome, $crate::ClassifierError, >, > + ::core::marker::Send +
1540 'a, >, > { ::std::boxed::Box::pin(self.classify(context, input)) } }
1541 };
1542 (@ find $receiver:ty; classify invalid; $($rest:tt)*) => {
1543 compile_error!("Boxology capability has an invalid structural signature");
1544 };
1545 (@ find $receiver:ty; $other:ident $validity:ident; $($rest:tt)*) => {
1546 $crate::__boxology_check_implementation!(@ find $receiver; $($rest)*);
1547 };
1548 (@ find $receiver:ty;) => {
1549 compile_error!("Boxology capability implementation is missing");
1550 };
1551}