Grcov report - tag.rs

1

use serde::de::{self, Visitor};

2

3

use super::{Error, Result};

4

5

pub struct Deserializer<'a, 'b: 'a> {

6

    de: &'a mut super::Deserializer<'b>,

7

8

9

impl<'a, 'b: 'a> Deserializer<'a, 'b> {

10

7021

    pub fn new(de: &'a mut super::Deserializer<'b>) -> Self {

11

7021

        Deserializer { de }

12

7021

13

14

15

impl<'a, 'b: 'a, 'c> de::Deserializer<'b> for &'c mut Deserializer<'a, 'b> {

16

    type Error = Error;

17

18

101

    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>

19

101

    where

20

101

        V: Visitor<'b>,

21

22

101

        self.de.deserialize_str(visitor)

23

101

24

25

    fn deserialize_string<V>(self, visitor: V) -> core::result::Result<V::Value, Self::Error>

26

    where

27

        V: Visitor<'b>,

28

29

        self.deserialize_str(visitor)

30

31

32

101

    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>

33

101

    where

34

101

        V: Visitor<'b>,

35

36

101

        self.deserialize_str(visitor)

37

101

38

39

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>

40

    where

41

        V: Visitor<'b>,

42

43

        self.deserialize_str(visitor)

44

45

46

    fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value>

47

    where

48

        V: Visitor<'b>,

49

50

        Err(Error::ExpectedString)

51

52

53

    fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value>

54

    where

55

        V: Visitor<'b>,

56

57

        Err(Error::ExpectedString)

58

59

60

    fn deserialize_i16<V>(self, _visitor: V) -> Result<V::Value>

61

    where

62

        V: Visitor<'b>,

63

64

        Err(Error::ExpectedString)

65

66

67

    fn deserialize_i32<V>(self, _visitor: V) -> Result<V::Value>

68

    where

69

        V: Visitor<'b>,

70

71

        Err(Error::ExpectedString)

72

73

74

    fn deserialize_i64<V>(self, _visitor: V) -> Result<V::Value>

75

    where

76

        V: Visitor<'b>,

77

78

        Err(Error::ExpectedString)

79

80

81

    #[cfg(feature = "integer128")]

82

    fn deserialize_i128<V>(self, _visitor: V) -> Result<V::Value>

83

    where

84

        V: Visitor<'b>,

85

86

        Err(Error::ExpectedString)

87

88

89

    fn deserialize_u8<V>(self, _visitor: V) -> Result<V::Value>

90

    where

91

        V: Visitor<'b>,

92

93

        Err(Error::ExpectedString)

94

95

96

    fn deserialize_u16<V>(self, _visitor: V) -> Result<V::Value>

97

    where

98

        V: Visitor<'b>,

99

100

        Err(Error::ExpectedString)

101

102

103

    fn deserialize_u32<V>(self, _visitor: V) -> Result<V::Value>

104

    where

105

        V: Visitor<'b>,

106

107

        Err(Error::ExpectedString)

108

109

110

    fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value>

111

    where

112

        V: Visitor<'b>,

113

114

        Err(Error::ExpectedString)

115

116

117

    #[cfg(feature = "integer128")]

118

    fn deserialize_u128<V>(self, _visitor: V) -> Result<V::Value>

119

    where

120

        V: Visitor<'b>,

121

122

        Err(Error::ExpectedString)

123

124

125

    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>

126

    where

127

        V: Visitor<'b>,

128

129

        Err(Error::ExpectedString)

130

131

132

    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>

133

    where

134

        V: Visitor<'b>,

135

136

        Err(Error::ExpectedString)

137

138

139

    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>

140

    where

141

        V: Visitor<'b>,

142

143

        Err(Error::ExpectedString)

144

145

146

    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value>

147

    where

148

        V: Visitor<'b>,

149

150

        Err(Error::ExpectedString)

151

152

153

    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value>

154

    where

155

        V: Visitor<'b>,

156

157

        Err(Error::ExpectedString)

158

159

160

    fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value>

161

    where

162

        V: Visitor<'b>,

163

164

        Err(Error::ExpectedString)

165

166

167

    fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value>

168

    where

169

        V: Visitor<'b>,

170

171

        Err(Error::ExpectedString)

172

173

174

    fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>

175

    where

176

        V: Visitor<'b>,

177

178

        Err(Error::ExpectedString)

179

180

181

    fn deserialize_newtype_struct<V>(self, _name: &'static str, _visitor: V) -> Result<V::Value>

182

    where

183

        V: Visitor<'b>,

184

185

        Err(Error::ExpectedString)

186

187

188

    fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value>

189

    where

190

        V: Visitor<'b>,

191

192

        Err(Error::ExpectedString)

193

194

195

    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value>

196

    where

197

        V: Visitor<'b>,

198

199

        Err(Error::ExpectedString)

200

201

202

    fn deserialize_tuple_struct<V>(

203

        self,

204

        _name: &'static str,

205

        _len: usize,

206

        _visitor: V,

207

    ) -> Result<V::Value>

208

    where

209

        V: Visitor<'b>,

210

211

        Err(Error::ExpectedString)

212

213

214

    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value>

215

    where

216

        V: Visitor<'b>,

217

218

        Err(Error::ExpectedString)

219

220

221

    fn deserialize_struct<V>(

222

        self,

223

        _name: &'static str,

224

        _fields: &'static [&'static str],

225

        _visitor: V,

226

    ) -> Result<V::Value>

227

    where

228

        V: Visitor<'b>,

229

230

        Err(Error::ExpectedString)

231

232

233

    fn deserialize_enum<V>(

234

        self,

235

        _name: &'static str,

236

        _variants: &'static [&'static str],

237

        _visitor: V,

238

    ) -> Result<V::Value>

239

    where

240

        V: Visitor<'b>,

241

242

        Err(Error::ExpectedString)

243

244

245

    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>

246

    where

247

        V: Visitor<'b>,

248

249

        self.deserialize_any(visitor)

250

251