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