1 // Copyright 2017, Igor Shaula
2 // Licensed under the MIT License <LICENSE or
3 // http://opensource.org/licenses/MIT>. This file
4 // may not be copied, modified, or distributed
5 // except according to those terms.
6 use super::enums::*;
7 use super::RegKey;
8 use std::error::Error;
9 use std::fmt;
10 use std::io;
11 use winapi::shared::minwindef::DWORD;
12 
13 macro_rules! read_value {
14     ($s:ident) => {
15         match mem::replace(&mut $s.f_name, None) {
16             Some(ref s) => $s.key.get_value(s).map_err(DecoderError::IoError),
17             None => Err(DecoderError::NoFieldName),
18         }
19     };
20 }
21 
22 macro_rules! parse_string {
23     ($s:ident) => {{
24         let s: String = read_value!($s)?;
25         s.parse()
26             .map_err(|e| DecoderError::ParseError(format!("{:?}", e)))
27     }};
28 }
29 
30 macro_rules! no_impl {
31     ($e:expr) => {
32         Err(DecoderError::DecodeNotImplemented($e.to_owned()))
33     };
34 }
35 
36 #[cfg(feature = "serialization-serde")]
37 mod serialization_serde;
38 
39 #[derive(Debug)]
40 pub enum DecoderError {
41     DecodeNotImplemented(String),
42     DeserializerError(String),
43     IoError(io::Error),
44     ParseError(String),
45     NoFieldName,
46 }
47 
48 impl fmt::Display for DecoderError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result49     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
50         write!(f, "{:?}", self)
51     }
52 }
53 
54 impl Error for DecoderError {}
55 
56 impl From<io::Error> for DecoderError {
from(err: io::Error) -> DecoderError57     fn from(err: io::Error) -> DecoderError {
58         DecoderError::IoError(err)
59     }
60 }
61 
62 pub type DecodeResult<T> = Result<T, DecoderError>;
63 
64 #[derive(Debug)]
65 enum DecoderReadingState {
66     WaitingForKey,
67     WaitingForValue,
68 }
69 
70 #[derive(Debug)]
71 enum DecoderEnumerationState {
72     EnumeratingKeys(DWORD),
73     EnumeratingValues(DWORD),
74 }
75 
76 #[derive(Debug)]
77 pub struct Decoder {
78     key: RegKey,
79     f_name: Option<String>,
80     reading_state: DecoderReadingState,
81     enumeration_state: DecoderEnumerationState,
82 }
83 
84 const DECODER_SAM: DWORD = KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS;
85 
86 impl Decoder {
from_key(key: &RegKey) -> DecodeResult<Decoder>87     pub fn from_key(key: &RegKey) -> DecodeResult<Decoder> {
88         key.open_subkey_with_flags("", DECODER_SAM)
89             .map(Decoder::new)
90             .map_err(DecoderError::IoError)
91     }
92 
new(key: RegKey) -> Decoder93     fn new(key: RegKey) -> Decoder {
94         Decoder {
95             key,
96             f_name: None,
97             reading_state: DecoderReadingState::WaitingForKey,
98             enumeration_state: DecoderEnumerationState::EnumeratingKeys(0),
99         }
100     }
101 }
102