polodb_bson 2.0.0

BSON lib for PoloDB
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
113
114
115
116
117
118
119

use std::fmt;
use std::num;
use std::io;
use std::str::Utf8Error;
use std::string::FromUtf8Error;
use rmp::decode::{DecodeStringError, ValueReadError, MarkerReadError};
use rmp::encode::ValueWriteError;

#[derive(Debug)]
pub enum BsonErr {
    ParseError(String),
    ParseIntError(Box<num::ParseIntError>),
    DecodeIntUnknownByte,
    IOErr(Box<io::Error>),
    UTF8Error(Box<Utf8Error>),
    FromUTF8Error(Box<FromUtf8Error>),
    TypeNotComparable(String, String),
    RmpWriteError(Box<ValueWriteError>),
    RmpReadError(Box<ValueReadError>),
    RmpMarkerReadError(Box<MarkerReadError>),
    DecodeStringErr(String),
}

pub mod parse_error_reason {

    pub static OBJECT_ID_LEN: &str = "length of ObjectId should be 12";
    pub static OBJECT_ID_HEX_DECODE_ERROR: &str = "decode error failed for ObjectID";
    pub static UNEXPECTED_DOCUMENT_FLAG: &str = "unexpected flag for document";
    pub static UNEXPECTED_PAGE_HEADER: &str = "unexpected page header";
    pub static UNEXPECTED_PAGE_TYPE: &str = "unexpected page type";
    pub static UNEXPECTED_HEADER_FOR_BTREE_PAGE: &str = "unexpected header for btree page";
    pub static KEY_TY_SHOULD_NOT_BE_ZERO: &str = "type name of KEY should not be zero";

}

impl fmt::Display for BsonErr {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            BsonErr::ParseError(reason) => write!(f, "ParseError: {}", reason),
            BsonErr::ParseIntError(parse_int_err) => parse_int_err.fmt(f),
            BsonErr::DecodeIntUnknownByte => write!(f, "DecodeIntUnknownByte"),
            BsonErr::IOErr(io_err) => std::fmt::Display::fmt(&io_err, f),
            BsonErr::UTF8Error(utf8_err) => std::fmt::Display::fmt(&utf8_err, f),
            BsonErr::TypeNotComparable(expected, actual) =>
                write!(f, "TypeNotComparable(expected: {}, actual: {})", expected, actual),
            BsonErr::FromUTF8Error(err) => write!(f, "{}", err),
            BsonErr::RmpWriteError(err) => write!(f, "{}", err),
            BsonErr::RmpReadError(err) => write!(f, "{}", err),
            BsonErr::DecodeStringErr(err) => write!(f, "{}", err),
            BsonErr::RmpMarkerReadError(_err) => write!(f, "RmpMarkerReadError"),
        }
    }

}

impl From<io::Error> for BsonErr {

    fn from(error: io::Error) -> Self {
        BsonErr::IOErr(Box::new(error))
    }

}

impl From<Utf8Error> for BsonErr {

    fn from(error: Utf8Error) -> Self {
        BsonErr::UTF8Error(Box::new(error))
    }

}

impl From<num::ParseIntError> for BsonErr {

    fn from(error: num::ParseIntError) -> Self {
        BsonErr::ParseIntError(Box::new(error))
    }

}

impl From<FromUtf8Error> for BsonErr {

    fn from(error: FromUtf8Error) -> Self {
        BsonErr::FromUTF8Error(Box::new(error))
    }

}

impl From<ValueWriteError> for BsonErr {

    fn from(error: ValueWriteError) -> Self {
        BsonErr::RmpWriteError(Box::new(error))
    }

}

impl From<ValueReadError> for BsonErr {

    fn from(error: ValueReadError) -> Self {
        BsonErr::RmpReadError(Box::new(error))
    }

}

impl<'a> From<DecodeStringError<'a>> for BsonErr {
    fn from(err: DecodeStringError<'a>) -> Self {
        BsonErr::DecodeStringErr(err.to_string())
    }
}

impl From<MarkerReadError> for BsonErr {
    fn from(err: MarkerReadError) -> Self {
        BsonErr::RmpMarkerReadError(Box::new(err))
    }
}

impl std::error::Error for BsonErr {
    
}