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
88
89
90

use std::fmt;

use serde_derive::{Deserialize, Serialize};

/// blocks: (blocking_id, blocking_io_number, blocked_id, blocked_flow_id) a blocks between functions
#[derive(PartialEq, Clone, Hash, Eq, Serialize, Deserialize)]
pub struct Block {
    /// The id of the flow where the blocking function reside
    pub blocking_flow_id: usize,
    /// The id of the blocking function (destination with input unable to be sent to)
    pub blocking_function_id: usize,
    /// The number of the io in the blocking function that is full and causing the block
    pub blocking_io_number: usize,
    /// The id of the function that would like to send to the blocking function but cannot because
    /// the input is full
    pub blocked_function_id: usize,
    /// The id of the flow where the blocked function resides
    pub blocked_flow_id: usize,
}

impl Block {
    /// Create a new `Block`
    pub fn new(
        blocking_flow_id: usize,
        blocking_function_id: usize,
        blocking_io_number: usize,
        blocked_function_id: usize,
        blocked_flow_id: usize,
    ) -> Self {
        Block {
            blocking_flow_id,
            blocking_function_id,
            blocking_io_number,
            blocked_function_id,
            blocked_flow_id,
        }
    }
}

impl fmt::Debug for Block {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "#{}({}) -> #{}({}):{}",
            self.blocked_function_id,
            self.blocked_flow_id,
            self.blocking_function_id,
            self.blocking_flow_id,
            self.blocking_io_number
        )
    }
}

impl fmt::Display for Block {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "#{}({}) -> #{}({}):{}",
            self.blocked_function_id,
            self.blocked_flow_id,
            self.blocking_function_id,
            self.blocking_flow_id,
            self.blocking_io_number
        )
    }
}

#[cfg(test)]
mod test {
    #[test]
    fn display_block_test() {
        let block = super::Block::new(1, 2, 0, 1, 0);
        println!("Block: {block}");
    }

    #[test]
    fn debug_block_test() {
        let block = super::Block::new(1, 2, 0, 1, 0);
        println!("Block: {block:?}");
    }

    #[test]
    fn block_new_test() {
        let block = super::Block::new(1, 2, 0, 1, 0);
        assert_eq!(block.blocking_flow_id, 1);
        assert_eq!(block.blocking_function_id, 2);
        assert_eq!(block.blocking_io_number, 0);
        assert_eq!(block.blocked_function_id, 1);
    }
}