pub struct Sticky<T: 'static> { /* private fields */ }Expand description
A Sticky<T> keeps a value T stored in a thread.
This type works similar in nature to Fragile and exposes a
similar interface. The difference is that whereas Fragile has
its destructor called in the thread where the value was sent, a
Sticky that is moved to another thread will have the internal
destructor called when the originating thread tears down.
Because Sticky allows values to be kept alive for longer than the
Sticky itself, it requires all its contents to be 'static for
soundness. More importantly it also requires the use of StackTokens.
For information about how to use stack tokens and why they are needed,
refer to stack_token!.
As this uses TLS internally the general rules about the platform limitations of destructors for TLS apply.
Implementations§
Source§impl<T> Sticky<T>
impl<T> Sticky<T>
Sourcepub fn new(value: T) -> Self
pub fn new(value: T) -> Self
Creates a new Sticky wrapping a value.
The value that is moved into the Sticky can be non Send and
will be anchored to the thread that created the object. If the
sticky wrapper type ends up being send from thread to thread
only the original thread can interact with the value.
Examples found in repository?
5fn main() {
6 fragile::stack_token!(tok);
7
8 // creating and using a fragile object in the same thread works
9 let val = Sticky::new(true);
10 println!("debug print in same thread: {:?}", &val);
11 println!("try_get in same thread: {:?}", val.try_get(tok));
12
13 // once send to another thread it stops working
14 thread::spawn(move || {
15 fragile::stack_token!(tok);
16 println!("debug print in other thread: {:?}", &val);
17 println!("try_get in other thread: {:?}", val.try_get(tok));
18 })
19 .join()
20 .unwrap();
21}Sourcepub fn is_valid(&self) -> bool
pub fn is_valid(&self) -> bool
Returns true if the access is valid.
This will be false if the value was sent to another thread.
Sourcepub fn into_inner(self) -> T
pub fn into_inner(self) -> T
Consumes the Sticky, returning the wrapped value.
§Panics
Panics if called from a different thread than the one where the original value was created.
Sourcepub fn try_into_inner(self) -> Result<T, Self>
pub fn try_into_inner(self) -> Result<T, Self>
Consumes the Sticky, returning the wrapped value if successful.
The wrapped value is returned if this is called from the same thread
as the one where the original value was created, otherwise the
Sticky is returned as Err(self).
Sourcepub fn get<'stack>(&'stack self, _proof: &'stack StackToken) -> &'stack T
pub fn get<'stack>(&'stack self, _proof: &'stack StackToken) -> &'stack T
Sourcepub fn get_mut<'stack>(
&'stack mut self,
_proof: &'stack StackToken,
) -> &'stack mut T
pub fn get_mut<'stack>( &'stack mut self, _proof: &'stack StackToken, ) -> &'stack mut T
Mutably borrows the wrapped value.
§Panics
Panics if the calling thread is not the one that wrapped the value.
For a non-panicking variant, use try_get_mut.
Sourcepub fn try_get<'stack>(
&'stack self,
_proof: &'stack StackToken,
) -> Result<&'stack T, InvalidThreadAccess>
pub fn try_get<'stack>( &'stack self, _proof: &'stack StackToken, ) -> Result<&'stack T, InvalidThreadAccess>
Tries to immutably borrow the wrapped value.
Returns None if the calling thread is not the one that wrapped the value.
Examples found in repository?
5fn main() {
6 fragile::stack_token!(tok);
7
8 // creating and using a fragile object in the same thread works
9 let val = Sticky::new(true);
10 println!("debug print in same thread: {:?}", &val);
11 println!("try_get in same thread: {:?}", val.try_get(tok));
12
13 // once send to another thread it stops working
14 thread::spawn(move || {
15 fragile::stack_token!(tok);
16 println!("debug print in other thread: {:?}", &val);
17 println!("try_get in other thread: {:?}", val.try_get(tok));
18 })
19 .join()
20 .unwrap();
21}Sourcepub fn try_get_mut<'stack>(
&'stack mut self,
_proof: &'stack StackToken,
) -> Result<&'stack mut T, InvalidThreadAccess>
pub fn try_get_mut<'stack>( &'stack mut self, _proof: &'stack StackToken, ) -> Result<&'stack mut T, InvalidThreadAccess>
Tries to mutably borrow the wrapped value.
Returns None if the calling thread is not the one that wrapped the value.