serde_bencode 0.2.1

A Serde backed Bencode encoding/decoding library for Rust.
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

use std::fmt;
use std::fmt::Display;
use std::error::Error as StdError;
use std::io::Error as IoError;
use std::result::Result as StdResult;
use serde::ser::Error as SerError;
use serde::de::Error as DeError;
use serde::de::{Unexpected, Expected};

pub type Result<T> = StdResult<T, Error>;

#[derive(Debug)]
pub enum Error {
    IoError(IoError),
    InvalidType(String),
    InvalidValue(String),
    InvalidLength(String),
    UnknownVariant(String),
    UnknownField(String),
    MissingField(String),
    DuplicateField(String),
    Custom(String),
    EndOfStream,
}

impl SerError for Error {
    fn custom<T: Display>(msg: T) -> Self {
        Error::Custom(msg.to_string())
    }
}

impl DeError for Error {
    fn custom<T: Display>(msg: T) -> Self {
        Error::Custom(msg.to_string())
    }

    fn invalid_type(unexp: Unexpected, exp: &Expected) -> Self {
        Error::InvalidType(format!("Invalid Type: {} (expected: `{}`)", unexp, exp))
    }

    fn invalid_value(unexp: Unexpected, exp: &Expected) -> Self {
        Error::InvalidValue(format!("Invalid Value: {} (expected: `{}`)", unexp, exp))
    }

    fn invalid_length(len: usize, exp: &Expected) -> Self {
        Error::InvalidLength(format!("Invalid Length: {} (expected: {})", len, exp))
    }

    fn unknown_variant(field: &str, expected: &'static [&'static str]) -> Self {
        Error::UnknownVariant(format!("Unknown Variant: `{}` (expected one of: {:?})",
                                      field,
                                      expected))
    }

    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
        Error::UnknownField(format!("Unknown Field: `{}` (expected one of: {:?})",
                                    field,
                                    expected))
    }

    fn missing_field(field: &'static str) -> Self {
        Error::MissingField(format!("Missing Field: `{}`", field))
    }

    fn duplicate_field(field: &'static str) -> Self {
        Error::DuplicateField(format!("Duplicat Field: `{}`", field))
    }
}

impl StdError for Error {
    fn description(&self) -> &str {
        match *self {
            Error::IoError(ref error) => StdError::description(error),
            Error::InvalidType(ref s) => s,
            Error::InvalidValue(ref s) => s,
            Error::InvalidLength(ref s) => s,
            Error::UnknownVariant(ref s) => s,
            Error::UnknownField(ref s) => s,
            Error::MissingField(ref s) => s,
            Error::DuplicateField(ref s) => s,
            Error::Custom(ref s) => s,
            Error::EndOfStream => "End of stream",
        }
    }

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

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(self.description())
    }
}