Struct Scope

pub struct Scope { /* private fields */ }

Named scope created using bypass::scope.

Examples

// Declare a thread-local scope called `NAME`.
bypass::scope!(static NAME);

// Creates the first, top-level subscope.
NAME.scope(|| {
    // Perform operations on the scope.
    NAME.insert("x", 123);
});

Implementations

impl Scope

pub fn scope<F, R>(&self, work: F) -> R

where F: FnOnce() -> R,

A scope constrains the extent of inserts. It can insert into its parent using lift.

Examples

bypass::scope!(static NAME);

NAME.scope(|| {
    NAME.insert("x", 1);

    NAME.scope(|| {
        NAME.insert("x", 2);

        let value: i32 = NAME.get("x");
        assert_eq!(value, 2);
    });

    let value: i32 = NAME.get("x");
    assert_eq!(value, 1);
});

pub fn debug<F>(&self, log: F)

where F: Fn(Log<'_>) + 'static,

Sets the debugger for this scope.

log will be called for each get and remove.

Examples

bypass::scope!(static X);

X.debug(|log| { println!("{}", log); });

pub fn lift<A: Into<Cow<'static, str>>>(&self, from: A) -> Lift

Lifts a given key to the parent scope.

Core operations whose keys match a lift will perform their operations in the parent scope. If no parent scope exists then the current scope is used.

Panics

Panics if a lift of the same key already exists in the current scope.

Examples

bypass::scope!(static X);

X.scope(|| {
    X.scope(|| {
        X.lift("x");
        X.insert("x", 123);
    });

    let value: i32 = X.get("x");
    println!("{}", value);
});

pub fn insert<K: Into<Cow<'static, str>>, V: Any>(&self, key: K, value: V)

Inserts an entry into the scope.

Panics

Panics if the key already exists.

Example

bypass::scope!(static X);

X.scope(|| {
    X.insert("abc", 123);
});

pub fn insert_clone<K: Into<Cow<'static, str>>, V: Any + Clone>( &self, key: K, value: V, ) -> V

Inserts an entry into the scope and returns a clone.

Convenience function that prevents the need for manually cloning.

Panics

Panics if the key already exists.

Example

bypass::scope!(static X);

X.scope(|| {
    let number = X.insert_clone("abc", 123);
    assert_eq!(number, 123);
});

pub fn get<V: Any + Clone, K: Into<Cow<'static, str>>>(&self, key: K) -> V

Gets a clone of an entry from the scope.

Panics

Panics if the key does not exist, or if the value associated with this key is not does not match V.

Examples

bypass::scope!(static X);

X.scope(|| {
    X.insert("abc", 123);
    let value: i32 = X.get("abc");
    println!("{}", value);
});

pub fn modify<V: Any, K: Into<Cow<'static, str>>, F: FnOnce(&mut V) -> R, R>( &self, key: K, modifier: F, ) -> R

Modify an entry in the scope.

Panics

Panics if the key does not exist, or if the value associated with this key is not does not match V.

Examples

bypass::scope!(static X);

X.scope(|| {
    X.insert("abc", 123);
    X.modify("abc", |item: &mut i32| {
        *item += 1;
    });
    let value: i32 = X.get("abc");
    println!("{}", value);
    assert_eq!(value, 124);
});

pub fn remove<V: Any, K: Into<Cow<'static, str>>>(&self, key: K) -> V

Removes an entry from the scope.

Panics

Panics if the key does not exist, or if the value associated with this key is not does not match V.

Examples

bypass::scope!(static X);

X.scope(|| {
    X.insert("abc", 123);
    let value: i32 = X.remove("abc");
    println!("{}", value);
});