Struct setting_tracker::Setting

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

Implementations§

source§

impl<T> Setting<T>
where T: Default + Clone,

source

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

Examples found in repository?
examples/readme.rs (line 12)
8
9
10
11
12
13
14
15
16
17

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();
}
More examples
Hide additional examples
examples/sharing_state.rs (lines 14-18)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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));
    }
}
source

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

Examples found in repository?
examples/readme.rs (line 13)
8
9
10
11
12
13
14
15
16
17

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();
}
More examples
Hide additional examples
examples/sharing_state.rs (line 21)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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));
    }
}
source

pub fn get(&self) -> T

Examples found in repository?
examples/readme.rs (line 15)
8
9
10
11
12
13
14
15
16
17

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();
}
More examples
Hide additional examples
examples/more_complex.rs (line 18)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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§

source§

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

source§

fn as_ref(&self) -> &T

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

impl<T> Debug for Setting<T>
where T: Debug,

source§

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

Formats the value using the given formatter. Read more
source§

impl<T> Default for Setting<T>
where T: Default + Debug + Clone,

source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl<T> !RefUnwindSafe for Setting<T>

§

impl<T> !Send for Setting<T>

§

impl<T> !Sync for Setting<T>

§

impl<T> Unpin for Setting<T>
where T: Unpin,

§

impl<T> !UnwindSafe for Setting<T>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.