Struct BlockData 

struct BlockData {
    pub id: BlockId,
    pub reverse_postorder: Option<u32>,
    pub only_reach_error: bool,
    pub shortest_paths: HashMap<BlockId, usize>,
    pub flow: Vector<BlockId, Ratio<DynaInt<u64, BigUint>>>,
}

Fields

id: BlockId

reverse_postorder: Option<u32>

Order in a reverse postorder numbering. None if the block is unreachable.

only_reach_error: bool

Node from where we can only reach error nodes (panic, etc.)

shortest_paths: HashMap<BlockId, usize>

List of reachable nodes, with the length of shortest path to them. Includes the current node.

flow: Vector<BlockId, Ratio<DynaInt<u64, BigUint>>>

Let’s say we put a quantity of water equal to 1 on the block, and the water flows downards. Whenever there is a branching, the quantity of water gets equally divided between the branches. When the control flows join, we put the water back together. The set below computes the amount of water received by each descendant of the node.

TODO: there must be a known algorithm which computes this, right?… This is exactly this problems: https://stackoverflow.com/questions/78221666/algorithm-for-total-flow-through-weighted-directed-acyclic-graph TODO: the way I compute this is not efficient.

Implementations

impl BlockData

fn shortest_paths_including_self( &self, ) -> impl Iterator<Item = (BlockId, usize)>

fn shortest_paths_excluding_self( &self, ) -> impl Iterator<Item = (BlockId, usize)>

fn reachable_including_self(&self) -> impl Iterator<Item = BlockId>

fn reachable_excluding_self(&self) -> impl Iterator<Item = BlockId>

Trait Implementations

impl Debug for BlockData

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.