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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

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

#[fxstruct(mode(sync), fallible(off, error(String)))]
struct Foo<const FAIL: bool = false> {
    #[fieldx(lazy, fallible)]
    ok: i32,

    #[fieldx(lazy, fallible, get(copy), get_mut, set)]
    writable: u32,

    #[fieldx(lazy, fallible, get(clone))]
    shared: Arc<String>,

    #[fieldx(lazy, lock, reader, writer, fallible, get)]
    locked: i32,
}

impl<const FAIL: bool> Foo<FAIL> {
    fn build_ok(&self) -> Result<i32, String> {
        if FAIL {
            Err("will never be there".to_string())
        }
        else {
            Ok(-42)
        }
    }

    fn build_writable(&self) -> Result<u32, String> {
        if FAIL {
            Err("no value".to_string())
        }
        else {
            Ok(12)
        }
    }

    fn build_shared(&self) -> Result<Arc<String>, String> {
        if FAIL {
            Err("this is a failed outcome".to_string())
        }
        else {
            Ok(Arc::new("shared".to_string()))
        }
    }

    fn build_locked(&self) -> Result<i32, String> {
        if FAIL {
            Err("no way this will work for you!".to_string())
        }
        else {
            Ok(100)
        }
    }
}

#[test]
fn fallible_ok() -> Result<(), Box<dyn std::error::Error>> {
    let mut foo = Foo::<false>::new();

    assert!(*foo.ok()? == -42);

    assert_eq!(foo.writable()?, 12);
    *foo.writable_mut()? = 42;
    assert_eq!(foo.writable()?, 42);

    assert_eq!(*foo.shared()?, "shared".to_string());

    assert_eq!(*foo.locked()?, 100);

    Ok(())
}

#[test]
fn fallible_error() -> Result<(), Box<dyn std::error::Error>> {
    let mut foo = Foo::<true>::new();

    assert!(foo.ok().is_err());
    assert_eq!(*foo.ok().unwrap_err(), String::from("will never be there"));

    assert!(foo.writable().is_err());
    assert_eq!(foo.writable().unwrap_err(), "no value".to_string());
    foo.set_writable(42);
    assert_eq!(foo.writable()?, 42);

    assert!(foo.shared().is_err());
    assert_eq!(*foo.shared().unwrap_err(), String::from("this is a failed outcome"));

    assert!(foo.locked().is_err());
    assert_eq!(
        *foo.locked().unwrap_err(),
        String::from("no way this will work for you!")
    );

    Ok(())
}