tinc 0.2.1

GRPc to REST transcoding library
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

pub mod const_macros;
pub mod wrapper;

pub use tinc_proc_macro::Tracker;

mod oneof;
pub use oneof::*;

mod error;
pub use error::*;

mod tracker;
pub use tracker::*;

mod identifier;
pub use identifier::*;

mod primitive;
pub use primitive::*;

mod map;
pub use map::*;

mod optional;
pub use optional::*;

mod enum_;
pub use enum_::*;

mod struct_;
pub use struct_::*;

mod repeated;
pub use repeated::*;

mod expected;
pub use expected::*;

#[cfg(feature = "prost")]
mod well_known;
#[cfg(feature = "prost")]
pub use well_known::*;

mod deserializer;
pub use deserializer::*;

mod http;
pub use http::*;
pub use tinc_cel as cel;
mod validation;
pub use validation::*;

mod fmt;
pub use fmt::*;

mod bytes;
pub use bytes::*;

mod float_with_non_finite;
pub use float_with_non_finite::*;

#[macro_export]
#[doc(hidden)]
macro_rules! __tinc_field_from_str {
    (
        $s:expr,
        $($literal:literal => $expr:expr),*
        $(,flattened: [$($ident:ident),*$(,)?])?
        $(,)?
    ) => {
        match $s {
            $($literal => Ok($expr),)*
            _ => {
                $($(
                    if let Ok(result) = ::core::str::FromStr::from_str($s) {
                        return Ok(Self::$ident(result));
                    }
                )*)?

                Err(())
            },
        }
    };
}

#[inline(always)]
pub fn tracker_allow_duplicates<T: Tracker>(tracker: Option<&T>) -> bool {
    tracker.is_none_or(|tracker| tracker.allow_duplicates())
}

#[inline(always)]
pub fn serde_ser_skip_default<T: Default + PartialEq>(value: &T) -> bool {
    value == &T::default()
}

pub fn deserialize_tracker_target<'de, D, T>(
    state: &mut TrackerSharedState,
    de: D,
    tracker: &mut T,
    target: &mut T::Target,
) -> Result<(), D::Error>
where
    D: serde::Deserializer<'de>,
    T: TrackerDeserializer<'de>,
{
    tinc_cel::CelMode::Serde.set();
    state.in_scope(|| {
        <T as TrackerDeserializer>::deserialize(
            tracker,
            target,
            SerdeDeserializer {
                deserializer: wrapper::DeserializerWrapper::new(de),
            },
        )
    })
}