borrow-bag

A type-safe, heterogeneous collection with zero-cost add and borrow.

BorrowBag allows the storage of any value, 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.

For usage details, please see the documentation

Motivation

Initially, BorrowBag was conceived to solve the problem of assembling Gotham's Middleware and Pipeline structures, storing concrete types without losing their type information, and with an ability to borrow them back later after moving the collection.

The original implementation was generic enough that it was immediately extracted into this crate.

Use cases

Please create an issue or pull request so your use case can be added here.

Example

extern crate borrow_bag;

use borrow_bag::BorrowBag;

struct X(u8);
struct Y(u8);

fn main() {
    let bag = BorrowBag::new();
    let (bag, x_handle) = bag.add(X(1));
    let (bag, y_handle) = bag.add(Y(2));

    let x: &X = bag.borrow(x_handle);
    assert_eq!(x.0, 1);

    // Type annotations aren't necessary, the `Handle` carries the necessary
    // type information.
    let y = bag.borrow(y_handle);
    assert_eq!(y.0, 2);
}

License

BorrowBag is licensed under your option of:

Help

The Gotham core team collaborate on Gitter. Gotham specific chat and requests for help are both very welcome here.

Policies

Gotham is a young project that we want to create an energetic and respectful community around.

As a starting point we've adopted the following policies which we'd like your help in refining further.

These policies are in effect for any environment or tool that supports the Gotham project.

News

You can keep up with Gotham at:

borrow-bag 0.4.0