hank-types 0.1.43

Generated type definitions for Hank
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

// Customizations from lib.customizations.rs
pub use hank::*;

impl serde::ser::Serialize for access_check::AccessCheckChain {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        use serde::ser::SerializeStruct as _;
        let mut state = serializer.serialize_struct("AccessCheckChain", 1)?;
        state.serialize_field(
            access_check::AccessCheckOperator::try_from(self.operator)
                .expect("invalid access check operator")
                .as_str_name(),
            &self.checks,
        )?;

        state.end()
    }
}

impl<'de> serde::de::Deserialize<'de> for access_check::AccessCheckChain {
    fn deserialize<D: serde::de::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        let d: std::collections::BTreeMap<String, Vec<access_check::AccessCheck>> =
            std::collections::BTreeMap::deserialize(d)?;

        let (operator, checks) = d.first_key_value().expect("invalid access chain format");
        Ok(access_check::AccessCheckChain {
            operator: access_check::AccessCheckOperator::from_str_name(operator)
                .expect("invalid access check operator")
                .into(),
            checks: checks.to_vec(),
        })
    }
}

#[derive(Default)]
pub struct InstructionBuilder<T>
where
    T: Default + prost::Message,
{
    kind: plugin::InstructionKind,
    input: T,
    target: Option<String>,
}

impl<T> InstructionBuilder<T>
where
    T: Default + prost::Message,
{
    pub fn new(kind: plugin::InstructionKind) -> Self {
        Self {
            kind,
            ..Default::default()
        }
    }

    pub fn with_input(self, input: T) -> Self {
        Self { input, ..self }
    }

    pub fn with_target(self, target: String) -> Self {
        Self {
            target: Some(target),
            ..self
        }
    }

    pub fn build(self) -> plugin::Instruction {
        self.into()
    }
}

impl<T> From<InstructionBuilder<T>> for plugin::Instruction
where
    T: Default + prost::Message,
{
    fn from(value: InstructionBuilder<T>) -> Self {
        plugin::Instruction {
            kind: value.kind.into(),
            input: value.input.encode_to_vec(),
            target: value.target,
        }
    }
}