Struct petgraph::graph::Frozen

[+] Show declaration

pub struct Frozen<'a, G: 'a>(_);

[−] Expand description

Frozen is a graph wrapper.

The Frozen only allows shared access (read-only) to the underlying graph G, but it allows mutable access to its node and edge weights.

This is used to ensure immutability of the graph's structure while permitting weights to be both read and written.

See indexing implementations and the traits Data and DataMap for read-write access to the graph's weights.

Implementations

impl<'a, G> Frozen<'a, G>[−]

pub fn new(gr: &'a mut G) -> Self[−]

Create a new Frozen from a mutable reference to a graph.

impl<'a, N, E, Ty, Ix> Frozen<'a, Graph<N, E, Ty, Ix>> where
    Ty: EdgeType,
    Ix: IndexType, [−]

pub fn index_twice_mut<T, U>(
    &mut self,
    i: T,
    j: U
) -> (&mut <Graph<N, E, Ty, Ix> as Index<T>>::Output, &mut <Graph<N, E, Ty, Ix> as Index<U>>::Output) where
    Graph<N, E, Ty, Ix>: IndexMut<T> + IndexMut<U>,
    T: GraphIndex,
    U: GraphIndex, [−]

Index the Graph by two indices, any combination of node or edge indices is fine.

Panics if the indices are equal or if they are out of bounds.

Trait Implementations

impl<'a, G> Data for Frozen<'a, G> where
    G: Data, 

type NodeWeight = G::NodeWeight

type EdgeWeight = G::EdgeWeight

impl<'a, G> DataMap for Frozen<'a, G> where
    G: DataMap, [+]

[+] Show hidden undocumented items

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

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

impl<'a, G> DataMapMut for Frozen<'a, G> where
    G: DataMapMut, [+]

[+] Show hidden undocumented items

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<'a, G> Deref for Frozen<'a, G>[+]

Deref allows transparent access to all shared reference (read-only) functionality in the underlying graph.

[+] Show hidden undocumented items

type Target = G

The resulting type after dereferencing.

fn deref(&self) -> &G[−]

Dereferences the value.

impl<'a, G> GetAdjacencyMatrix for Frozen<'a, G> where
    G: GetAdjacencyMatrix, [+]

[+] Show hidden undocumented items

type AdjMatrix = G::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<'a, G> GraphBase for Frozen<'a, G> where
    G: GraphBase, 

type NodeId = G::NodeId

node identifier

type EdgeId = G::EdgeId

edge identifier

impl<'a, G> GraphProp for Frozen<'a, G> where
    G: GraphProp, [+]

[+] Show hidden undocumented items

type EdgeType = G::EdgeType

The kind edges in the graph.

fn is_directed(&self) -> bool

impl<'a, G, I> Index<I> for Frozen<'a, G> where
    G: Index<I>, [+]

[+] Show hidden undocumented items

type Output = G::Output

The returned type after indexing.

fn index(&self, i: I) -> &G::Output[−]

Performs the indexing (container[index]) operation.

impl<'a, G, I> IndexMut<I> for Frozen<'a, G> where
    G: IndexMut<I>, [+]

[+] Show hidden undocumented items

fn index_mut(&mut self, i: I) -> &mut G::Output[−]

Performs the mutable indexing (container[index]) operation.

impl<'a, 'b, G> IntoEdgeReferences for &'b Frozen<'a, G> where
    G: IntoEdgeReferences, [+]

[+] Show hidden undocumented items

type EdgeRef = G::EdgeRef

type EdgeReferences = G::EdgeReferences

fn edge_references(self) -> Self::EdgeReferences

impl<'a, 'b, G> IntoEdges for &'b Frozen<'a, G> where
    G: IntoEdges, [+]

[+] Show hidden undocumented items

type Edges = G::Edges

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

impl<'a, 'b, G> IntoEdgesDirected for &'b Frozen<'a, G> where
    G: IntoEdgesDirected, [+]

[+] Show hidden undocumented items

type EdgesDirected = G::EdgesDirected

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

impl<'a, 'b, G> IntoNeighbors for &'b Frozen<'a, G> where
    G: IntoNeighbors, [+]

[+] Show hidden undocumented items

type Neighbors = G::Neighbors

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

Return an iterator of the neighbors of node a.

impl<'a, 'b, G> IntoNeighborsDirected for &'b Frozen<'a, G> where
    G: IntoNeighborsDirected, [+]

[+] Show hidden undocumented items

type NeighborsDirected = G::NeighborsDirected

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

impl<'a, 'b, G> IntoNodeIdentifiers for &'b Frozen<'a, G> where
    G: IntoNodeIdentifiers, [+]

[+] Show hidden undocumented items

type NodeIdentifiers = G::NodeIdentifiers

fn node_identifiers(self) -> Self::NodeIdentifiers

impl<'a, 'b, G> IntoNodeReferences for &'b Frozen<'a, G> where
    G: IntoNodeReferences, [+]

[+] Show hidden undocumented items

type NodeRef = G::NodeRef

type NodeReferences = G::NodeReferences

fn node_references(self) -> Self::NodeReferences

impl<'a, G> NodeCompactIndexable for Frozen<'a, G> where
    G: NodeCompactIndexable, 

impl<'a, G> NodeCount for Frozen<'a, G> where
    G: NodeCount, [+]

[+] Show hidden undocumented items

fn node_count(&self) -> usize

impl<'a, G> NodeIndexable for Frozen<'a, G> where
    G: NodeIndexable, [+]

[+] Show hidden undocumented items

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

impl<'a, G> Visitable for Frozen<'a, G> where
    G: Visitable, [+]

[+] Show hidden undocumented items

type Map = G::Map

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)