Struct pathfinder::Node

pub struct Node {
    pub hash: u64,
    pub geo: Coordinate,
    pub color: Rgba<u8>,
    pub radius: Option<u32>,
    // some fields omitted
}

A Location object that can be drawn on an image, along with set size and color.

Fields

hash: u64

geo: Coordinate

color: Rgba<u8>

radius: Option<u32>

Methods

impl Node

pub fn new(name: &str, geo: Coordinate) -> Self

Constructs a Node struct.

pub fn from_file(path: &str) -> Result<Vec<Self>, Error>

Retrive coordinate from a csv format.

pub fn center(&self) -> Coordinate

Gets the center position of the node accounting for size.

pub fn from_list(list: &[(i16, i16)]) -> Vec<Self>

Converts a list of tuples (x,y) to a Vector of Nodes. Names are assigned from "A" and upwards automatically.

use pathfinder::Node;
let list = [(0, 0), (10, 10), (15, 15)];
let nodes = Node::from_list(&list);
assert_eq!(nodes.len(), 3);

pub fn is_directly_connected(&self, other: &Node) -> bool

Looks through all connected Nodes and returns if they are connected.

pub fn linked_list(list: Vec<Node>) -> Vec<Self>

Links a list of nodes together in the order they are indexed. A list of A, B, C. Will result in them being linked as: A -> B -> C.

let nodes = Node::from_list(&[(0, 0), (20, 20)]);
let linked_list = Node::linked_list(nodes);

pub fn hl(&self, index: usize) -> Result<&HL>

Returns a specific link if it exists. Returns none if not.

let node = Node::new("", Coordinate::new(0, 0));
let hl = node.hl(0);
assert!(hl.is_err());

let a = Node::new("A", Coordinate::new(0, 0));
let mut b = Node::new("B", Coordinate::new(50, 50));
b.link(&a);
assert!(b.hl(0).is_ok());

pub fn hl_mut(&mut self, index: usize) -> Result<&mut HL>

See Node::hl for examples. Returns a mutable variant.

pub fn linked_list_predicate(     list: Vec<Node>,     f: &dyn Fn(Coordinate, Coordinate) -> bool ) -> Vec<Self>

Links a list of nodes together in the order they are indexed. A list of A, B, C. Will result in them being linked as: A -> B -> C.

use pathfinder::Node;
let nodes = Node::from_list(&[(0, 0), (20, 20)]);
let linked_list = Node::linked_list(nodes);

pub fn get_link_avail_index(&self) -> usize

Returns the next point which is available to link.

let a = Node::new("A", Coordinate::new(0, 0));
let mut b = Node::new("B", Coordinate::new(50, 50));
assert_eq!(b.get_link_avail_index(), 0);
b.link(&a);
assert_eq!(b.get_link_avail_index(), 1);

pub fn disconnect(&mut self)

Removes all connects leaving this node. This still leaves connections going towards this node.

let a = Node::new("A", Coordinate::new(0, 0));
let mut b = Node::new("B", Coordinate::new(50, 50));
b.link(&a);
assert!(b.hl(0).is_ok());
b.disconnect();
assert!(b.hl(0).is_err());

pub fn link<P: Hash + Location>(&mut self, other: &P)

Links Node self to another point that has Hash and Location implemented.

let b: Node = Node::new("B", Coordinate::new(100, 100));
let mut a: Node = Node::new("A", Coordinate::new(0, 0));
a.link(&b);
assert!(a.is_directly_connected(&b));

Trait Implementations

impl Hash for Node

fn hash(&self) -> u64

impl Find for Node

fn find<H: Hash>(&self, hash: H) -> Option<Coordinate>

Matches the Hashes and returns Some if it matches.

impl MinMax for Node

fn min_max(&self) -> (Coordinate, Coordinate)

impl Location for Node

fn position(&self) -> Coordinate

Retrieves the position Coordinates.

fn eq<L: Location>(&self, other: &L) -> bool

Returns if the positions are equal or not.

fn x(&self) -> i16

Retrieves the X coordinate.

fn y(&self) -> i16

Retrieves the Y coordinate.

fn sum(&self) -> i16

Returns the sum of the x and y value.

impl Draw for Node

fn draw<S: Shape>(&self, image: IW, offset: Coordinate, shape: &S) -> IW

fn size(&self) -> u32

fn links(&self) -> &[HL]

impl From<Coordinate> for Node

fn from(c: Coordinate) -> Self

Performs the conversion.

impl From<Group> for Node

fn from(group: Group) -> Self

Performs the conversion.

impl From<Node> for Group

fn from(node: Node) -> Self

Performs the conversion.

impl From<Node> for Coordinate

fn from(node: Node) -> Self

Performs the conversion.

impl Copy for Node

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> PartialEq<Node> for Node

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

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

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

This method tests for !=.

impl Debug for Node

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

Formats the value using the given formatter.