Struct 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, S: Clone> Clone for SquareGraph<N, E, Ix, S>

where Ix: IndexType + Clone,

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

Returns a duplicate 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, S: Debug> Debug for SquareGraph<N, E, Ix, S>

where Ix: IndexType + Debug,

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 of 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,