xref: /xiu/protocol/rtmp/src/messages/errors.rs (revision 69de9bbd) 
1 use {
2     crate::{
3         amf0::errors::Amf0ReadError,
4         protocol_control_messages::errors::ProtocolControlMessageReaderError,
5         user_control_messages::errors::EventMessagesError,
6     },
7     failure::{Backtrace, Fail},
8     bytesio::bytes_errors::BytesReadError,
9     std::fmt,
10 };
11 
12 #[derive(Debug, Fail)]
13 pub enum MessageErrorValue {
14     #[fail(display = "bytes read error: {}", _0)]
15     BytesReadError(BytesReadError),
16     #[fail(display = "unknow read state")]
17     UnknowReadState,
18     #[fail(display = "amf0 read error: {}", _0)]
19     Amf0ReadError(Amf0ReadError),
20     #[fail(display = "unknown message type")]
21     UnknowMessageType,
22     #[fail(display = "protocol control message read error: {}", _0)]
23     ProtocolControlMessageReaderError(ProtocolControlMessageReaderError),
24     #[fail(display = "user control message read error: {}", _0)]
25     EventMessagesError(EventMessagesError),
26 }
27 
28 #[derive(Debug)]
29 pub struct MessageError {
30     pub value: MessageErrorValue,
31 }
32 
33 impl From<MessageErrorValue> for MessageError {
from(val: MessageErrorValue) -> Self34     fn from(val: MessageErrorValue) -> Self {
35         MessageError { value: val }
36     }
37 }
38 
39 impl From<BytesReadError> for MessageError {
from(error: BytesReadError) -> Self40     fn from(error: BytesReadError) -> Self {
41         MessageError {
42             value: MessageErrorValue::BytesReadError(error),
43         }
44     }
45 }
46 
47 impl From<Amf0ReadError> for MessageError {
from(error: Amf0ReadError) -> Self48     fn from(error: Amf0ReadError) -> Self {
49         MessageError {
50             value: MessageErrorValue::Amf0ReadError(error),
51         }
52     }
53 }
54 
55 impl From<ProtocolControlMessageReaderError> for MessageError {
from(error: ProtocolControlMessageReaderError) -> Self56     fn from(error: ProtocolControlMessageReaderError) -> Self {
57         MessageError {
58             value: MessageErrorValue::ProtocolControlMessageReaderError(error),
59         }
60     }
61 }
62 
63 impl From<EventMessagesError> for MessageError {
from(error: EventMessagesError) -> Self64     fn from(error: EventMessagesError) -> Self {
65         MessageError {
66             value: MessageErrorValue::EventMessagesError(error),
67         }
68     }
69 }
70 
71 impl fmt::Display for MessageError {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result72     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
73         fmt::Display::fmt(&self.value, f)
74     }
75 }
76 
77 impl Fail for MessageError {
cause(&self) -> Option<&dyn Fail>78     fn cause(&self) -> Option<&dyn Fail> {
79         self.value.cause()
80     }
81 
backtrace(&self) -> Option<&Backtrace>82     fn backtrace(&self) -> Option<&Backtrace> {
83         self.value.backtrace()
84     }
85 }
86