Struct truck_topology::Vertex

pub struct Vertex<P> { /* fields omitted */ }

Vertex, the minimum topological unit.

The constructor Vertex::new() creates a different vertex each time. These vertices are uniquely identified by their id.

let v0 = Vertex::new(()); // one vertex
let v1 = Vertex::new(()); // another vertex
assert_ne!(v0, v1); // two vertices are different

Implementations

impl<P> Vertex<P>

pub fn new(point: P) -> Vertex<P>

constructor

Examples

use truck_topology::*;
let v0 = Vertex::new(()); // a vertex whose geometry is the empty tuple.
let v1 = Vertex::new(()); // another vertex
let v2 = v0.clone(); // a cloned vertex
assert_ne!(v0, v1);
assert_eq!(v0, v2);

pub fn news(points: &[P]) -> Vec<Vertex<P>> where
    P: Copy, 

Creates len distinct vertices and return them by vector.

Examples

use truck_topology::Vertex;
let v = Vertex::news(&[(), (), ()]);
assert_eq!(v.len(), 3);
assert_ne!(v[0], v[2]);

pub fn try_lock_point(&self) -> TryLockResult<MutexGuard<'_, P>>

Tries to lock the mutex of the contained point. The thread will not blocked.

Examples

use truck_topology::*;
let v0 = Vertex::new(0);
let v1 = v0.clone();

// Two vertices have the same content.
assert_eq!(*v0.try_lock_point().unwrap(), 0);
assert_eq!(*v1.try_lock_point().unwrap(), 0);

{
    let mut point = v0.try_lock_point().unwrap();
    *point = 1;
}
// The contents of two vertices are synchronized.
assert_eq!(*v0.try_lock_point().unwrap(), 1);
assert_eq!(*v1.try_lock_point().unwrap(), 1);

// The thread is not blocked even if the point is already locked.
let lock = v0.try_lock_point();
assert!(v1.try_lock_point().is_err());    

pub fn lock_point(&self) -> LockResult<MutexGuard<'_, P>>

Acquires the mutex of the contained point, blocking the current thread until it is able to do so.

Examples

use truck_topology::*;
let v0 = Vertex::new(0);
let v1 = v0.clone();

// Two vertices have the same content.
assert_eq!(*v0.lock_point().unwrap(), 0);
assert_eq!(*v1.lock_point().unwrap(), 0);

{
    let mut point = v0.lock_point().unwrap();
    *point = 1;
}
// The contents of two vertices are synchronized.
assert_eq!(*v0.lock_point().unwrap(), 1);
assert_eq!(*v1.lock_point().unwrap(), 1);

// Check the behavior of `lock`.
std::thread::spawn(move || {
    *v0.lock_point().unwrap() = 2;
}).join().expect("thread::spawn failed");
assert_eq!(*v1.lock_point().unwrap(), 2);    

pub fn id(&self) -> VertexID<P>

Returns the id of the vertex.

Trait Implementations

impl<P> Clone for Vertex<P>

fn clone(&self) -> Vertex<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Vertex<P>

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

Formats the value using the given formatter.

impl<P> Eq for Vertex<P>

impl<P> Hash for Vertex<P>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<P> PartialEq<Vertex<P>> for Vertex<P>

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.