1 use netio::bytes_errors::{BytesReadError, BytesWriteError}; 2 3 use failure::{Backtrace, Fail}; 4 use std::fmt; 5 6 #[derive(Debug, Fail)] 7 pub enum UnpackErrorValue { 8 #[fail(display = "bytes read error: {}", _0)] 9 BytesReadError(BytesReadError), 10 #[fail(display = "unknow read state")] 11 UnknowReadState, 12 #[fail(display = "empty chunks")] 13 EmptyChunks, 14 //IO(io::Error), 15 } 16 17 #[derive(Debug)] 18 pub struct UnpackError { 19 pub value: UnpackErrorValue, 20 } 21 22 impl From<UnpackErrorValue> for UnpackError { 23 fn from(val: UnpackErrorValue) -> Self { 24 UnpackError { value: val } 25 } 26 } 27 28 impl From<BytesReadError> for UnpackError { 29 fn from(error: BytesReadError) -> Self { 30 UnpackError { 31 value: UnpackErrorValue::BytesReadError(error), 32 } 33 } 34 } 35 36 #[derive(Debug, Fail)] 37 pub enum PackErrorValue { 38 #[fail(display = "not exist header")] 39 NotExistHeader, 40 #[fail(display = "unknow read state")] 41 UnknowReadState, 42 #[fail(display = "bytes writer error: {}", _0)] 43 BytesWriteError(BytesWriteError), 44 } 45 46 #[derive(Debug)] 47 pub struct PackError { 48 pub value: PackErrorValue, 49 } 50 51 impl From<PackErrorValue> for PackError { 52 fn from(val: PackErrorValue) -> Self { 53 PackError { value: val } 54 } 55 } 56 57 impl From<BytesWriteError> for PackError { 58 fn from(error: BytesWriteError) -> Self { 59 PackError { 60 value: PackErrorValue::BytesWriteError(error), 61 } 62 } 63 } 64 65 impl fmt::Display for PackError { 66 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 67 fmt::Display::fmt(&self.value, f) 68 } 69 } 70 71 impl Fail for PackError { 72 fn cause(&self) -> Option<&dyn Fail> { 73 self.value.cause() 74 } 75 76 fn backtrace(&self) -> Option<&Backtrace> { 77 self.value.backtrace() 78 } 79 } 80 81 impl fmt::Display for UnpackError { 82 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 83 fmt::Display::fmt(&self.value, f) 84 } 85 } 86 87 impl Fail for UnpackError { 88 fn cause(&self) -> Option<&dyn Fail> { 89 self.value.cause() 90 } 91 92 fn backtrace(&self) -> Option<&Backtrace> { 93 self.value.backtrace() 94 } 95 } 96