robopoker 0.1.1

Implementations of Meta's Pluribus No-Limit Texas Hold-Em solution.
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

use crate::mccfr::edge::Edge;
use crate::mccfr::node::Node;
use petgraph::graph::DiGraph;
use petgraph::graph::NodeIndex;
use std::ptr::NonNull;

#[derive(Debug, Clone)]
pub struct Info {
    roots: Vec<NodeIndex>,
    graph: NonNull<DiGraph<Node, Edge>>,
}

impl From<(NodeIndex, NonNull<DiGraph<Node, Edge>>)> for Info {
    fn from((index, graph): (NodeIndex, NonNull<DiGraph<Node, Edge>>)) -> Self {
        let roots = vec![index];
        Self { roots, graph }
    }
}

impl Info {
    pub fn add(&mut self, index: NodeIndex) {
        self.roots.push(index)
    }
    pub fn heads(&self) -> Vec<&Node> {
        self.roots
            .iter()
            .copied()
            .map(|i| self.graph_ref().node_weight(i).expect("valid node index"))
            .collect()
    }
    pub fn node(&self) -> &Node {
        self.roots
            .iter()
            .next()
            .copied()
            .map(|i| self.graph_ref().node_weight(i).expect("valid node index"))
            .expect("non-empty infoset")
    }
    /// SAFETY:
    /// we have logical assurance that lifetimes work out effectively:
    /// 'info: 'node: 'tree
    /// Info is created from a Node
    /// Node is created from a Tree
    /// Tree owns its Graph
    fn graph_ref(&self) -> &DiGraph<Node, Edge> {
        unsafe { self.graph.as_ref() }
    }
}