probor 0.3.1

A (prototype of) serialization protocol on top of CBOR that provides protobuf-like functionality
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

use cbor;
use std::error::Error;
use std::fmt::{self, Formatter, Debug, Display};


pub enum DecodeError {
    AbsentField(&'static str),
    WrongArrayLength(usize),
    DuplicateKey,
    UnexpectedNull,
    WrongType(&'static str, cbor::DecodeError),
    WrongValue(&'static str),
    BadFieldValue(&'static str, Box<DecodeError>),
    BadArrayElement(usize, Box<DecodeError>),
    SkippingError(cbor::DecodeError),
}

impl Debug for DecodeError {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
        use self::DecodeError::*;
        match self {
            &AbsentField(field) => write!(fmt, "absent field {:?}", field),
            &WrongArrayLength(n) => write!(fmt, "wrong array length {:?}", n),
            &DuplicateKey => write!(fmt, "some key is duplicated"),
            &UnexpectedNull => write!(fmt, "null is not expected"),
            &WrongType(exp, ref err) => write!(fmt, "{}: {}", exp, err),
            &WrongValue(exp) => write!(fmt, "{}", exp),
            &BadFieldValue(field, ref err)
            => write!(fmt, "Bad value for {:?}: {}", field, err),
            &BadArrayElement(num, ref err)
            => write!(fmt, "Bad array element {}: {}", num, err),
            &SkippingError(ref err)
            => write!(fmt, "Error when skipping value: {}", err),
        }
    }
}

impl Display for DecodeError {
    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
        use self::DecodeError::*;
        match self {
            &AbsentField(field) => write!(fmt, "absent field {:?}", field),
            &WrongArrayLength(n) => write!(fmt, "wrong array length {:?}", n),
            &DuplicateKey => write!(fmt, "some key is duplicated"),
            &UnexpectedNull => write!(fmt, "null is not expected"),
            &WrongType(exp, ref err) => write!(fmt, "{}: {}", exp, err),
            &WrongValue(exp) => write!(fmt, "{}", exp),
            &BadFieldValue(field, ref err)
            => write!(fmt, "Bad value for {:?}: {}", field, err),
            &BadArrayElement(num, ref err)
            => write!(fmt, "Bad array element {}: {}", num, err),
            &SkippingError(ref err)
            => write!(fmt, "Error when skipping value: {}", err),
        }
    }
}

impl Error for DecodeError {
    fn description(&self) -> &'static str {
        use self::DecodeError::*;
        match self {
            &AbsentField(_) => "absent field",
            &WrongArrayLength(_) => "wrong array length",
            &DuplicateKey => "some key is duplicated",
            &UnexpectedNull => "unexpected null",
            &WrongType(exp, _) => exp,
            &WrongValue(exp) => exp,
            &BadFieldValue(_, _) => "bad field value",
            &BadArrayElement(_, _) => "bad array element",
            &SkippingError(_) => "error when skipping value",
        }
    }
    fn cause(&self) -> Option<&Error> {
        use self::DecodeError::*;
        match self {
            &AbsentField(_) => None,
            &WrongArrayLength(_) => None,
            &DuplicateKey => None,
            &UnexpectedNull => None,
            &WrongType(_, ref err) => Some(err),
            &WrongValue(_) => None,
            &BadFieldValue(_, ref err) => Some(&**err),
            &BadArrayElement(_, ref err) => Some(&**err),
            &SkippingError(ref err) => Some(err),
        }
    }
}