bee_ledger/types/
output_diff.rs

1// Copyright 2020-2021 IOTA Stiftung
2// SPDX-License-Identifier: Apache-2.0
3
4use crate::types::{error::Error, TreasuryDiff};
5
6use bee_common::packable::{Packable, Read, Write};
7use bee_message::output::OutputId;
8
9/// A type to record output and treasury changes that happened within a milestone.
10#[derive(Clone, Debug, Eq, PartialEq)]
11pub struct OutputDiff {
12    created_outputs: Vec<OutputId>,
13    consumed_outputs: Vec<OutputId>,
14    treasury_diff: Option<TreasuryDiff>,
15}
16
17impl OutputDiff {
18    /// Creates a new `OutputDiff`.
19    pub fn new(
20        created_outputs: Vec<OutputId>,
21        consumed_outputs: Vec<OutputId>,
22        treasury_diff: Option<TreasuryDiff>,
23    ) -> Self {
24        Self {
25            created_outputs,
26            consumed_outputs,
27            treasury_diff,
28        }
29    }
30
31    /// Returns the created outputs of the `OutputDiff`.
32    pub fn created_outputs(&self) -> &[OutputId] {
33        &self.created_outputs
34    }
35
36    /// Returns the consumed outputs of the `OutputDiff`.
37    pub fn consumed_outputs(&self) -> &[OutputId] {
38        &self.consumed_outputs
39    }
40
41    /// Returns the treasury diff of the `OutputDiff`.
42    pub fn treasury_diff(&self) -> Option<&TreasuryDiff> {
43        self.treasury_diff.as_ref()
44    }
45}
46
47impl Packable for OutputDiff {
48    type Error = Error;
49
50    fn packed_len(&self) -> usize {
51        self.created_outputs.packed_len() + self.consumed_outputs.packed_len() + self.treasury_diff.packed_len()
52    }
53
54    fn pack<W: Write>(&self, writer: &mut W) -> Result<(), Self::Error> {
55        (self.created_outputs.len() as u32).pack(writer)?;
56        for output in self.created_outputs.iter() {
57            output.pack(writer)?;
58        }
59
60        (self.consumed_outputs.len() as u32).pack(writer)?;
61        for output in self.consumed_outputs.iter() {
62            output.pack(writer)?;
63        }
64
65        self.treasury_diff.pack(writer).map_err(|_| Error::PackableOption)?;
66
67        Ok(())
68    }
69
70    fn unpack_inner<R: Read + ?Sized, const CHECK: bool>(reader: &mut R) -> Result<Self, Self::Error> {
71        let created_outputs_len = u32::unpack_inner::<R, CHECK>(reader)? as usize;
72        let mut created_outputs = Vec::with_capacity(created_outputs_len);
73        for _ in 0..created_outputs_len {
74            created_outputs.push(OutputId::unpack_inner::<R, CHECK>(reader)?);
75        }
76
77        let consumed_outputs_len = u32::unpack_inner::<R, CHECK>(reader)? as usize;
78        let mut consumed_outputs = Vec::with_capacity(consumed_outputs_len);
79        for _ in 0..consumed_outputs_len {
80            consumed_outputs.push(OutputId::unpack_inner::<R, CHECK>(reader)?);
81        }
82
83        let treasury_diff =
84            Option::<TreasuryDiff>::unpack_inner::<R, CHECK>(reader).map_err(|_| Error::PackableOption)?;
85
86        Ok(Self {
87            created_outputs,
88            consumed_outputs,
89            treasury_diff,
90        })
91    }
92}