fmt code

getong · getong · commit 9563f417eba4 · 2025-03-05T11:49:06.000+08:00
diff --git a/src/adapters/framed_tcp.rs b/src/adapters/framed_tcp.rs
@@ -121,7 +121,7 @@ impl Remote for RemoteResource {
                 }
                 Err(err) => {
                     log::error!("TCP receive error: {}", err);
-                    break ReadStatus::Disconnected // should not happen
+                    break ReadStatus::Disconnected; // should not happen
                 }
             }
         }
@@ -144,13 +144,13 @@ impl Remote for RemoteResource {
                 Ok(bytes_sent) => {
                     total_bytes_sent += bytes_sent;
                     if total_bytes_sent == total_bytes {
-                        break SendStatus::Sent
+                        break SendStatus::Sent;
                     }
                 }
                 Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => continue,
                 Err(err) => {
                     log::error!("TCP receive error: {}", err);
-                    break SendStatus::ResourceNotFound // should not happen
+                    break SendStatus::ResourceNotFound; // should not happen
                 }
             }
         }
diff --git a/src/adapters/tcp.rs b/src/adapters/tcp.rs
@@ -177,7 +177,7 @@ impl Remote for RemoteResource {
                 }
                 Err(err) => {
                     log::error!("TCP receive error: {}", err);
-                    break ReadStatus::Disconnected // should not happen
+                    break ReadStatus::Disconnected; // should not happen
                 }
             }
         }
@@ -195,7 +195,7 @@ impl Remote for RemoteResource {
                 Ok(bytes_sent) => {
                     total_bytes_sent += bytes_sent;
                     if total_bytes_sent == data.len() {
-                        break SendStatus::Sent
+                        break SendStatus::Sent;
                     }
                 }
                 Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => continue,
@@ -204,7 +204,7 @@ impl Remote for RemoteResource {
                 // a Event::Disconnection will be generated later.
                 Err(err) => {
                     log::error!("TCP receive error: {}", err);
-                    break SendStatus::ResourceNotFound // should not happen
+                    break SendStatus::ResourceNotFound; // should not happen
                 }
             }
         }
@@ -238,7 +238,7 @@ pub fn check_stream_ready(stream: &TcpStream) -> PendingStatus {
     // A multiplatform non-blocking way to determine if the TCP stream is connected:
     // Extracted from: https://github.com/tokio-rs/mio/issues/1486
     if let Ok(Some(_)) = stream.take_error() {
-        return PendingStatus::Disconnected
+        return PendingStatus::Disconnected;
     }
     match stream.peer_addr() {
         Ok(_) => PendingStatus::Ready,
diff --git a/src/adapters/udp.rs b/src/adapters/udp.rs
@@ -193,11 +193,11 @@ impl Remote for RemoteResource {
                 }
                 Err(ref err) if err.kind() == ErrorKind::ConnectionRefused => {
                     // Avoid ICMP generated error to be logged
-                    break ReadStatus::WaitNextEvent
+                    break ReadStatus::WaitNextEvent;
                 }
                 Err(err) => {
                     log::error!("UDP receive error: {}", err);
-                    break ReadStatus::WaitNextEvent // Should not happen
+                    break ReadStatus::WaitNextEvent; // Should not happen
                 }
             }
         }
@@ -262,15 +262,15 @@ impl LocalResource {
                     };
 
                     if !ingress_addresses.contains(&ingress_ip) {
-                        continue
+                        continue;
                     }
 
                     fn convert_sockaddr(addr: SockaddrStorage) -> Option<SocketAddr> {
                         if let Some(addr) = addr.as_sockaddr_in() {
-                            return Some(SocketAddr::V4((*addr).into()))
+                            return Some(SocketAddr::V4((*addr).into()));
                         }
                         if let Some(addr) = addr.as_sockaddr_in6() {
-                            return Some(SocketAddr::V6((*addr).into()))
+                            return Some(SocketAddr::V6((*addr).into()));
                         }
                         None
                     }
@@ -417,7 +417,7 @@ impl Local for LocalResource {
         #[cfg(target_os = "linux")]
         if let Some(ingress_addresses) = &self.ingress_addresses {
             self.accept_filtered(ingress_addresses, accept_remote);
-            return
+            return;
         }
 
         let buffer: MaybeUninit<[u8; MAX_LOCAL_PAYLOAD_LEN]> = MaybeUninit::uninit();
@@ -464,7 +464,7 @@ fn send_packet(data: &[u8], send_method: impl Fn(&[u8]) -> io::Result<usize>) ->
             }
             Err(err) => {
                 log::error!("UDP send error: {}", err);
-                break SendStatus::ResourceNotFound // should not happen
+                break SendStatus::ResourceNotFound; // should not happen
             }
         }
     }
diff --git a/src/adapters/ws.rs b/src/adapters/ws.rs
@@ -139,7 +139,7 @@ impl Remote for RemoteResource {
 
                             #[cfg(not(target_os = "windows"))]
                             if let Err(err) = _peek_result {
-                                break Self::io_error_to_read_status(&err)
+                                break Self::io_error_to_read_status(&err);
                             }
                         }
                         Message::Close(_) => break ReadStatus::Disconnected,
@@ -148,7 +148,7 @@ impl Remote for RemoteResource {
                     Err(Error::Io(ref err)) => break Self::io_error_to_read_status(err),
                     Err(err) => {
                         log::error!("WS receive error: {}", err);
-                        break ReadStatus::Disconnected // should not happen
+                        break ReadStatus::Disconnected; // should not happen
                     }
                 },
                 RemoteState::Handshake(_) => unreachable!(),
@@ -174,7 +174,7 @@ impl Remote for RemoteResource {
                         Err(Error::Capacity(_)) => break SendStatus::MaxPacketSizeExceeded,
                         Err(err) => {
                             log::error!("WS send error: {}", err);
-                            break SendStatus::ResourceNotFound // should not happen
+                            break SendStatus::ResourceNotFound; // should not happen
                         }
                     }
                 }
@@ -195,7 +195,7 @@ impl Remote for RemoteResource {
                     if tcp_status != PendingStatus::Ready {
                         // TCP handshake not ready yet.
                         *pending = Some(PendingHandshake::Connect(url, stream));
-                        return tcp_status
+                        return tcp_status;
                     }
                     let stream_backup = stream.clone();
                     match ws_connect(url, stream) {
diff --git a/src/events.rs b/src/events.rs
@@ -152,16 +152,16 @@ where E: Send + 'static
         self.enque_timers();
 
         if let Ok(priority_event) = self.priority_receiver.try_recv() {
-            return Some(priority_event)
+            return Some(priority_event);
         }
         else if let Some(next_instant) = self.timers.iter().next() {
             if *next_instant.0 <= Instant::now() {
                 let instant = *next_instant.0;
-                return self.timers.remove(&instant)
+                return self.timers.remove(&instant);
             }
         }
         else if let Ok(event) = self.receiver.try_recv() {
-            return Some(event)
+            return Some(event);
         }
 
         None
diff --git a/src/network.rs b/src/network.rs
@@ -391,7 +391,7 @@ impl NetworkProcessor {
             let now = Instant::now();
             self.process_poll_event(Some(timeout), &mut event_callback);
             if now.elapsed() > timeout {
-                break
+                break;
             }
         }
     }
diff --git a/src/network/poll.rs b/src/network/poll.rs
@@ -80,7 +80,7 @@ impl Poll {
                             }
                         }
                     }
-                    break
+                    break;
                 }
                 Err(ref err) if err.kind() == ErrorKind::Interrupted => continue,
                 Err(ref err) => panic!("{}: No error here", err),
diff --git a/src/network/resource_id.rs b/src/network/resource_id.rs
@@ -51,7 +51,8 @@ impl ResourceId {
 
         Self {
             id: ((adapter_id as usize) << Self::ADAPTER_ID_POS)
-                | resource_type | (base_value << Self::BASE_VALUE_POS),
+                | resource_type
+                | (base_value << Self::BASE_VALUE_POS),
         }
     }
 
diff --git a/src/node.rs b/src/node.rs
@@ -305,7 +305,7 @@ impl<S: Send + 'static> NodeListener<S> {
             log::trace!("Read from cache {:?}", net_event);
             event_callback(NodeEvent::Network(net_event));
             if !self.handler.is_running() {
-                return
+                return;
             }
         }
 
@@ -417,7 +417,7 @@ impl<S: Send + 'static> NodeListener<S> {
                     let mut event_callback = multiplexed.lock().expect(OTHER_THREAD_ERR);
                     event_callback(NodeEvent::Network(net_event));
                     if !handler.is_running() {
-                        return
+                        return;
                     }
                 }
 
diff --git a/src/util/encoding.rs b/src/util/encoding.rs
@@ -41,15 +41,15 @@ impl Decoder {
                     decoded_callback(decoded);
                     if !not_decoded.is_empty() {
                         next_data = not_decoded;
-                        continue
+                        continue;
                     }
                     else {
-                        break
+                        break;
                     }
                 }
             }
             self.stored.extend_from_slice(next_data);
-            break
+            break;
         }
     }
 
@@ -68,7 +68,7 @@ impl Decoder {
                 }
                 else {
                     // We still don't know the size (data was too small)
-                    return None
+                    return None;
                 }
             }
         };
diff --git a/src/util/thread.rs b/src/util/thread.rs
@@ -45,7 +45,7 @@ impl<T: Send + 'static> NamespacedThread<T> {
     /// Returns the inner `T` value if never was joined, `None` otherwise
     pub fn try_join(&mut self) -> Option<T> {
         if self.join_handle.is_some() {
-            return Some(self.join())
+            return Some(self.join());
         }
         None
     }

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ impl Remote for RemoteResource {`
`121`	`121`	`}`
`122`	`122`	`Err(err) => {`
`123`	`123`	`log::error!("TCP receive error: {}", err);`
`124`		`- break ReadStatus::Disconnected // should not happen`
	`124`	`+ break ReadStatus::Disconnected; // should not happen`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`	`}`
`@@ -144,13 +144,13 @@ impl Remote for RemoteResource {`
`144`	`144`	`Ok(bytes_sent) => {`
`145`	`145`	`total_bytes_sent += bytes_sent;`
`146`	`146`	`if total_bytes_sent == total_bytes {`
`147`		`- break SendStatus::Sent`
	`147`	`+ break SendStatus::Sent;`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`	`Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => continue,`
`151`	`151`	`Err(err) => {`
`152`	`152`	`log::error!("TCP receive error: {}", err);`
`153`		`- break SendStatus::ResourceNotFound // should not happen`
	`153`	`+ break SendStatus::ResourceNotFound; // should not happen`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ impl Remote for RemoteResource {`
`177`	`177`	`}`
`178`	`178`	`Err(err) => {`
`179`	`179`	`log::error!("TCP receive error: {}", err);`
`180`		`- break ReadStatus::Disconnected // should not happen`
	`180`	`+ break ReadStatus::Disconnected; // should not happen`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`	`}`
`@@ -195,7 +195,7 @@ impl Remote for RemoteResource {`
`195`	`195`	`Ok(bytes_sent) => {`
`196`	`196`	`total_bytes_sent += bytes_sent;`
`197`	`197`	`if total_bytes_sent == data.len() {`
`198`		`- break SendStatus::Sent`
	`198`	`+ break SendStatus::Sent;`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`	`Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => continue,`
`@@ -204,7 +204,7 @@ impl Remote for RemoteResource {`
`204`	`204`	`// a Event::Disconnection will be generated later.`
`205`	`205`	`Err(err) => {`
`206`	`206`	`log::error!("TCP receive error: {}", err);`
`207`		`- break SendStatus::ResourceNotFound // should not happen`
	`207`	`+ break SendStatus::ResourceNotFound; // should not happen`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`	`}`
`@@ -238,7 +238,7 @@ pub fn check_stream_ready(stream: &TcpStream) -> PendingStatus {`
`238`	`238`	`// A multiplatform non-blocking way to determine if the TCP stream is connected:`
`239`	`239`	`// Extracted from: https://github.com/tokio-rs/mio/issues/1486`
`240`	`240`	`if let Ok(Some(_)) = stream.take_error() {`
`241`		`- return PendingStatus::Disconnected`
	`241`	`+ return PendingStatus::Disconnected;`
`242`	`242`	`}`
`243`	`243`	`match stream.peer_addr() {`
`244`	`244`	`Ok(_) => PendingStatus::Ready,`
Original file line number	Diff line number	Diff line change
`@@ -193,11 +193,11 @@ impl Remote for RemoteResource {`
`193`	`193`	`}`
`194`	`194`	`Err(ref err) if err.kind() == ErrorKind::ConnectionRefused => {`
`195`	`195`	`// Avoid ICMP generated error to be logged`
`196`		`- break ReadStatus::WaitNextEvent`
	`196`	`+ break ReadStatus::WaitNextEvent;`
`197`	`197`	`}`
`198`	`198`	`Err(err) => {`
`199`	`199`	`log::error!("UDP receive error: {}", err);`
`200`		`- break ReadStatus::WaitNextEvent // Should not happen`
	`200`	`+ break ReadStatus::WaitNextEvent; // Should not happen`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`	`}`
`@@ -262,15 +262,15 @@ impl LocalResource {`
`262`	`262`	`};`
`263`	`263`
`264`	`264`	`if !ingress_addresses.contains(&ingress_ip) {`
`265`		`- continue`
	`265`	`+ continue;`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`fn convert_sockaddr(addr: SockaddrStorage) -> Option<SocketAddr> {`
`269`	`269`	`if let Some(addr) = addr.as_sockaddr_in() {`
`270`		`- return Some(SocketAddr::V4((*addr).into()))`
	`270`	`+ return Some(SocketAddr::V4((*addr).into()));`
`271`	`271`	`}`
`272`	`272`	`if let Some(addr) = addr.as_sockaddr_in6() {`
`273`		`- return Some(SocketAddr::V6((*addr).into()))`
	`273`	`+ return Some(SocketAddr::V6((*addr).into()));`
`274`	`274`	`}`
`275`	`275`	`None`
`276`	`276`	`}`
`@@ -417,7 +417,7 @@ impl Local for LocalResource {`
`417`	`417`	`#[cfg(target_os = "linux")]`
`418`	`418`	`if let Some(ingress_addresses) = &self.ingress_addresses {`
`419`	`419`	`self.accept_filtered(ingress_addresses, accept_remote);`
`420`		`- return`
	`420`	`+ return;`
`421`	`421`	`}`
`422`	`422`
`423`	`423`	`let buffer: MaybeUninit<[u8; MAX_LOCAL_PAYLOAD_LEN]> = MaybeUninit::uninit();`
`@@ -464,7 +464,7 @@ fn send_packet(data: &[u8], send_method: impl Fn(&[u8]) -> io::Result<usize>) ->`
`464`	`464`	`}`
`465`	`465`	`Err(err) => {`
`466`	`466`	`log::error!("UDP send error: {}", err);`
`467`		`- break SendStatus::ResourceNotFound // should not happen`
	`467`	`+ break SendStatus::ResourceNotFound; // should not happen`
`468`	`468`	`}`
`469`	`469`	`}`
`470`	`470`	`}`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ impl Remote for RemoteResource {`
`139`	`139`
`140`	`140`	`#[cfg(not(target_os = "windows"))]`
`141`	`141`	`if let Err(err) = _peek_result {`
`142`		`- break Self::io_error_to_read_status(&err)`
	`142`	`+ break Self::io_error_to_read_status(&err);`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`	`Message::Close(_) => break ReadStatus::Disconnected,`
`@@ -148,7 +148,7 @@ impl Remote for RemoteResource {`
`148`	`148`	`Err(Error::Io(ref err)) => break Self::io_error_to_read_status(err),`
`149`	`149`	`Err(err) => {`
`150`	`150`	`log::error!("WS receive error: {}", err);`
`151`		`- break ReadStatus::Disconnected // should not happen`
	`151`	`+ break ReadStatus::Disconnected; // should not happen`
`152`	`152`	`}`
`153`	`153`	`},`
`154`	`154`	`RemoteState::Handshake(_) => unreachable!(),`
`@@ -174,7 +174,7 @@ impl Remote for RemoteResource {`
`174`	`174`	`Err(Error::Capacity(_)) => break SendStatus::MaxPacketSizeExceeded,`
`175`	`175`	`Err(err) => {`
`176`	`176`	`log::error!("WS send error: {}", err);`
`177`		`- break SendStatus::ResourceNotFound // should not happen`
	`177`	`+ break SendStatus::ResourceNotFound; // should not happen`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`	`}`
`@@ -195,7 +195,7 @@ impl Remote for RemoteResource {`
`195`	`195`	`if tcp_status != PendingStatus::Ready {`
`196`	`196`	`// TCP handshake not ready yet.`
`197`	`197`	`*pending = Some(PendingHandshake::Connect(url, stream));`
`198`		`- return tcp_status`
	`198`	`+ return tcp_status;`
`199`	`199`	`}`
`200`	`200`	`let stream_backup = stream.clone();`
`201`	`201`	`match ws_connect(url, stream) {`
Original file line number	Diff line number	Diff line change
`@@ -152,16 +152,16 @@ where E: Send + 'static`
`152`	`152`	`self.enque_timers();`
`153`	`153`
`154`	`154`	`if let Ok(priority_event) = self.priority_receiver.try_recv() {`
`155`		`- return Some(priority_event)`
	`155`	`+ return Some(priority_event);`
`156`	`156`	`}`
`157`	`157`	`else if let Some(next_instant) = self.timers.iter().next() {`
`158`	`158`	`if *next_instant.0 <= Instant::now() {`
`159`	`159`	`let instant = *next_instant.0;`
`160`		`- return self.timers.remove(&instant)`
	`160`	`+ return self.timers.remove(&instant);`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`	`else if let Ok(event) = self.receiver.try_recv() {`
`164`		`- return Some(event)`
	`164`	`+ return Some(event);`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`None`
Original file line number	Diff line number	Diff line change
`@@ -391,7 +391,7 @@ impl NetworkProcessor {`
`391`	`391`	`let now = Instant::now();`
`392`	`392`	`self.process_poll_event(Some(timeout), &mut event_callback);`
`393`	`393`	`if now.elapsed() > timeout {`
`394`		`- break`
	`394`	`+ break;`
`395`	`395`	`}`
`396`	`396`	`}`
`397`	`397`	`}`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ impl Poll {`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`}`
`83`		`- break`
	`83`	`+ break;`
`84`	`84`	`}`
`85`	`85`	`Err(ref err) if err.kind() == ErrorKind::Interrupted => continue,`
`86`	`86`	`Err(ref err) => panic!("{}: No error here", err),`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,8 @@ impl ResourceId {`
`51`	`51`
`52`	`52`	`Self {`
`53`	`53`	`id: ((adapter_id as usize) << Self::ADAPTER_ID_POS)`
`54`		`- \| resource_type \| (base_value << Self::BASE_VALUE_POS),`
	`54`	`+ \| resource_type`
	`55`	`+ \| (base_value << Self::BASE_VALUE_POS),`
`55`	`56`	`}`
`56`	`57`	`}`
`57`	`58`
Original file line number	Diff line number	Diff line change
`@@ -305,7 +305,7 @@ impl<S: Send + 'static> NodeListener<S> {`
`305`	`305`	`log::trace!("Read from cache {:?}", net_event);`
`306`	`306`	`event_callback(NodeEvent::Network(net_event));`
`307`	`307`	`if !self.handler.is_running() {`
`308`		`- return`
	`308`	`+ return;`
`309`	`309`	`}`
`310`	`310`	`}`
`311`	`311`
`@@ -417,7 +417,7 @@ impl<S: Send + 'static> NodeListener<S> {`
`417`	`417`	`let mut event_callback = multiplexed.lock().expect(OTHER_THREAD_ERR);`
`418`	`418`	`event_callback(NodeEvent::Network(net_event));`
`419`	`419`	`if !handler.is_running() {`
`420`		`- return`
	`420`	`+ return;`
`421`	`421`	`}`
`422`	`422`	`}`
`423`	`423`
Original file line number	Diff line number	Diff line change
`@@ -41,15 +41,15 @@ impl Decoder {`
`41`	`41`	`decoded_callback(decoded);`
`42`	`42`	`if !not_decoded.is_empty() {`
`43`	`43`	`next_data = not_decoded;`
`44`		`- continue`
	`44`	`+ continue;`
`45`	`45`	`}`
`46`	`46`	`else {`
`47`		`- break`
	`47`	`+ break;`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`self.stored.extend_from_slice(next_data);`
`52`		`- break`
	`52`	`+ break;`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`@@ -68,7 +68,7 @@ impl Decoder {`
`68`	`68`	`}`
`69`	`69`	`else {`
`70`	`70`	`// We still don't know the size (data was too small)`
`71`		`- return None`
	`71`	`+ return None;`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`	`};`