cardano_serialization_lib/serialization/governance/
voting_procedure.rs

1use crate::*;
2
3impl cbor_event::se::Serialize for VotingProcedure {
4    fn serialize<'se, W: Write>(
5        &self,
6        serializer: &'se mut Serializer<W>,
7    ) -> cbor_event::Result<&'se mut Serializer<W>> {
8        serializer.write_array(cbor_event::Len::Len(2))?;
9        match self.vote {
10            VoteKind::No => {
11                serializer.write_unsigned_integer(0u64)?;
12            }
13            VoteKind::Yes => {
14                serializer.write_unsigned_integer(1u64)?;
15            }
16            VoteKind::Abstain => {
17                serializer.write_unsigned_integer(2u64)?;
18            }
19        };
20        self.anchor.serialize_nullable(serializer)?;
21        Ok(serializer)
22    }
23}
24
25impl Deserialize for VotingProcedure {
26    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
27        (|| -> Result<_, DeserializeError> {
28            let len = raw.array()?;
29            if let cbor_event::Len::Len(n) = len {
30                if n != 2 {
31                    return Err(DeserializeFailure::CBOR(cbor_event::Error::WrongLen(
32                        2,
33                        len,
34                        "[vote, anchor / null]",
35                    ))
36                    .into());
37                }
38            }
39
40            let vote = match raw.unsigned_integer()? {
41                0 => VoteKind::No,
42                1 => VoteKind::Yes,
43                2 => VoteKind::Abstain,
44                n => {
45                    return Err(
46                        DeserializeError::from(DeserializeFailure::FixedValuesMismatch {
47                            found: Key::Uint(n),
48                            expected: vec![Key::Uint(0), Key::Uint(1), Key::Uint(2)],
49                        })
50                        .annotate("vote"),
51                    )
52                }
53            };
54
55            let anchor = Anchor::deserialize_nullable(raw).map_err(|e| e.annotate("anchor"))?;
56
57            if let cbor_event::Len::Indefinite = len {
58                if raw.special()? != CBORSpecial::Break {
59                    return Err(DeserializeFailure::EndingBreakMissing.into());
60                }
61            }
62
63            Ok(Self { vote, anchor })
64        })()
65        .map_err(|e| e.annotate("VotingProcedure"))
66    }
67}