Struct borrow_bag::BorrowBag

pub struct BorrowBag<V> { /* fields omitted */ }

BorrowBag allows the storage of any value using add(T), and returns a Handle which can be used to borrow the value back later. As the BorrowBag is add-only, Handle values remain valid for the lifetime of the BorrowBag.

After being added, the Handle can be passed to borrow(Handle), which will return a reference to the value.

use borrow_bag::new_borrow_bag;

#[derive(PartialEq, Debug)]
struct X;

#[derive(PartialEq, Debug)]
struct Y;

#[derive(PartialEq, Debug)]
struct Z;

let bag = new_borrow_bag();
let (bag, x_handle) = bag.add(X);
let (bag, y_handle) = bag.add(Y);
let (bag, z_handle) = bag.add(Z);

let x: &X = bag.borrow(x_handle);
assert_eq!(x, &X);
let y: &Y = bag.borrow(y_handle);
assert_eq!(y, &Y);
let z: &Z = bag.borrow(z_handle);
assert_eq!(z, &Z);

// Can borrow multiple times using the same handle
let x: &X = bag.borrow(x_handle);
assert_eq!(x, &X);

Methods

impl<V> BorrowBag<V>

fn add<T>(self, t: T) -> (BorrowBag<V::Output>, Handle<T, V::Navigator>) where
    V: Append<T>, 

Adds a value to the bag, and returns a tuple containing:

1. The new bag containing the added element; and
2. A Handle which can be used to retrieve the added element.

The trait bound is used to constrain and define the BorrowBag implementation, but is not intended to provide any restrictions on the value being added.

let bag = new_borrow_bag();
// Consumes the empty `bag`, and produces a new `bag` containing the value. The `handle`
// can be used to borrow the value back later.
let (bag, handle) = bag.add(15u8);

fn borrow<T, N>(&self, handle: Handle<T, N>) -> &T where
    V: Lookup<T, N>, 

Borrows a value previously added to the bag.

let i: &u8 = bag.borrow(handle);
assert_eq!(*i, 15);