Struct plexus::graph::VertexView

pub struct VertexView<B> where
    B: Reborrow,
    B::Target: AsStorage<Vertex<<B as Parametric>::Data>> + Parametric,  { /* private fields */ }

View of a vertex entity.

See the graph module documentation for more information about views.

Implementations

impl<B, M> VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<<B as Parametric>::Data>> + Parametric, 

pub fn to_ref(&self) -> VertexView<&M>

impl<'a, B, M, G> VertexView<B> where
    B: ReborrowInto<'a, Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

pub fn into_ref(self) -> VertexView<&'a M>

Examples

use decorum::R64;
use nalgebra::Point3;
use plexus::graph::MeshGraph;
use plexus::prelude::*;
use plexus::primitive::cube::Cube;
use plexus::primitive::generate::Position;

type E3 = Point3<R64>;

let mut graph: MeshGraph<E3> = Cube::new().polygons::<Position<E3>>().collect();
let key = graph.arcs().nth(0).unwrap().key();
let vertex = graph.arc_mut(key).unwrap().split_at_midpoint().into_ref();

// This would not be possible without conversion into an immutable view.
let _ = vertex.into_outgoing_arc().into_face().unwrap();
let _ = vertex
    .into_outgoing_arc()
    .into_opposite_arc()
    .into_face()
    .unwrap();

impl<B, M, G> VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

pub fn get<'a>(&'a self) -> &'a G::Vertex where
    G: 'a, 

pub fn position<'a>(&'a self) -> &'a VertexPosition<G> where
    G: 'a,
    G::Vertex: AsPosition, 

impl<B, M, G> VertexView<B> where
    B: ReborrowMut<Target = M>,
    M: AsStorageMut<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

pub fn get_mut<'a>(&'a mut self) -> &'a mut G::Vertex where
    G: 'a, 

impl<B, M, G> VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Arc<G>> + AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

This impl block contains no items.

Reachable API.

impl<B, M, G> VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Arc<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: GraphData, 

pub fn into_outgoing_arc(self) -> ArcView<B>

Converts the vertex into its outgoing (leading) arc.

pub fn outgoing_arc(&self) -> ArcView<&M>

Gets the outgoing (leading) arc of the vertex.

pub fn shortest_path(
    &self,
    key: VertexKey
) -> Result<Path<'static, &M>, GraphError>

pub fn into_shortest_path(
    self,
    key: VertexKey
) -> Result<Path<'static, B>, GraphError>

pub fn shortest_path_with<Q, F>(
    &self,
    key: VertexKey,
    f: F
) -> Result<Path<'static, &M>, GraphError> where
    Q: Copy + Metric,
    F: Fn(VertexView<&M>, VertexView<&M>) -> Q, 

pub fn into_shortest_path_with<Q, F>(
    self,
    key: VertexKey,
    f: F
) -> Result<Path<'static, B>, GraphError> where
    Q: Copy + Metric,
    F: Fn(VertexView<&M>, VertexView<&M>) -> Q, 

pub fn valence(&self) -> usize

Gets the valence of the vertex.

A vertex’s valence is the number of adjacent vertices to which it is connected by arcs. The valence of a vertex is the same as its degree, which is the number of edges to which the vertex is connected.

pub fn centroid(&self) -> VertexPosition<G> where
    G: VertexCentroid,
    G::Vertex: AsPosition, 

impl<B, M, G> VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Arc<G>> + AsStorage<Face<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: GraphData, 

pub fn normal(&self) -> Result<Vector<VertexPosition<G>>, GraphError> where
    G: VertexNormal,
    G::Vertex: AsPosition, 

impl<'a, B, M, G> VertexView<B> where
    B: ReborrowInto<'a, Target = M>,
    M: 'a + AsStorage<Arc<G>> + AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

This impl block contains no items.

Reachable API.

impl<B, G> VertexView<B> where
    B: Reborrow,
    B::Target: AsStorage<Arc<G>> + AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

This impl block contains no items.

Reachable API.

impl<'a, B, M, G> VertexView<B> where
    B: ReborrowInto<'a, Target = M>,
    M: 'a + AsStorage<Arc<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: GraphData, 

pub fn into_adjacent_vertices(
    self
) -> impl Clone + Iterator<Item = VertexView<&'a M>>

pub fn into_incoming_arcs(self) -> impl Clone + Iterator<Item = ArcView<&'a M>>

pub fn into_outgoing_arcs(self) -> impl Clone + Iterator<Item = ArcView<&'a M>>

impl<B, G> VertexView<B> where
    B: Reborrow,
    B::Target: AsStorage<Arc<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: GraphData, 

pub fn adjacent_vertices(
    &self
) -> impl Clone + Iterator<Item = VertexView<&B::Target>>

pub fn incoming_arcs(&self) -> impl Clone + Iterator<Item = ArcView<&B::Target>>

Gets an iterator of views over the incoming arcs of the vertex.

The ordering of arcs is deterministic and is based on the leading arc of the vertex.

pub fn outgoing_arcs(&self) -> impl Clone + Iterator<Item = ArcView<&B::Target>>

Gets an iterator of views over the outgoing arcs of the vertex.

The ordering of arcs is deterministic and is based on the leading arc of the vertex.

pub fn traverse_by_breadth(
    &self
) -> impl Clone + Iterator<Item = VertexView<&B::Target>>

Gets an iterator that traverses adjacent vertices by breadth.

The traversal moves from the vertex to its adjacent vertices and so on. If there are disjoint subgraphs in the graph, then a traversal will not reach every vertex in the graph.

pub fn traverse_by_depth(
    &self
) -> impl Clone + Iterator<Item = VertexView<&B::Target>>

Gets an iterator that traverses adjacent vertices by depth.

The traversal moves from the vertex to its adjacent vertices and so on. If there are disjoint subgraphs in the graph, then a traversal will not reach every vertex in the graph.

impl<'a, B, M, G> VertexView<B> where
    B: ReborrowInto<'a, Target = M>,
    M: 'a + AsStorage<Arc<G>> + AsStorage<Face<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: GraphData, 

pub fn into_adjacent_faces(
    self
) -> impl Clone + Iterator<Item = FaceView<&'a M>>

impl<B, G> VertexView<B> where
    B: Reborrow,
    B::Target: AsStorage<Arc<G>> + AsStorage<Face<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: GraphData, 

pub fn adjacent_faces(
    &self
) -> impl Clone + Iterator<Item = FaceView<&B::Target>>

Gets an iterator of views over the adjacent faces of the vertex.

The ordering of faces is deterministic and is based on the leading arc of the vertex.

impl<'a, M, G> VertexView<&'a mut M> where
    M: AsStorage<Arc<G>> + AsStorageMut<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: 'a + GraphData, 

pub fn into_adjacent_vertex_orphans(
    self
) -> impl Iterator<Item = VertexOrphan<'a, G>>

impl<B> VertexView<B> where
    B: ReborrowMut,
    B::Target: AsStorage<Arc<<B as Parametric>::Data>> + AsStorageMut<Vertex<<B as Parametric>::Data>> + Consistent + Parametric, 

pub fn adjacent_vertex_orphans(
    &mut self
) -> impl Iterator<Item = VertexOrphan<'_, <B as Parametric>::Data>>

impl<'a, M, G> VertexView<&'a mut M> where
    M: AsStorageMut<Arc<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: 'a + GraphData, 

pub fn into_incoming_arc_orphans(self) -> impl Iterator<Item = ArcOrphan<'a, G>>

impl<B> VertexView<B> where
    B: ReborrowMut,
    B::Target: AsStorageMut<Arc<<B as Parametric>::Data>> + AsStorage<Vertex<<B as Parametric>::Data>> + Consistent + Parametric, 

pub fn incoming_arc_orphans(
    &mut self
) -> impl Iterator<Item = ArcOrphan<'_, <B as Parametric>::Data>>

Gets an iterator of orphan views over the incoming arcs of the vertex.

The ordering of arcs is deterministic and is based on the leading arc of the vertex.

impl<'a, M, G> VertexView<&'a mut M> where
    M: AsStorage<Arc<G>> + AsStorageMut<Face<G>> + AsStorage<Vertex<G>> + Consistent + Parametric<Data = G>,
    G: 'a + GraphData, 

pub fn into_adjacent_face_orphans(
    self
) -> impl Iterator<Item = FaceOrphan<'a, G>>

impl<B> VertexView<B> where
    B: ReborrowMut,
    B::Target: AsStorage<Arc<<B as Parametric>::Data>> + AsStorageMut<Face<<B as Parametric>::Data>> + AsStorage<Vertex<<B as Parametric>::Data>> + Consistent + Parametric, 

pub fn adjacent_face_orphans(
    &mut self
) -> impl Iterator<Item = FaceOrphan<'_, <B as Parametric>::Data>>

Gets an iterator of orphan views over the adjacent faces of the vertex.

The ordering of faces is deterministic and is based on the leading arc of the vertex.

impl<'a, M, G> VertexView<&'a mut M> where
    M: AsStorage<Arc<G>> + AsStorage<Edge<G>> + AsStorage<Face<G>> + AsStorage<Vertex<G>> + Default + Mutable<Data = G>,
    G: GraphData, 

pub fn remove(self)

Removes the vertex.

Any and all dependent entities are also removed, such as arcs and edges connected to the vertex, faces connected to such arcs, vertices with no remaining leading arc, etc.

Vertex removal is the most destructive removal, because vertices are a dependency of all other entities.

Examples

Removing a corner from a cube by removing its vertex:

use decorum::R64;
use nalgebra::Point3;
use plexus::graph::MeshGraph;
use plexus::prelude::*;
use plexus::primitive::cube::Cube;
use plexus::primitive::generate::Position;

type E3 = Point3<R64>;

let mut graph: MeshGraph<E3> = Cube::new().polygons::<Position<E3>>().collect();
let key = graph.vertices().nth(0).unwrap().key();
graph.vertex_mut(key).unwrap().remove();

Trait Implementations

impl<B> Borrow<VertexKey> for VertexView<B> where
    B: Reborrow,
    B::Target: AsStorage<Vertex<<B as Parametric>::Data>> + Parametric, 

fn borrow(&self) -> &VertexKey

Immutably borrows from an owned value.

impl<B, M, G> Clone for VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData,
    View<B, Vertex<G>>: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B, M, G> ClosedView for VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

type Key = VertexKey

type Entity = Vertex<G>

fn key(&self) -> Self::Key

impl<B, M, G> Deref for VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

type Target = Vertex<G>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<B, M, G> DerefMut for VertexView<B> where
    B: ReborrowMut<Target = M>,
    M: AsStorageMut<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, M, G> From<VertexView<&'a mut M>> for VertexOrphan<'a, G> where
    M: AsStorageMut<Vertex<G>> + Parametric<Data = G>,
    G: 'a + GraphData, 

fn from(vertex: VertexView<&'a mut M>) -> Self

Converts to this type from the input type.

impl<B, M, G> Hash for VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

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

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<B, M, G> PartialEq<VertexView<B>> for VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData, 

fn eq(&self, other: &Self) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<B, M, G> Copy for VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData,
    View<B, Vertex<G>>: Copy, 

impl<B, M, G> Eq for VertexView<B> where
    B: Reborrow<Target = M>,
    M: AsStorage<Vertex<G>> + Parametric<Data = G>,
    G: GraphData,