Struct Setting 

pub struct Setting<T> { /* private fields */ }

Implementations

impl<T> Setting<T>

where T: Default + Clone,

pub fn cb(&mut self, f: impl FnMut(&T, &T) + 'static)

Set a callback, guaranteed to be called every time inner value changes

Examples found in repository

examples/readme.rs (line 12)

fn main() {
    let mut settings = Settings::default(); // equivalent of `Settings { port: 0, domain: "".to_string() }`
    settings
        .port
        .cb(|old, new| println!("port: {:?} -> {:?}", old, new));
    settings.port.set(1);
    settings.port.set(10);
    let _ = settings.domain.get();
    let _ = settings.domain.as_ref();
}

examples/sharing_state.rs (lines 14-18)

fn main() {
    let mut settings = Settings::default();
    let s = Rc::new("abc".to_string());
    {
        let mut ss = s.to_string();
        settings.str.cb(move |o, n| {
            println!("{:?} -> {:?}", o, n);
            ss.push_str("...");
            println!("{:?} from closure", ss);
        });
    }
    println!("{}", s);
    settings.str.set("new".to_string());
    println!("{:?}", settings);
}

examples/simple.rs (line 14)

fn main() {
    let mut settings = Settings::default();
    // Register callbacks for value changes
    settings
        .domain
        .cb(|o, n| println!("domain: {:?} -> {:?}", o, n));
    settings
        .port
        .cb(|o, n| println!("port: {:?} -> {:?}", o, n));
    // Set new values, callbacks are now invoked when setting is changed
    println!("{:?}", settings);
    settings.domain.set("127.0.0.1".to_string());
    settings.port.set(1337);
    println!("{:?}", settings);
}

examples/more_complex.rs (line 14)

fn main() {
    let mut settings = Settings::default();

    settings.cell.cb(|o, n| println!("{:?} -> {:?}", o, n));
    settings.vec.cb(|o, n| println!("{:?} -> {:?}", o, n));

    // Field name should be empty by default
    println!("name should be empty by default: {:?}", settings.str.get());

    // Change Settings struct, user callbacks should be called if they were are assigned
    settings.str.set("new_name".to_string());
    settings.cell.set(10.into());
    settings.cell.set(2222.into());

    // Changing Vec elements is a bit more tedious
    let mut vec = settings.vec.get();
    vec.extend([1, 2, 3, 4]);
    settings.vec.set(vec);

    println!("{:?}", settings);
}

examples/real_world_mpsc.rs (lines 16-19)

fn main() {
    // Settings
    let (sender, receiver) = channel();
    let mut settings = Settings::default();
    settings.port.cb(move |old, new| {
        let old_and_new = (old.clone(), new.clone());
        sender.send(old_and_new).unwrap();
    });

    // Port subscriber
    thread::spawn(move || loop {
        let port = receiver.recv();
        if port.is_ok() {
            println!(
                "port changed: {:?} -> {:?}",
                port.unwrap().0,
                port.unwrap().1
            );
        }
    });

    // Port publisher
    let mut changing_port = 0u16;
    loop {
        changing_port = changing_port + 1;
        settings.port.set(changing_port);
        thread::sleep(Duration::from_millis(500));
    }
}

pub fn set(&mut self, new_val: T)

Set value

Examples found in repository

examples/readme.rs (line 13)

fn main() {
    let mut settings = Settings::default(); // equivalent of `Settings { port: 0, domain: "".to_string() }`
    settings
        .port
        .cb(|old, new| println!("port: {:?} -> {:?}", old, new));
    settings.port.set(1);
    settings.port.set(10);
    let _ = settings.domain.get();
    let _ = settings.domain.as_ref();
}

examples/sharing_state.rs (line 21)

fn main() {
    let mut settings = Settings::default();
    let s = Rc::new("abc".to_string());
    {
        let mut ss = s.to_string();
        settings.str.cb(move |o, n| {
            println!("{:?} -> {:?}", o, n);
            ss.push_str("...");
            println!("{:?} from closure", ss);
        });
    }
    println!("{}", s);
    settings.str.set("new".to_string());
    println!("{:?}", settings);
}

examples/simple.rs (line 20)

fn main() {
    let mut settings = Settings::default();
    // Register callbacks for value changes
    settings
        .domain
        .cb(|o, n| println!("domain: {:?} -> {:?}", o, n));
    settings
        .port
        .cb(|o, n| println!("port: {:?} -> {:?}", o, n));
    // Set new values, callbacks are now invoked when setting is changed
    println!("{:?}", settings);
    settings.domain.set("127.0.0.1".to_string());
    settings.port.set(1337);
    println!("{:?}", settings);
}

examples/more_complex.rs (line 21)

fn main() {
    let mut settings = Settings::default();

    settings.cell.cb(|o, n| println!("{:?} -> {:?}", o, n));
    settings.vec.cb(|o, n| println!("{:?} -> {:?}", o, n));

    // Field name should be empty by default
    println!("name should be empty by default: {:?}", settings.str.get());

    // Change Settings struct, user callbacks should be called if they were are assigned
    settings.str.set("new_name".to_string());
    settings.cell.set(10.into());
    settings.cell.set(2222.into());

    // Changing Vec elements is a bit more tedious
    let mut vec = settings.vec.get();
    vec.extend([1, 2, 3, 4]);
    settings.vec.set(vec);

    println!("{:?}", settings);
}

examples/real_world_mpsc.rs (line 37)

fn main() {
    // Settings
    let (sender, receiver) = channel();
    let mut settings = Settings::default();
    settings.port.cb(move |old, new| {
        let old_and_new = (old.clone(), new.clone());
        sender.send(old_and_new).unwrap();
    });

    // Port subscriber
    thread::spawn(move || loop {
        let port = receiver.recv();
        if port.is_ok() {
            println!(
                "port changed: {:?} -> {:?}",
                port.unwrap().0,
                port.unwrap().1
            );
        }
    });

    // Port publisher
    let mut changing_port = 0u16;
    loop {
        changing_port = changing_port + 1;
        settings.port.set(changing_port);
        thread::sleep(Duration::from_millis(500));
    }
}

pub fn get(&self) -> T

Get value by cloning

Examples found in repository

examples/readme.rs (line 15)

fn main() {
    let mut settings = Settings::default(); // equivalent of `Settings { port: 0, domain: "".to_string() }`
    settings
        .port
        .cb(|old, new| println!("port: {:?} -> {:?}", old, new));
    settings.port.set(1);
    settings.port.set(10);
    let _ = settings.domain.get();
    let _ = settings.domain.as_ref();
}

examples/more_complex.rs (line 18)

fn main() {
    let mut settings = Settings::default();

    settings.cell.cb(|o, n| println!("{:?} -> {:?}", o, n));
    settings.vec.cb(|o, n| println!("{:?} -> {:?}", o, n));

    // Field name should be empty by default
    println!("name should be empty by default: {:?}", settings.str.get());

    // Change Settings struct, user callbacks should be called if they were are assigned
    settings.str.set("new_name".to_string());
    settings.cell.set(10.into());
    settings.cell.set(2222.into());

    // Changing Vec elements is a bit more tedious
    let mut vec = settings.vec.get();
    vec.extend([1, 2, 3, 4]);
    settings.vec.set(vec);

    println!("{:?}", settings);
}

Trait Implementations

impl<T> AsRef<T> for Setting<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Debug for Setting<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Setting<T>

where T: Default + Debug + Clone,

fn default() -> Self

Returns the “default value” for a type.