ockam_identity 0.134.0

Ockam is a library for building devices that communicate securely, privately and trustfully with cloud services and other devices.
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

use ockam_core::compat::vec::Vec;
use ockam_core::Message;
use ockam_core::{deserialize, serialize, Decodable, Encodable, Encoded, Error};
use serde::{Deserialize, Serialize};

/// Request type for `EncryptorWorker` API Address
#[derive(Serialize, Deserialize, Message)]
pub struct EncryptionRequest(pub Vec<u8>);

impl Encodable for EncryptionRequest {
    fn encode(self) -> ockam_core::Result<Encoded> {
        Encodable::encode(self.0)
    }
}

impl Decodable for EncryptionRequest {
    fn decode(v: &[u8]) -> ockam_core::Result<Self> {
        Ok(EncryptionRequest(Decodable::decode(v)?))
    }
}

/// Response type for `EncryptorWorker` API Address
#[derive(Serialize, Deserialize, Message)]
pub enum EncryptionResponse {
    /// Success
    Ok(Vec<u8>),
    /// Error
    Err(Error),
}

impl Encodable for EncryptionResponse {
    fn encode(self) -> ockam_core::Result<Encoded> {
        serialize(self)
    }
}

impl Decodable for EncryptionResponse {
    fn decode(v: &[u8]) -> ockam_core::Result<Self> {
        deserialize(v)
    }
}
/// Request type for `Decryptor` API Address (the `Decryptor` is accessible through the `HandshakeWorker`)
#[derive(Serialize, Deserialize, Message)]
pub struct DecryptionRequest(pub Vec<u8>);

impl Encodable for DecryptionRequest {
    fn encode(self) -> ockam_core::Result<Encoded> {
        Encodable::encode(self.0)
    }
}

impl Decodable for DecryptionRequest {
    fn decode(v: &[u8]) -> ockam_core::Result<Self> {
        Ok(DecryptionRequest(Decodable::decode(v)?))
    }
}
/// Response type for `Decryptor` API Address (the `Decryptor` is accessible through the `HandshakeWorker`)
#[derive(Serialize, Deserialize, Message)]
pub enum DecryptionResponse {
    /// Success
    Ok(Vec<u8>),
    /// Error
    Err(Error),
}

impl Encodable for DecryptionResponse {
    fn encode(self) -> ockam_core::Result<Encoded> {
        serialize(self)
    }
}

impl Decodable for DecryptionResponse {
    fn decode(v: &[u8]) -> ockam_core::Result<Self> {
        deserialize(v)
    }
}