Struct QWERTY_US

pub struct QWERTY_US { /* private fields */ }

Methods from Deref<Target = Keyboard>

pub fn capacity(&self) -> (usize, usize)

Return the current node and edge capacity of the graph.

pub fn is_directed(&self) -> bool

Whether the graph has directed edges.

pub fn node_count(&self) -> usize

Return the number of nodes in the graph.

pub fn edge_count(&self) -> usize

Return the number of edges in the graph.

pub fn contains_node(&self, n: N) -> bool

Return true if the node is contained in the graph.

pub fn contains_edge(&self, a: N, b: N) -> bool

Return true if the edge connecting a with b is contained in the graph.

pub fn nodes(&self) -> Nodes<'_, N>

Return an iterator over the nodes of the graph.

Iterator element type is N.

pub fn neighbors(&self, a: N) -> Neighbors<'_, N, Ty>

Return an iterator of all nodes with an edge starting from a.

• Directed: Outgoing edges from a.
• Undirected: All edges from or to a.

Produces an empty iterator if the node doesn’t exist.
Iterator element type is N.

Examples found in repository

examples/simple.rs (line 18)

fn simple() {
    
    let ampersand = QWERTY_US.find_key('h');

    match ampersand {
        Some(_) => println!("Key exists"),
        None => println!("Key doesn't exist in layout"),
    }

    if let Some(key) = ampersand {
        for n in QWERTY_US.neighbors(key) {
            println!("{:?}", n);
        }
    }
    println!("{:?}", Dot::with_config(&*QWERTY_US, &[Config::EdgeNoLabel]));
}

pub fn neighbors_directed( &self, a: N, dir: Direction, ) -> NeighborsDirected<'_, N, Ty>

Return an iterator of all neighbors that have an edge between them and a, in the specified direction. If the graph’s edges are undirected, this is equivalent to .neighbors(a).

• Directed, Outgoing: All edges from a.
• Directed, Incoming: All edges to a.
• Undirected: All edges from or to a.

Produces an empty iterator if the node doesn’t exist.
Iterator element type is N.

pub fn edges(&self, from: N) -> Edges<'_, N, E, Ty>

Return an iterator of target nodes with an edge starting from a, paired with their respective edge weights.

• Directed: Outgoing edges from a.
• Undirected: All edges from or to a.

Produces an empty iterator if the node doesn’t exist.
Iterator element type is (N, &E).

pub fn edge_weight(&self, a: N, b: N) -> Option<&E>

Return a reference to the edge weight connecting a with b, or None if the edge does not exist in the graph.

pub fn all_edges(&self) -> AllEdges<'_, N, E, Ty>

Return an iterator over all edges of the graph with their weight in arbitrary order.

Iterator element type is (N, N, &E)

Trait Implementations

impl Deref for QWERTY_US

type Target = GraphMap<Key, Edge, Directed>

The resulting type after dereferencing.

fn deref(&self) -> &Keyboard

Dereferences the value.

impl LazyStatic for QWERTY_US