1use std::convert::{TryFrom, TryInto};23use linked_hash_map::LinkedHashMap;4use serde::{5 Deserializer, Serialize,6 de::{self, MapAccess, SeqAccess},7};89use crate::{Error, Value};1011struct ObjectAccess {12 iter: linked_hash_map::IntoIter<String, Value>,13 value: Option<Value>,14}15impl ObjectAccess {16 fn new(v: LinkedHashMap<String, Value>) -> Self {17 Self {18 iter: v.into_iter(),19 value: None,20 }21 }22}2324impl<'de> MapAccess<'de> for ObjectAccess {25 type Error = Error;2627 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>28 where29 K: de::DeserializeSeed<'de>,30 {31 match self.iter.next() {32 Some((k, v)) => {33 let _ = self.value.insert(v);34 Ok(Some(seed.deserialize(Value::String(k))?))35 }36 _ => Ok(None),37 }38 }3940 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>41 where42 V: de::DeserializeSeed<'de>,43 {44 seed.deserialize(self.value.take().unwrap())45 }46}4748struct ArrayAccess {49 iter: std::vec::IntoIter<Value>,50}51impl ArrayAccess {52 fn new(v: Vec<Value>) -> Self {53 Self {54 iter: v.into_iter(),55 }56 }57}5859impl<'de> SeqAccess<'de> for ArrayAccess {60 type Error = Error;6162 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>63 where64 T: de::DeserializeSeed<'de>,65 {66 match self.iter.next() {67 Some(v) => Ok(Some(seed.deserialize(v)?)),68 _ => Ok(None),69 }70 }71}7273impl Value {74 fn parse_int<T: TryFrom<i64>>(&self) -> Result<T, Error> {75 match self {76 Value::Number(n) => Ok((*n).try_into().map_err(|_| Error::BadNumber)?),77 _ => Err(Error::Expected("integer")),78 }79 }80 fn parse_boolean(self) -> Result<bool, Error> {81 match self {82 Value::Boolean(b) => Ok(b),83 _ => Err(Error::Expected("boolean")),84 }85 }86 pub fn parse_string(&self) -> Result<&str, Error> {87 match self {88 Value::String(s) => Ok(s),89 _ => Err(Error::Expected("string")),90 }91 }92 fn parse_char(self) -> Result<char, Error> {93 match self {94 Value::String(s) if s.chars().count() == 1 => Ok(s.chars().next().unwrap()),95 _ => Err(Error::Expected("char")),96 }97 }98 fn parse_array(self) -> Result<Vec<Value>, Error> {99 match self {100 Value::Array(s) => Ok(s),101 _ => Err(Error::Expected("array")),102 }103 }104 fn parse_object(self) -> Result<LinkedHashMap<String, Value>, Error> {105 match self {106 Value::Object(s) => Ok(s),107 _ => Err(Error::Expected("object")),108 }109 }110 fn parse_null(self) -> Result<(), Error> {111 match self {112 Value::Null => Ok(()),113 _ => Err(Error::Expected("null")),114 }115 }116}117118impl de::Error for Error {119 fn custom<T>(msg: T) -> Self120 where121 T: std::fmt::Display,122 {123 Self::Custom(format!("{}", msg))124 }125}126127impl<'de> Deserializer<'de> for Value {128 type Error = Error;129130 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>131 where132 V: serde::de::Visitor<'de>,133 {134 match self {135 Value::Number(f) => visitor.visit_i64(f),136 Value::String(s) => visitor.visit_str(&s),137 Value::Boolean(b) => visitor.visit_bool(b),138 Value::Object(o) => visitor.visit_map(ObjectAccess::new(o)),139 Value::Array(a) => visitor.visit_seq(ArrayAccess::new(a)),140 Value::Null => visitor.visit_none(),141 Value::Import(d) => {142 let value = d.serialize(crate::se_impl::MySerialize)?;143 value.deserialize_any(visitor)144 }145 }146 }147148 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>149 where150 V: serde::de::Visitor<'de>,151 {152 visitor.visit_bool(self.parse_boolean()?)153 }154155 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>156 where157 V: serde::de::Visitor<'de>,158 {159 visitor.visit_i8(self.parse_int()?)160 }161162 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>163 where164 V: serde::de::Visitor<'de>,165 {166 visitor.visit_i16(self.parse_int()?)167 }168169 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>170 where171 V: serde::de::Visitor<'de>,172 {173 visitor.visit_i32(self.parse_int()?)174 }175176 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>177 where178 V: serde::de::Visitor<'de>,179 {180 visitor.visit_i64(self.parse_int()?)181 }182183 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>184 where185 V: serde::de::Visitor<'de>,186 {187 visitor.visit_u8(self.parse_int()?)188 }189190 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>191 where192 V: serde::de::Visitor<'de>,193 {194 visitor.visit_u16(self.parse_int()?)195 }196197 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>198 where199 V: serde::de::Visitor<'de>,200 {201 visitor.visit_u32(self.parse_int()?)202 }203204 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>205 where206 V: serde::de::Visitor<'de>,207 {208 visitor.visit_u64(self.parse_int()?)209 }210211 fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value, Self::Error>212 where213 V: serde::de::Visitor<'de>,214 {215 todo!()216 }217218 fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value, Self::Error>219 where220 V: serde::de::Visitor<'de>,221 {222 todo!()223 }224225 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>226 where227 V: serde::de::Visitor<'de>,228 {229 visitor.visit_char(self.parse_char()?)230 }231232 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>233 where234 V: serde::de::Visitor<'de>,235 {236 visitor.visit_str(self.parse_string()?)237 }238239 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>240 where241 V: serde::de::Visitor<'de>,242 {243 visitor.visit_string(self.parse_string()?.to_owned())244 }245246 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>247 where248 V: serde::de::Visitor<'de>,249 {250 todo!()251 }252253 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>254 where255 V: serde::de::Visitor<'de>,256 {257 todo!()258 }259260 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>261 where262 V: serde::de::Visitor<'de>,263 {264 match self {265 Value::Null => visitor.visit_none(),266 v => visitor.visit_some(v),267 }268 }269270 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>271 where272 V: serde::de::Visitor<'de>,273 {274 self.parse_null()?;275 visitor.visit_unit()276 }277278 fn deserialize_unit_struct<V>(279 self,280 _name: &'static str,281 visitor: V,282 ) -> Result<V::Value, Self::Error>283 where284 V: serde::de::Visitor<'de>,285 {286 self.deserialize_unit(visitor)287 }288289 fn deserialize_newtype_struct<V>(290 self,291 _name: &'static str,292 visitor: V,293 ) -> Result<V::Value, Self::Error>294 where295 V: serde::de::Visitor<'de>,296 {297 visitor.visit_newtype_struct(self)298 }299300 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>301 where302 V: serde::de::Visitor<'de>,303 {304 visitor.visit_seq(self.parse_array().map(ArrayAccess::new)?)305 }306307 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>308 where309 V: serde::de::Visitor<'de>,310 {311 self.deserialize_seq(visitor)312 }313314 fn deserialize_tuple_struct<V>(315 self,316 _name: &'static str,317 _len: usize,318 visitor: V,319 ) -> Result<V::Value, Self::Error>320 where321 V: serde::de::Visitor<'de>,322 {323 self.deserialize_seq(visitor)324 }325326 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>327 where328 V: serde::de::Visitor<'de>,329 {330 match self {331 Value::Import(d) => {332 let value = d.serialize(crate::se_impl::MySerialize)?;333 value.deserialize_map(visitor)334 }335 v => visitor.visit_map(v.parse_object().map(ObjectAccess::new)?),336 }337 }338339 fn deserialize_struct<V>(340 self,341 _name: &'static str,342 _fields: &'static [&'static str],343 visitor: V,344 ) -> Result<V::Value, Self::Error>345 where346 V: serde::de::Visitor<'de>,347 {348 self.deserialize_map(visitor)349 }350351 fn deserialize_enum<V>(352 self,353 _name: &'static str,354 _variants: &'static [&'static str],355 _visitor: V,356 ) -> Result<V::Value, Self::Error>357 where358 V: serde::de::Visitor<'de>,359 {360 todo!()361 }362363 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>364 where365 V: serde::de::Visitor<'de>,366 {367 self.deserialize_str(visitor)368 }369370 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>371 where372 V: serde::de::Visitor<'de>,373 {374 self.deserialize_any(visitor)375 }376}