fieldx_aux 0.1.11

Various types and tools useful for fieldx crates and, potentially, to users of fieldx
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use proc_macro2::Span;
use syn::spanned::Spanned;

use crate::{FXAttributes, FXDoc, FXProp};

/// Trait for arguments with trigger behavior. For example, `fieldx` `get` which can be disabled by `off` subargument.
pub trait FXTriggerHelper {
    /// Trigger value
    fn is_true(&self) -> FXProp<bool>;
}

/// Where it is not possible to use the standard `From`/`Into` traits due to conflicting implementations this crate is
/// using `FXFrom`/`FXInto` instead.
pub trait FXFrom<T> {
    fn fx_from(value: T) -> Self;
}

/// The counterpart of `FXFrom`.
pub trait FXInto<T> {
    fn fx_into(self) -> T;
}

impl<T, U> FXInto<U> for T
where
    U: FXFrom<T>,
{
    #[inline]
    fn fx_into(self) -> U {
        U::fx_from(self)
    }
}

pub trait FXTryFrom<T>: Sized {
    type Error;
    fn fx_try_from(value: T) -> Result<Self, Self::Error>;
}

pub trait FXTryInto<T>: Sized {
    type Error;
    fn fx_try_into(self) -> Result<T, Self::Error>;
}

impl<T, U> FXTryInto<U> for T
where
    U: FXTryFrom<T>,
{
    type Error = U::Error;

    #[inline]
    fn fx_try_into(self) -> Result<U, Self::Error> {
        U::fx_try_from(self)
    }
}

/// Implements `FXTriggerHelper`-like functionality for `Option<impl FXTriggerHelper>`
pub trait FXBoolHelper {
    fn is_true(&self) -> FXProp<bool>;
    fn is_true_opt(&self) -> Option<FXProp<bool>>;
}

/// Base functionality of helper types.
pub trait FXHelperTrait: FXTriggerHelper {
    /// Helper method name.
    fn name(&self) -> Option<FXProp<&str>>;
    /// For helper methods that are backed by additional types these are attributes to be applied to the types.
    fn attributes(&self) -> Option<&FXAttributes>;
    /// Additional attributes to apply to generated helper.
    fn attributes_fn(&self) -> Option<&FXAttributes>;
    /// Helper visibility if explicitly set
    fn visibility(&self) -> Option<&syn::Visibility>;
    /// Helper doc if explicitly set.
    fn doc(&self) -> Option<&FXDoc>;
}

impl<H: FXTriggerHelper> FXBoolHelper for Option<H> {
    #[inline]
    fn is_true(&self) -> FXProp<bool> {
        self.as_ref().map_or(FXProp::new(false, None), |h| h.is_true())
    }

    #[inline]
    fn is_true_opt(&self) -> Option<FXProp<bool>> {
        self.as_ref().map(|h| h.is_true())
    }
}

/// Make value traits report their set/unset state. This means:
/// - For types with `off` support unset means `off` is present.
/// - If `off` is ommitted then unset means `None`.
/// - For types that are optional unset means `None`.
pub trait FXSetState {
    fn is_set(&self) -> FXProp<bool>;
}

impl<T> FXSetState for Option<T>
where
    T: FXSetState,
{
    fn is_set(&self) -> FXProp<bool> {
        self.as_ref().map_or(FXProp::new(false, None), |v| v.is_set())
    }
}

impl<T> FXSetState for &T
where
    T: FXSetState,
{
    fn is_set(&self) -> FXProp<bool> {
        T::is_set(*self)
    }
}

impl FXSetState for syn::Visibility {
    fn is_set(&self) -> FXProp<bool> {
        FXProp::new(true, Some(self.span()))
    }
}

// Generic trait for all kinds of objects that can report their span.
pub trait FXSpaned {
    fn fx_span(&self) -> Span;
}

impl<T> FXSpaned for T
where
    T: Spanned,
{
    fn fx_span(&self) -> Span {
        self.span()
    }
}