serde_bencode 0.1.2

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::error::Error as StdError;
use std::io::Error as IoError;
use serde::ser::Error as SerError;
use serde::de::Error as DeError;
use serde::de::Type;

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

impl SerError for BencodeError {
    fn custom<T: Into<String>>(msg: T) -> Self {
        BencodeError::Custom(msg.into())
    }

    fn invalid_value(msg: &str) -> Self {
        BencodeError::InvalidValue(msg.into())
    }
}

impl DeError for BencodeError {
    fn custom<T: Into<String>>(msg: T) -> Self {
        BencodeError::Custom(msg.into())
    }

    fn end_of_stream() -> Self {
        BencodeError::EndOfStream
    }

    fn invalid_type(ty: Type) -> Self {
        BencodeError::InvalidType(format!("Invalid Type: {:?}", ty))
    }

    fn invalid_value(msg: &str) -> Self {
        BencodeError::InvalidValue(format!("Invalid Value: {}", msg))
    }

    fn invalid_length(len: usize) -> Self {
        BencodeError::InvalidLength(format!("Invalid Length: {}", len))
    }

    fn unknown_variant(field: &str) -> Self {
        BencodeError::UnknownVariant(format!("Unknown Variant: {}", field))
    }

    fn unknown_field(field: &str) -> Self {
        BencodeError::UnknownField(format!("Unknown Field: {}", field))
    }

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

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

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

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

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