Struct fbp::fbp_threadsafe_wrapper::ThreadSafeType

pub struct ThreadSafeType<T: Clone> { /* fields omitted */ }

Generic Thread safe type

Implementations

impl<T: Clone> ThreadSafeType<T>

pub fn new(wrapped_type: T) -> Self

Creates a new ThreadSafeType for a specific type

Example

Basic usage:

use fbp::fbp_threadsafe_wrapper::*;

let safe_bool = ThreadSafeType::new(false);

pub fn create(an_arc: Arc<Mutex<T>>) -> Self

Create a new ThreadSafeType from an Arc<Mutex>

Example

Basic usage:

use fbp::fbp_threadsafe_wrapper::*;
use std::sync::{Arc, Mutex, MutexGuard};

let an_arc = Arc::new(Mutex::new(false));

let safe_bool = ThreadSafeType::create(an_arc);

pub fn get_type(&self) -> MutexGuard<'_, T>

Return a MutexGuard of the underlying data

NOTE: MutexGuard will dereference to the underlying type

Example

Basic usage:

use fbp::fbp_threadsafe_wrapper::*;
use std::ops::Deref;

let safe_bool = ThreadSafeType::new(false);
let the_value = safe_bool.get_type();
if *the_value.deref() == true {
	println!("The value is true");
} else {
	println!("The value is false");
}

pub fn get_arc(&self) -> Arc<Mutex<T>>

Return the underlying arc used by the ThreadSafeType

Example

Basic usage:

use fbp::fbp_threadsafe_wrapper::*;
use std::sync::{Arc, Mutex, MutexGuard};

let safe_bool = ThreadSafeType::new(false);
let the_arc = safe_bool.get_arc();

pub fn set_arc(&mut self, new_arc: Arc<Mutex<T>>)

Change the underlying arc used by the threadSafeType

Example

Basic usage:

use fbp::fbp_threadsafe_wrapper::*;
use std::sync::{Arc, Mutex, MutexGuard};

let mut safe_bool = ThreadSafeType::new(false);
let new_arc = Arc::new(Mutex::new(true));
safe_bool.set_arc(new_arc);

Trait Implementations

impl<T: Clone> Clone for ThreadSafeType<T>

fn clone(&self) -> ThreadSafeType<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Clone> Debug for ThreadSafeType<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default + Clone> Default for ThreadSafeType<T>

fn default() -> ThreadSafeType<T>

Returns the “default value” for a type.

impl<'de, T: Clone> Deserialize<'de> for ThreadSafeType<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Clone> Serialize for ThreadSafeType<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.