fieldx 0.2.3

Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#![cfg(feature = "sync")]
use fieldx::fxstruct;
use parking_lot::Mutex;

#[fxstruct(sync)]
#[derive(Debug)]
pub struct Foo<T>
where
    T: std::fmt::Debug + Default + Clone + Send + Sync + 'static,
{
    #[fieldx(lazy, writer, clearer, predicate)]
    foo: String,
    #[fieldx(lazy, writer, reader, predicate, clearer, set, get(off))]
    bar: i32,

    // #[fieldx(default(3.1415926))]
    // pub pi: f32,

    // Let's try a charged but not lazy field
    #[fieldx(
        writer,
        reader,
        get(off),
        clearer,
        predicate,
        set,
        default(String::from("bazzification"))
    )]
    baz: String,

    #[fieldx(lazy, clearer)]
    fubar: String,

    bar_builds: Mutex<i32>,
    next_bar:   Mutex<Option<i32>>,

    #[fieldx(lazy)]
    dummy: T,
}

impl<T> Foo<T>
where
    T: std::fmt::Debug + Default + Clone + Send + Sync + 'static,
{
    fn build_foo(&self) -> String {
        format!("Foo with bar={:?}", *self.read_bar()).to_string()
    }

    fn build_bar(&self) -> i32 {
        *self.bar_builds.lock() += 1;
        self.next_bar.lock().unwrap_or(42)
    }

    fn build_dummy(&self) -> T {
        T::default()
    }

    fn build_fubar(&self) -> String {
        "аби було".to_string()
    }

    pub fn set_next_bar(&self, next_val: i32) {
        *self.next_bar.lock() = Some(next_val);
    }

    pub fn bar_builds(&self) -> i32 {
        *self.bar_builds.lock()
    }
}