Struct lattice_graph::square::SquareGraph

pub struct SquareGraph<N, E, Ix = usize, S = DefaultShape> where
    Ix: IndexType,  { /* private fields */ }

Undirected Square Grid Graph. It is has rectangle shape.

Node(i,j+1) - Edge(i,j+1,Horizontal) - Node(i+1,j+1)
  |                                     |
Edge(i,j,Vertical)                     Edge(i+1,j,Vertical)
  |                                     |
Node(i,j)   - Edge(i,j,Horizontal)   - Node(i+1,j)

Implementations

impl<N, E, Ix, S> SquareGraph<N, E, Ix, S> where
    Ix: IndexType,
    S: Shape, 

pub unsafe fn new_raw(
    nodes: FixedVec2D<N>,
    horizontal: FixedVec2D<E>,
    vertical: FixedVec2D<E>
) -> Self

Create a SquareGraph from raw data. It only check whether the size of nodes and edges are correct in debug_assertion.

pub fn new(h: usize, v: usize) -> Self where
    N: Default,
    E: Default, 

Create a SquareGraph with the nodes and edges initialized with default.

pub fn new_with<FN, FE>(h: usize, v: usize, fnode: FN, fedge: FE) -> Self where
    FN: FnMut(usize, usize) -> N,
    FE: FnMut(usize, usize, Axis) -> E, 

Creates a SquareGraph with initializing nodes and edges from position.

pub fn get_edge_id(
    &self,
    node: NodeIndex<Ix>,
    dir: SquareDirection
) -> Option<(EdgeIndex<Ix>, bool)>

Get the edge from node.

pub fn get_edge_reference<'a>(
    &'a self,
    n: NodeIndex<Ix>,
    dir: SquareDirection
) -> Option<EdgeReference<'a, E, Ix, S>>

Get the edge reference form node.

impl<N, E, Ix, S> SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

pub fn horizontal_node_count(&self) -> usize

Returns the Node count in the horizontal direction.

pub fn vertical_node_count(&self) -> usize

Returns the Node count in the vertical direction.

pub fn nodes(&self) -> &[&[N]]

Get a reference to the nodes. [horizontal][vertical]

pub fn horizontal(&self) -> &[&[E]]

Get a reference to the horizontal edges. [horizontal][vertical]

pub fn vertical(&self) -> &[&[E]]

Get a reference to the vertical edges. [horizontal][vertical]

pub fn nodes_mut(&mut self) -> &mut [&mut [N]]

Get a mutable reference to the nodes. [horizontal][vertical]

pub fn horizontal_mut(&mut self) -> &[&mut [E]]

Get a mutable reference to the horizontal edges. [horizontal][vertical]

pub fn vertical_mut(&mut self) -> &[&mut [E]]

Get a mutable reference to the vertical edges.

impl<E, Ix, S> SquareGraph<(), E, Ix, S> where
    Ix: IndexType,
    S: Shape, 

pub fn new_edge_graph<FE>(h: usize, v: usize, fedge: FE) -> Self where
    FE: FnMut(usize, usize, Axis) -> E, 

Create a SquareGraph with the edges initialized from position.

Trait Implementations

impl<N: Clone, E: Clone, Ix: Clone, S: Clone> Clone for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

fn clone(&self) -> SquareGraph<N, E, Ix, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N, E, Ix, S> Data for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

type NodeWeight = N

type EdgeWeight = E

impl<N, E, Ix, S> DataMap for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

fn node_weight(&self, id: Self::NodeId) -> Option<&Self::NodeWeight>

fn edge_weight(&self, id: Self::EdgeId) -> Option<&Self::EdgeWeight>

impl<N, E, Ix, S> DataMapMut for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

fn node_weight_mut(&mut self, id: Self::NodeId) -> Option<&mut Self::NodeWeight>

fn edge_weight_mut(&mut self, id: Self::EdgeId) -> Option<&mut Self::EdgeWeight>

impl<N: Debug, E: Debug, Ix: Debug, S: Debug> Debug for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

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

Formats the value using the given formatter.

impl<N, E, Ix, S> GraphBase for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

type NodeId = NodeIndex<Ix>

node identifier

type EdgeId = EdgeIndex<Ix>

edge identifier

impl<N, E, Ix, S> GraphProp for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

type EdgeType = Undirected

The kind edges in the graph.

fn is_directed(&self) -> bool

impl<'a, N, E, Ix, S> IntoEdgeReferences for &'a SquareGraph<N, E, Ix, S> where
    Ix: IndexType,
    E: Copy,
    S: Shape, 

type EdgeRef = EdgeReference<'a, E, Ix, S>

type EdgeReferences = EdgeReferences<'a, E, Ix, S>

fn edge_references(self) -> Self::EdgeReferences

impl<'a, N, E, Ix, S> IntoEdges for &'a SquareGraph<N, E, Ix, S> where
    Ix: IndexType,
    E: Copy,
    S: Shape, 

type Edges = Edges<'a, N, E, Ix, S>

fn edges(self, a: Self::NodeId) -> Self::Edges

impl<'a, N, E, Ix, S> IntoNeighbors for &'a SquareGraph<N, E, Ix, S> where
    Ix: IndexType,
    S: Shape, 

type Neighbors = Neighbors<Ix, S>

fn neighbors(self, a: Self::NodeId) -> Self::Neighbors

Return an iterator of the neighbors of node a.

impl<'a, N, E, Ix, S> IntoNeighborsDirected for &'a SquareGraph<N, E, Ix, S> where
    Ix: IndexType,
    S: Shape, 

type NeighborsDirected = Neighbors<Ix, S>

fn neighbors_directed(
    self,
    n: Self::NodeId,
    _d: Direction
) -> Self::NeighborsDirected

impl<'a, N, E, Ix, S> IntoNodeIdentifiers for &'a SquareGraph<N, E, Ix, S> where
    Ix: IndexType,
    Range<Ix>: Iterator<Item = Ix>, 

type NodeIdentifiers = NodeIndices<Ix>

fn node_identifiers(self) -> Self::NodeIdentifiers

impl<'a, N: Clone, E, Ix, S> IntoNodeReferences for &'a SquareGraph<N, E, Ix, S> where
    Ix: IndexType,
    Range<Ix>: Iterator<Item = Ix>, 

type NodeRef = (NodeIndex<Ix>, &'a N)

type NodeReferences = NodeReferences<'a, N, Ix>

fn node_references(self) -> Self::NodeReferences

impl<N, E, Ix, S> NodeCount for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

fn node_count(&self) -> usize

impl<N, E, Ix, S> NodeIndexable for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

fn node_bound(&self) -> usize

Return an upper bound of the node indices in the graph (suitable for the size of a bitmap).

fn to_index(&self, a: Self::NodeId) -> usize

Convert a to an integer index.

fn from_index(&self, i: usize) -> Self::NodeId

Convert i to a node index. i must be a valid value in the graph.

impl<N, E, Ix, S> Visitable for SquareGraph<N, E, Ix, S> where
    Ix: IndexType, 

type Map = VisMap

The associated map type

fn visit_map(&self) -> Self::Map

Create a new visitor map

fn reset_map(&self, map: &mut Self::Map)

Reset the visitor map (and resize to new size of graph if needed)

impl<N, E, Ix, S> NodeCompactIndexable for SquareGraph<N, E, Ix, S> where
    Ix: IndexType,