summaryrefslogtreecommitdiffstats
path: root/third_party/rust/winreg/src/decoder/serialization_serde.rs
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/winreg/src/decoder/serialization_serde.rs')
-rw-r--r--third_party/rust/winreg/src/decoder/serialization_serde.rs331
1 files changed, 331 insertions, 0 deletions
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 <LICENSE or
+// http://opensource.org/licenses/MIT>. 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<T: fmt::Display>(msg: T) -> Self {
+ DecoderError::DeserializerError(format!("{}", msg))
+ }
+}
+
+impl<'de, 'a> Deserializer<'de> for &'a mut Decoder {
+ type Error = DecoderError;
+ fn deserialize_any<V>(self, visitor: V) -> DecodeResult<V::Value>
+ 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<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_bool(read_value!(self).map(|v: u32| v > 0)?)
+ }
+
+ fn deserialize_u8<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_u32(visitor)
+ }
+
+ fn deserialize_u16<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_u32(visitor)
+ }
+
+ fn deserialize_u32<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_u32(read_value!(self)?)
+ }
+
+ fn deserialize_u64<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_u64(read_value!(self)?)
+ }
+
+ fn deserialize_i8<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_i8(parse_string!(self)?)
+ }
+
+ fn deserialize_i16<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_i16(parse_string!(self)?)
+ }
+
+ fn deserialize_i32<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_i32(parse_string!(self)?)
+ }
+
+ fn deserialize_i64<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_i64(parse_string!(self)?)
+ }
+
+ fn deserialize_f32<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_f32(parse_string!(self)?)
+ }
+
+ fn deserialize_f64<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_f64(parse_string!(self)?)
+ }
+
+ fn deserialize_char<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_string(visitor)
+ }
+
+ fn deserialize_str<V>(self, _visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_str")
+ }
+
+ fn deserialize_string<V>(self, visitor: V) -> DecodeResult<V::Value>
+ 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<V>(self, _visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_bytes")
+ }
+
+ fn deserialize_byte_buf<V>(self, _visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_byte_buf")
+ }
+
+ fn deserialize_option<V>(self, visitor: V) -> DecodeResult<V::Value>
+ 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<V>(self, _visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_unit")
+ }
+
+ fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_unit_struct")
+ }
+
+ fn deserialize_newtype_struct<V>(
+ self,
+ _name: &'static str,
+ _visitor: V,
+ ) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_newtype_struct")
+ }
+
+ fn deserialize_seq<V>(self, _visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_seq")
+ }
+
+ fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_tuple")
+ }
+
+ fn deserialize_tuple_struct<V>(
+ self,
+ _name: &'static str,
+ _len: usize,
+ _visitor: V,
+ ) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_tuple_struct")
+ }
+
+ fn deserialize_map<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_map(self)
+ }
+
+ fn deserialize_struct<V>(
+ self,
+ _name: &'static str,
+ _fields: &'static [&'static str],
+ visitor: V,
+ ) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_map(self)
+ }
+
+ fn deserialize_identifier<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_string(visitor)
+ }
+
+ fn deserialize_enum<V>(
+ self,
+ _name: &'static str,
+ _variants: &'static [&'static str],
+ _visitor: V,
+ ) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ no_impl!("deserialize_enum")
+ }
+
+ fn deserialize_ignored_any<V>(self, visitor: V) -> DecodeResult<V::Value>
+ where
+ V: Visitor<'de>,
+ {
+ self.deserialize_any(visitor)
+ }
+}
+
+impl<'de, 'a> MapAccess<'de> for Decoder {
+ type Error = DecoderError;
+ fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, 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<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+ 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),
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-29 15:29:50 +0000