Struct lattice_graph::lattice_abstract::LatticeGraph

pub struct LatticeGraph<N, E, S: Shape> { /* private fields */ }

Abstract Lattice Graph. It holds the node and edge weight data. The actural behaviour is dependent on Shape.

Implementations

impl<N, E, S: Shape> LatticeGraph<N, E, S>

pub unsafe fn new_uninit(s: S) -> Self

Creates a graph with uninitalized node and edge weight data. It is extremely unsafe so should use with MaybeUninit and use assume_init.

pub fn new(s: S) -> Self where
    N: Default,
    E: Default, 

Creates a graph with node and edge weight data set to default.

pub fn new_with<FN, FE>(s: S, n: FN, e: FE) -> Self where
    FN: FnMut(S::Coordinate) -> N,
    FE: FnMut(S::Coordinate, S::Axis) -> E, 

Creates a graph with node and edge weight data from the coordinate.

pub fn shape(&self) -> &S

Get a reference to the lattice graph’s s.

impl<N, E, S: Shape + Default> LatticeGraph<N, E, S>

pub fn new_s() -> Self where
    N: Default,
    E: Default, 

Creates a graph with node and edge weight data set to default with Shape from default.

pub unsafe fn new_uninit_s() -> Self

Creates a graph with uninitalized node and edge weight data with Shape from default. It is extremely unsafe so should use with MaybeUninit and use assume_init.

pub fn new_with_s<FN, FE>(n: FN, e: FE) -> Self where
    FN: FnMut(S::Coordinate) -> N,
    FE: FnMut(S::Coordinate, S::Axis) -> E, 

Creates a graph with node and edge weight data from the coordinate with Shape from default.

impl<N, E, S: Shape> LatticeGraph<MaybeUninit<N>, MaybeUninit<E>, S>

pub unsafe fn assume_init(self) -> LatticeGraph<N, E, S>

Assume the underlying nodes and edges to be initialized.

let mut hex = unsafe { HexGraphConst::<MaybeUninit<f32>, MaybeUninit<()>, OddR, 5, 5>::new_uninit_s() };
for i in 0..5{
    for j in 0..5{
        let offset = Offset::new(i, j);
        let coord = hex.shape().from_offset(offset);
        if let Some(ref mut n) = hex.node_weight_mut(coord){
            **n = MaybeUninit::new((i + j) as f32);
        }
    }
}
let hex_init = unsafe{ hex.assume_init() };

Trait Implementations

impl<N: Clone, E: Clone, S: Clone + Shape> Clone for LatticeGraph<N, E, S>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N, E, S: Shape> Data for LatticeGraph<N, E, S>

type NodeWeight = N

type EdgeWeight = E

impl<N, E, S: Shape> DataMap for LatticeGraph<N, E, S>

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

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

impl<N, E, S: Shape> DataMapMut for LatticeGraph<N, E, S>

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, S: Debug + Shape> Debug for LatticeGraph<N, E, S>

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

Formats the value using the given formatter.

impl<N, E, S> Default for LatticeGraph<N, E, S> where
    N: Default,
    E: Default,
    S: Shape + Default + Clone, 

fn default() -> Self

Returns the “default value” for a type.

impl<N, E, S: Shape> Drop for LatticeGraph<N, E, S>

fn drop(&mut self)

Executes the destructor for this type.

impl<N, E, S, C> GetAdjacencyMatrix for LatticeGraph<N, E, S> where
    C: Copy + PartialEq,
    S: Shape<Coordinate = C>, 

type AdjMatrix = ()

The associated adjacency matrix type

fn adjacency_matrix(&self) -> Self::AdjMatrix

Create the adjacency matrix

fn is_adjacent(
    &self,
    _matrix: &Self::AdjMatrix,
    a: Self::NodeId,
    b: Self::NodeId
) -> bool

Return true if there is an edge from a to b, false otherwise.

impl<N, E, S: Shape> GraphBase for LatticeGraph<N, E, S>

type NodeId = S::Coordinate

node identifier

type EdgeId = (S::Coordinate, S::Axis)

edge identifier

impl<N, E, S: Shape> GraphProp for LatticeGraph<N, E, S>

type EdgeType = EdgeTypeWrap<S::Axis>

The kind edges in the graph.

fn is_directed(&self) -> bool

impl<N: Hash, E: Hash, S: Hash + Shape> Hash for LatticeGraph<N, E, S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a, N, E, S, C, D, A> IntoEdgeReferences for &'a LatticeGraph<N, E, S> where
    C: Copy,
    S: Shape<Coordinate = C, Axis = A>,
    A: Axis<Direction = D>,
    D: AxisDirection + Copy, 

type EdgeRef = EdgeReference<'a, C, E, D, A>

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

fn edge_references(self) -> Self::EdgeReferences

impl<'a, N, E, S, C, D, A> IntoEdges for &'a LatticeGraph<N, E, S> where
    C: Copy,
    S: Shape<Coordinate = C, Axis = A>,
    A: Axis<Direction = D>,
    D: AxisDirection + Copy, 

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

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

impl<'a, N, E, S, C, D, A> IntoEdgesDirected for &'a LatticeGraph<N, E, S> where
    C: Copy,
    S: Shape<Coordinate = C, Axis = A>,
    A: Axis<Direction = D>,
    D: AxisDirection + Copy, 

type EdgesDirected = EdgesDirected<'a, N, E, S>

fn edges_directed(self, a: Self::NodeId, dir: Direction) -> Self::EdgesDirected

impl<'a, N, E, S, D> IntoNeighbors for &'a LatticeGraph<N, E, S> where
    S: Shape,
    S::Axis: Axis<Direction = D>,
    D: AxisDirection + Clone, 

type Neighbors = Neighbors<'a, N, E, S>

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

Return an iterator of the neighbors of node a.

impl<'a, N, E, S, D> IntoNeighborsDirected for &'a LatticeGraph<N, E, S> where
    S: Shape,
    S::Axis: Axis<Direction = D>,
    D: AxisDirection + Clone, 

type NeighborsDirected = Neighbors<'a, N, E, S>

fn neighbors_directed(self, a: Self::NodeId, _d: Direction) -> Self::Neighbors

impl<'a, N, E, S: Shape> IntoNodeIdentifiers for &'a LatticeGraph<N, E, S>

type NodeIdentifiers = NodeIndices<S>

fn node_identifiers(self) -> Self::NodeIdentifiers

impl<'a, N, E, S: Shape> IntoNodeReferences for &'a LatticeGraph<N, E, S>

type NodeRef = (<S as Shape>::Coordinate, &'a N)

type NodeReferences = NodeReferences<'a, N, E, S>

fn node_references(self) -> Self::NodeReferences

impl<N, E, S: Shape> NodeCount for LatticeGraph<N, E, S>

fn node_count(&self) -> usize

impl<N, E, S: Shape> NodeIndexable for LatticeGraph<N, E, S>

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: PartialEq, E: PartialEq, S: PartialEq + Shape> PartialEq<LatticeGraph<N, E, S>> for LatticeGraph<N, E, S>

fn eq(&self, other: &LatticeGraph<N, E, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &LatticeGraph<N, E, S>) -> bool

This method tests for !=.

impl<N, E, S: Shape + Clone> Visitable for LatticeGraph<N, E, S>

type Map = VisMap<S>

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: Eq, E: Eq, S: Eq + Shape> Eq for LatticeGraph<N, E, S>

impl<N, E, S: Shape> NodeCompactIndexable for LatticeGraph<N, E, S>

impl<N, E, S: Shape> StructuralEq for LatticeGraph<N, E, S>

impl<N, E, S: Shape> StructuralPartialEq for LatticeGraph<N, E, S>