blueprint-core 0.2.0-alpha.2

Blueprint SDK Core functionality
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

use super::{FromJobCall, FromJobCallParts, rejection::*};
use crate::JobCall;
use crate::job::call::Parts;
use crate::metadata::{MetadataMap, MetadataValue};
use alloc::string::String;
use bytes::{Bytes, BytesMut};
use core::convert::Infallible;

impl<Ctx> FromJobCall<Ctx> for JobCall
where
    Ctx: Send + Sync,
{
    type Rejection = Infallible;

    async fn from_job_call(call: JobCall, _: &Ctx) -> Result<Self, Self::Rejection> {
        Ok(call)
    }
}

impl<Ctx> FromJobCallParts<Ctx> for MetadataMap<MetadataValue>
where
    Ctx: Send + Sync,
{
    type Rejection = Infallible;

    async fn from_job_call_parts(parts: &mut Parts, _: &Ctx) -> Result<Self, Self::Rejection> {
        let metadata = parts.metadata.clone();

        Ok(metadata)
    }
}

impl<Ctx> FromJobCall<Ctx> for BytesMut
where
    Ctx: Send + Sync,
{
    type Rejection = Infallible;

    async fn from_job_call(call: JobCall, _: &Ctx) -> Result<Self, Self::Rejection> {
        let (_, body) = call.into_parts();
        Ok(body.into())
    }
}

impl<Ctx> FromJobCall<Ctx> for Bytes
where
    Ctx: Send + Sync,
{
    type Rejection = Infallible;

    async fn from_job_call(call: JobCall, _: &Ctx) -> Result<Self, Self::Rejection> {
        let (_, body) = call.into_parts();

        Ok(body)
    }
}

impl<Ctx> FromJobCall<Ctx> for String
where
    Ctx: Send + Sync,
{
    type Rejection = InvalidUtf8;

    async fn from_job_call(call: JobCall, ctx: &Ctx) -> Result<Self, Self::Rejection> {
        let bytes = Bytes::from_job_call(call, ctx)
            .await
            .map_err(InvalidUtf8::from_err)?;

        let string = String::from_utf8(bytes.into()).map_err(InvalidUtf8::from_err)?;

        Ok(string)
    }
}

impl<Ctx> FromJobCallParts<Ctx> for Parts
where
    Ctx: Send + Sync,
{
    type Rejection = Infallible;

    async fn from_job_call_parts(
        parts: &mut Parts,
        _context: &Ctx,
    ) -> Result<Self, Self::Rejection> {
        Ok(parts.clone())
    }
}