1 use crate::{ArcSwapAny, RefCnt, Strategy};
2 use serde::{Deserialize, Deserializer, Serialize, Serializer};
3 
4 impl<T, S> Serialize for ArcSwapAny<T, S>
5 where
6     T: RefCnt + Serialize,
7     S: Strategy<T>,
8 {
serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>9     fn serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
10         self.load().serialize(serializer)
11     }
12 }
13 
14 impl<'de, T, S> Deserialize<'de> for ArcSwapAny<T, S>
15 where
16     T: RefCnt + Deserialize<'de>,
17     S: Strategy<T> + Default,
18 {
deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>19     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
20         Ok(Self::from(T::deserialize(deserializer)?))
21     }
22 }
23 
24 #[cfg(test)]
25 mod tests {
26     use crate::{ArcSwap, ArcSwapAny, ArcSwapOption, RefCnt};
27     use serde_derive::{Deserialize, Serialize};
28     use serde_test::{assert_tokens, Token};
29     use std::sync::Arc;
30 
31     #[derive(Debug, Serialize, Deserialize)]
32     #[serde(transparent)]
33     struct ArcSwapAnyEq<T: RefCnt>(ArcSwapAny<T>);
34     impl<T: RefCnt + PartialEq> PartialEq for ArcSwapAnyEq<T> {
eq(&self, other: &Self) -> bool35         fn eq(&self, other: &Self) -> bool {
36             self.0.load().eq(&other.0.load())
37         }
38     }
39     impl<T: RefCnt + PartialEq> Eq for ArcSwapAnyEq<T> {}
40 
41     #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
42     struct Foo {
43         field0: u64,
44         field1: String,
45     }
46 
47     #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
48     struct Bar {
49         field0: ArcSwapAnyEq<Arc<u64>>,
50         field1: ArcSwapAnyEq<Option<Arc<String>>>,
51     }
52 
53     #[test]
test_serialize_deserialize()54     fn test_serialize_deserialize() {
55         let field0 = u64::MAX;
56         let field1 = "FOO_-0123456789";
57 
58         let data_orig = Foo {
59             field0,
60             field1: field1.to_string(),
61         };
62         let data = ArcSwapAnyEq(ArcSwap::from_pointee(data_orig));
63         assert_tokens(
64             &data,
65             &[
66                 Token::Struct {
67                     name: "Foo",
68                     len: 2,
69                 },
70                 Token::Str("field0"),
71                 Token::U64(u64::MAX),
72                 Token::Str("field1"),
73                 Token::String(field1),
74                 Token::StructEnd,
75             ],
76         );
77 
78         let data = Bar {
79             field0: ArcSwapAnyEq(ArcSwap::from_pointee(field0)),
80             field1: ArcSwapAnyEq(ArcSwapOption::from_pointee(field1.to_string())),
81         };
82         assert_tokens(
83             &data,
84             &[
85                 Token::Struct {
86                     name: "Bar",
87                     len: 2,
88                 },
89                 Token::Str("field0"),
90                 Token::U64(u64::MAX),
91                 Token::Str("field1"),
92                 Token::Some,
93                 Token::String(field1),
94                 Token::StructEnd,
95             ],
96         );
97     }
98 
99     #[test]
test_serialize_deserialize_option()100     fn test_serialize_deserialize_option() {
101         let field0 = u64::MAX;
102         let field1 = "FOO_-0123456789";
103 
104         let data_orig = Foo {
105             field0,
106             field1: field1.to_string(),
107         };
108         let data = ArcSwapAnyEq(ArcSwapOption::from_pointee(data_orig));
109         assert_tokens(
110             &data,
111             &[
112                 Token::Some,
113                 Token::Struct {
114                     name: "Foo",
115                     len: 2,
116                 },
117                 Token::Str("field0"),
118                 Token::U64(u64::MAX),
119                 Token::Str("field1"),
120                 Token::String(field1),
121                 Token::StructEnd,
122             ],
123         );
124     }
125 
126     #[test]
test_serialize_deserialize_option_none()127     fn test_serialize_deserialize_option_none() {
128         let data = ArcSwapAnyEq(ArcSwapOption::<Foo>::from_pointee(None));
129 
130         assert_tokens(&data, &[Token::None]);
131     }
132 }
133