[go: up one dir, main page]

serde-hex 0.1.0

Hexadecimal encoding/decoding with serde.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Miscellaneous type used by this crate.
use std::{error, fmt, io, result};

/// An alias of `std::result::Result` with this crate's
/// `Error` type inserted by default.
pub type Result<T> = result::Result<T, Error>;

/// error raised during hexadecimal parsing operations
#[derive(Debug)]
pub enum ParseHexError {
    /// hexadecimal buffer was outside allowed range
    Range {
        /// minimum allowed size
        min: usize,
        /// maximum allowed size
        max: usize,
        /// size the was found
        got: usize,
    },
    /// hexadecimal buffer was of expected size
    Size {
        /// expected size
        expect: usize,
        /// size that was found
        actual: usize,
    },
    /// non-hexadecimal character encountered
    Char {
        /// value encountered
        val: char,
    },
}

impl fmt::Display for ParseHexError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ParseHexError::Range {
                ref min,
                ref max,
                ref got,
            } => write!(
                f,
                "expected buff size in `{}...{}`, got `{}`",
                min, max, got
            ),
            ParseHexError::Size {
                ref expect,
                ref actual,
            } => write!(f, "expected buff size `{}` got `{}`", expect, actual),
            ParseHexError::Char { ref val } => write!(f, "non-hex character `{}`", val),
        }
    }
}

impl error::Error for ParseHexError {
    fn description(&self) -> &str {
        match *self {
            ParseHexError::Range { .. } => "hexadecimal outside valid range",
            ParseHexError::Size { .. } => "invalid hexadecimal size",
            ParseHexError::Char { .. } => "non-hex character",
        }
    }
}

/// top-level error kind of this crate
#[derive(Debug)]
pub enum Error {
    /// error raised during i/o operations
    IoError(io::Error),
    /// error raised during parsing operations
    Parsing(ParseHexError),
}

// implement `Display` to allow user-facing errors.  Required
// by the `std::error::Error` trait.
impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::IoError(ref err) => err.fmt(f),
            Error::Parsing(ref err) => err.fmt(f),
        }
    }
}

// implement the standard error trait for hexadecimal errors.
impl error::Error for Error {
    fn description(&self) -> &str {
        match *self {
            Error::IoError(ref err) => err.description(),
            Error::Parsing(ref err) => err.description(),
        }
    }

    fn cause(&self) -> Option<&error::Error> {
        match *self {
            Error::IoError(ref err) => Some(err),
            Error::Parsing(ref err) => Some(err),
        }
    }
}

impl From<io::Error> for Error {
    fn from(err: io::Error) -> Self {
        Error::IoError(err)
    }
}

impl From<ParseHexError> for Error {
    fn from(err: ParseHexError) -> Self {
        Error::Parsing(err)
    }
}