From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../rust/winreg/src/decoder/serialization_serde.rs | 331 +++++++++++++++++++++ 1 file changed, 331 insertions(+) create mode 100644 third_party/rust/winreg/src/decoder/serialization_serde.rs (limited to 'third_party/rust/winreg/src/decoder/serialization_serde.rs') diff --git a/third_party/rust/winreg/src/decoder/serialization_serde.rs b/third_party/rust/winreg/src/decoder/serialization_serde.rs new file mode 100644 index 0000000000..1287540448 --- /dev/null +++ b/third_party/rust/winreg/src/decoder/serialization_serde.rs @@ -0,0 +1,331 @@ +// Copyright 2017, Igor Shaula +// Licensed under the MIT License . This file +// may not be copied, modified, or distributed +// except according to those terms. +use super::super::FromRegValue; +use super::{ + DecodeResult, Decoder, DecoderEnumerationState, DecoderError, DecoderReadingState, DECODER_SAM, +}; +use serde::de::*; +use std::fmt; +use std::mem; + +impl Error for DecoderError { + fn custom(msg: T) -> Self { + DecoderError::DeserializerError(format!("{}", msg)) + } +} + +impl<'de, 'a> Deserializer<'de> for &'a mut Decoder { + type Error = DecoderError; + fn deserialize_any(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + use self::DecoderEnumerationState::*; + match self.enumeration_state { + EnumeratingKeys(..) => no_impl!("deserialize_any for keys"), + EnumeratingValues(..) => { + let s = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + let v = self.key.get_raw_value(s)?; + use RegType::*; + match v.vtype { + REG_SZ | REG_EXPAND_SZ | REG_MULTI_SZ => { + visitor.visit_string(String::from_reg_value(&v)?) + } + REG_DWORD => visitor.visit_u32(u32::from_reg_value(&v)?), + REG_QWORD => visitor.visit_u64(u64::from_reg_value(&v)?), + _ => Err(DecoderError::DecodeNotImplemented( + "value type deserialization not implemented".to_owned(), + )), + } + } + } + } + + fn deserialize_bool(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_bool(read_value!(self).map(|v: u32| v > 0)?) + } + + fn deserialize_u8(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + self.deserialize_u32(visitor) + } + + fn deserialize_u16(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + self.deserialize_u32(visitor) + } + + fn deserialize_u32(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_u32(read_value!(self)?) + } + + fn deserialize_u64(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_u64(read_value!(self)?) + } + + fn deserialize_i8(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_i8(parse_string!(self)?) + } + + fn deserialize_i16(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_i16(parse_string!(self)?) + } + + fn deserialize_i32(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_i32(parse_string!(self)?) + } + + fn deserialize_i64(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_i64(parse_string!(self)?) + } + + fn deserialize_f32(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_f32(parse_string!(self)?) + } + + fn deserialize_f64(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_f64(parse_string!(self)?) + } + + fn deserialize_char(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + self.deserialize_string(visitor) + } + + fn deserialize_str(self, _visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_str") + } + + fn deserialize_string(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + use self::DecoderReadingState::*; + match self.reading_state { + WaitingForKey => { + let s = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + visitor.visit_string(s.clone()) + } + WaitingForValue => visitor.visit_string(read_value!(self)?), + } + } + + fn deserialize_bytes(self, _visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_bytes") + } + + fn deserialize_byte_buf(self, _visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_byte_buf") + } + + fn deserialize_option(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + let v = { + let s = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + self.key.get_raw_value(s) + }; + match v { + Ok(..) => visitor.visit_some(&mut *self), + Err(..) => visitor.visit_none(), + } + } + + fn deserialize_unit(self, _visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_unit") + } + + fn deserialize_unit_struct(self, _name: &'static str, _visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_unit_struct") + } + + fn deserialize_newtype_struct( + self, + _name: &'static str, + _visitor: V, + ) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_newtype_struct") + } + + fn deserialize_seq(self, _visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_seq") + } + + fn deserialize_tuple(self, _len: usize, _visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_tuple") + } + + fn deserialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + _visitor: V, + ) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_tuple_struct") + } + + fn deserialize_map(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_map(self) + } + + fn deserialize_struct( + self, + _name: &'static str, + _fields: &'static [&'static str], + visitor: V, + ) -> DecodeResult + where + V: Visitor<'de>, + { + visitor.visit_map(self) + } + + fn deserialize_identifier(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + self.deserialize_string(visitor) + } + + fn deserialize_enum( + self, + _name: &'static str, + _variants: &'static [&'static str], + _visitor: V, + ) -> DecodeResult + where + V: Visitor<'de>, + { + no_impl!("deserialize_enum") + } + + fn deserialize_ignored_any(self, visitor: V) -> DecodeResult + where + V: Visitor<'de>, + { + self.deserialize_any(visitor) + } +} + +impl<'de, 'a> MapAccess<'de> for Decoder { + type Error = DecoderError; + fn next_key_seed(&mut self, seed: K) -> Result, Self::Error> + where + K: DeserializeSeed<'de>, + { + self.reading_state = DecoderReadingState::WaitingForKey; + use self::DecoderEnumerationState::*; + match self.enumeration_state { + EnumeratingKeys(index) => match self.key.enum_key(index) { + Some(res) => { + self.f_name = Some(res?); + self.enumeration_state = EnumeratingKeys(index + 1); + seed.deserialize(&mut *self).map(Some) + } + None => { + self.enumeration_state = EnumeratingValues(0); + self.next_key_seed(seed) + } + }, + EnumeratingValues(index) => { + let next_value = self.key.enum_value(index); + match next_value { + Some(res) => { + self.f_name = Some(res?.0); + self.enumeration_state = EnumeratingValues(index + 1); + seed.deserialize(&mut *self).map(Some) + } + None => Ok(None), + } + } + } + } + + fn next_value_seed(&mut self, seed: V) -> Result + where + V: DeserializeSeed<'de>, + { + self.reading_state = DecoderReadingState::WaitingForValue; + use self::DecoderEnumerationState::*; + match self.enumeration_state { + EnumeratingKeys(..) => { + let f_name = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + match self.key.open_subkey_with_flags(f_name, DECODER_SAM) { + Ok(subkey) => { + let mut nested = Decoder::new(subkey); + seed.deserialize(&mut nested) + } + Err(err) => Err(DecoderError::IoError(err)), + } + } + EnumeratingValues(..) => seed.deserialize(&mut *self), + } + } +} -- cgit v1.2.3