Struct borrow_bag::BorrowBag
[−]
[src]
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>
[src]
fn add<T>(self, t: T) -> (BorrowBag<V::Output>, Handle<T, V::Navigator>) where
V: Append<T>,
[src]
V: Append<T>,
Adds a value to the bag, and returns a tuple containing:
- The new bag containing the added element; and
- 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>,
[src]
V: Lookup<T, N>,
Borrows a value previously added to the bag.
let i: &u8 = bag.borrow(handle); assert_eq!(*i, 15);