engineioxide_core/
protocol.rs

1use std::{fmt, str::FromStr};
2
3use serde::{Deserialize, Deserializer, Serialize, Serializer};
4
5/// The type of `transport` used to connect to the client/server.
6#[derive(Debug, Copy, Clone, PartialEq)]
7pub enum TransportType {
8    /// Polling transport
9    Polling = 0x01,
10    /// Websocket transport
11    Websocket = 0x02,
12}
13
14impl From<u8> for TransportType {
15    fn from(t: u8) -> Self {
16        match t {
17            0x01 => TransportType::Polling,
18            0x02 => TransportType::Websocket,
19            _ => panic!("unknown transport type"),
20        }
21    }
22}
23
24impl FromStr for TransportType {
25    type Err = UnknownTransportError;
26
27    fn from_str(s: &str) -> Result<Self, Self::Err> {
28        match s {
29            "websocket" => Ok(TransportType::Websocket),
30            "polling" => Ok(TransportType::Polling),
31            _ => Err(UnknownTransportError),
32        }
33    }
34}
35impl From<TransportType> for &'static str {
36    fn from(t: TransportType) -> Self {
37        match t {
38            TransportType::Polling => "polling",
39            TransportType::Websocket => "websocket",
40        }
41    }
42}
43impl From<TransportType> for String {
44    fn from(t: TransportType) -> Self {
45        match t {
46            TransportType::Polling => "polling".into(),
47            TransportType::Websocket => "websocket".into(),
48        }
49    }
50}
51
52impl Serialize for TransportType {
53    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
54    where
55        S: Serializer,
56    {
57        serializer.serialize_str((*self).into())
58    }
59}
60
61impl<'de> Deserialize<'de> for TransportType {
62    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
63    where
64        D: Deserializer<'de>,
65    {
66        let s = String::deserialize(deserializer)?;
67        Self::from_str(&s).map_err(serde::de::Error::custom)
68    }
69}
70
71/// Cannot determine the transport type to connect to the client/server.
72#[derive(Debug, Copy, Clone)]
73pub struct UnknownTransportError;
74impl std::fmt::Display for UnknownTransportError {
75    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
76        write!(f, "unknown transport type")
77    }
78}
79impl std::error::Error for UnknownTransportError {}
80
81/// == ProtocolVersion ==
82
83#[derive(Debug)]
84pub struct UnknownProtocolVersionError;
85impl std::fmt::Display for UnknownProtocolVersionError {
86    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
87        write!(f, "unknown protocol version")
88    }
89}
90impl std::error::Error for UnknownProtocolVersionError {}
91
92/// The engine.io protocol version
93#[derive(Debug, Copy, Clone, PartialEq)]
94pub enum ProtocolVersion {
95    /// The protocol version 3
96    V3 = 3,
97    /// The protocol version 4
98    V4 = 4,
99}
100
101impl fmt::Display for ProtocolVersion {
102    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
103        fmt::Display::fmt(&(*self as u8), f)
104    }
105}
106impl FromStr for ProtocolVersion {
107    type Err = UnknownProtocolVersionError;
108
109    #[cfg(feature = "v3")]
110    fn from_str(s: &str) -> Result<Self, Self::Err> {
111        match s {
112            "3" => Ok(ProtocolVersion::V3),
113            "4" => Ok(ProtocolVersion::V4),
114            _ => Err(UnknownProtocolVersionError),
115        }
116    }
117
118    #[cfg(not(feature = "v3"))]
119    fn from_str(s: &str) -> Result<Self, Self::Err> {
120        match s {
121            "4" => Ok(ProtocolVersion::V4),
122            _ => Err(UnknownProtocolVersionError),
123        }
124    }
125}
engineioxide_core/protocol.rs

engineioxide_core/
protocol.rs
