Struct factory::SwappableFactory

pub struct SwappableFactory<T>(_);

#[cfg(feature = "swappable")] A Factory that allows for swapping inner factories dynamically.

This use a lock-free data structure for swapping.

Examples

use factory::{CloneFactory, Factory, SwappableFactory};

let f0 = SwappableFactory::new(CloneFactory::new(32));
let f1 = f0.clone();
assert_eq!(f0.create(), 32);
assert_eq!(f1.create(), 32);

f0.swap(CloneFactory::new(50));
assert_eq!(f0.create(), 50);
assert_eq!(f1.create(), 50);

Methods

impl<T: Factory> SwappableFactory<T>

pub fn new(inner: T) -> Self

Makes a new SwappableFactory with the initial inner factory.

pub fn get(&self) -> Arc<T>

Returns the currently used factory.

pub fn swap(&self, new: T) -> Arc<T>

Updates inner factory by new, and returns old one.

This operation affects all SwappableFactory instances cloned from the original one.

Trait Implementations

impl<T: Factory> Factory for SwappableFactory<T>

type Item = T::Item

The type of instances created by this factory.

fn create(&self) -> Self::Item

Creates an instance.

impl<T> Clone for SwappableFactory<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Default> Default for SwappableFactory<T>

fn default() -> SwappableFactory<T>

Returns the "default value" for a type.

impl<T: Debug> Debug for SwappableFactory<T>

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

Formats the value using the given formatter.