iter.rs

#[derive(Debug)]
struct Node {
    id: u32,
}

#[derive(Debug)]
struct Edge {
    left: u32,
    right: u32,
}

#[derive(Debug)]
struct Graph {
    nodes: Vec<Node>,
    edges: Vec<Edge>,
}

impl Graph {
    fn iter_edges(&self) -> EdgeIterator {
        EdgeIterator::new(self)
    }
    fn iter_nodes(&self) -> NodeIterator {
        NodeIterator::new(self)
    }
}

struct NodeIterator<'a> {
    graph: &'a Graph,
}
impl<'a> NodeIterator<'a> {
    fn new(graph: &'a Graph) -> Self {
        NodeIterator { graph }
    }
}
impl<'a> Iterator for NodeIterator<'a> {
    type Item = &'a Node;
    fn next(&mut self) -> Option<Self::Item> {
        Some(self.graph.nodes.get(0).unwrap())
    }
}

struct EdgeIterator<'a> {
    graph: &'a Graph,
}
impl<'a> EdgeIterator<'a> {
    fn new(graph: &'a Graph) -> Self {
        EdgeIterator { graph }
    }
}
impl<'a> Iterator for EdgeIterator<'a> {
    type Item = &'a Edge;
    fn next(&mut self) -> Option<Self::Item> {
        Some(self.graph.edges.get(0).unwrap())
    }
}

fn main() {
    let graph = Graph {
        nodes: vec![Node { id: 1 }, Node { id: 2 }, Node { id: 3 }],
        edges: vec![
            Edge { left: 1, right: 2 },
            Edge { left: 2, right: 3 },
            Edge { left: 3, right: 1 },
        ],
    };

    let edge0 = graph.iter_edges().next();
    dbg!(edge0);
    let node0 = graph.iter_nodes().next();
    dbg!(node0);
}