Struct contrail_collections::linked_list::LinkedListNode

pub struct LinkedListNode<M, T> { /* fields omitted */ }

A node in a linked list.

Methods

impl<M, T> LinkedListNode<M, T> where
    M: StorageMode,
    T: Bytes, 

pub fn data(&self, trail: &Trail) -> T

Returns the data associated with the linked list node on the trail.

Examples

use contrail::TrailBuilder;
use contrail_collections::linked_list::BacktrackableLinkedListArena;

let mut builder = TrailBuilder::new();
let arena = BacktrackableLinkedListArena::new(&mut builder, vec![10, 11, 12]);
let trail = builder.finish();

let node = arena.node(2);
assert_eq!(node.data(&trail), 12);

pub fn set_data(&self, trail: &mut Trail, new_data: T)

Sets the data associated with the linked list node on the trail.

Examples

use contrail::TrailBuilder;
use contrail_collections::linked_list::BacktrackableLinkedListArena;

let mut builder = TrailBuilder::new();
let arena = BacktrackableLinkedListArena::new(&mut builder, vec![1, 0, 0]);
let mut trail = builder.finish();

let node = arena.node(0);
assert_eq!(node.data(&trail), 1);

node.set_data(&mut trail, 0);
assert_eq!(node.data(&trail), 0);

pub fn next(&self, trail: &Trail) -> LinkedListNode<M, T>

Returns the next linked list node that this node is linked to.

Initially, a node is linked to itself.

Examples

use contrail::TrailBuilder;
use contrail_collections::linked_list::BacktrackableLinkedListArena;

let mut builder = TrailBuilder::new();
let arena = BacktrackableLinkedListArena::new(&mut builder, vec![(); 3]);
let mut trail = builder.finish();

let node = arena.node(0);
assert_eq!(node.next(&trail), node);

let other = arena.node(1);
other.insert_after(&mut trail, node);
assert_eq!(node.next(&trail), other);
assert_eq!(other.next(&trail), node);

pub fn prev(&self, trail: &Trail) -> LinkedListNode<M, T>

Returns the previous linked list node that this node is linked to.

Initially, a node is linked to itself.

Examples

use contrail::TrailBuilder;
use contrail_collections::linked_list::BacktrackableLinkedListArena;

let mut builder = TrailBuilder::new();
let arena = BacktrackableLinkedListArena::new(&mut builder, vec![(); 3]);
let mut trail = builder.finish();

let node = arena.node(0);
assert_eq!(node.prev(&trail), node);

let other = arena.node(1);
other.insert_before(&mut trail, node);
assert_eq!(node.prev(&trail), other);
assert_eq!(other.prev(&trail), node);

pub fn unlink(&self, trail: &mut Trail)

Unlinks the node from its neighbors and links to itself.

Examples

use contrail::TrailBuilder;
use contrail_collections::linked_list::BacktrackableLinkedListArena;

let mut builder = TrailBuilder::new();
let arena = BacktrackableLinkedListArena::new(&mut builder, vec![(); 3]);
let mut trail = builder.finish();

let a = arena.node(0);
let b = arena.node(1);
let c = arena.node(2);

b.insert_after(&mut trail, a);
c.insert_after(&mut trail, b);

assert_eq!(a.next(&trail), b);
assert_eq!(b.next(&trail), c);
assert_eq!(c.next(&trail), a);

b.unlink(&mut trail);

assert_eq!(b.next(&trail), b);
assert_eq!(a.next(&trail), c);
assert_eq!(c.next(&trail), a);

pub fn insert_after(&self, trail: &mut Trail, node: LinkedListNode<M, T>)

Sets the next linked list node that this node is linked to.

Examples

use contrail::TrailBuilder;
use contrail_collections::linked_list::BacktrackableLinkedListArena;

let mut builder = TrailBuilder::new();
let arena = BacktrackableLinkedListArena::new(&mut builder, vec![(); 3]);
let mut trail = builder.finish();

let node = arena.node(0);
let other = arena.node(1);

other.insert_after(&mut trail, node);
assert_eq!(node.next(&trail), other);
assert_eq!(other.next(&trail), node);

pub fn insert_before(&self, trail: &mut Trail, node: LinkedListNode<M, T>)

Sets the previous linked list node that this node is linked to.

Examples

use contrail::TrailBuilder;
use contrail_collections::linked_list::BacktrackableLinkedListArena;

let mut builder = TrailBuilder::new();
let arena = BacktrackableLinkedListArena::new(&mut builder, vec![(); 3]);
let mut trail = builder.finish();

let node = arena.node(0);
let other = arena.node(1);

other.insert_before(&mut trail, node);
assert_eq!(node.prev(&trail), other);
assert_eq!(other.prev(&trail), node);

Trait Implementations

impl<M, T> PartialEq<LinkedListNode<M, T>> for LinkedListNode<M, T>

fn eq(&self, other: &Self) -> 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<M, T> Clone for LinkedListNode<M, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M, T> Eq for LinkedListNode<M, T>

impl<M, T> Copy for LinkedListNode<M, T>

impl<M, T> Debug for LinkedListNode<M, T> where
    M: StorageMode, 

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

Formats the value using the given formatter.