Struct Handle 

pub struct Handle { /* private fields */ }

Handle represents a node in the forest. A handle will contribute to the reference count of the node.

Implementations

impl Handle

pub fn new() -> Self

Create a new handle.

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

Check if two nodes are connected. A node is connected to itself. This operation is O(log n).

Examples

use dynforest::Handle;
let a = Handle::new();
let b = Handle::new();
assert!(!a.is_connected(&b));
let _conn = a.connect(&b);
assert!(a.is_connected(&b));

pub unsafe fn connect_unchecked(&self, other: &Self) -> Connection

Connect two nodes without checking if they are already connected.

Safety

The caller must ensure that the two handles are not connected.

pub fn connect(&self, other: &Self) -> Option<Connection>

Connect two nodes. Return None if they are already connected. A node is always connected to itself. This operation is O(log n).

Examples

use dynforest::Handle;
let a = Handle::new();
let b = Handle::new();
let conn1 = a.connect(&b);
assert!(conn1.is_some());
assert!(a.is_connected(&b));
assert!(b.is_connected(&a));
let c = Handle::new();
let conn2 = b.connect(&c);
assert!(conn2.is_some());
assert!(a.is_connected(&c));
// a and c are already connected
let conn3 = a.connect(&c);
assert!(conn3.is_none());

Trait Implementations

impl Clone for Handle

fn clone(&self) -> Handle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Handle

fn default() -> Self

Returns the “default value” for a type.

impl Hash for Handle

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Handle

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Handle