fmt

Author: DyrellC

iota-streams-app-channels/src/api/tangle/mod.rs

@@ -132,7 +132,9 @@ impl MessageContent {
         }
     }
 
-    pub fn unreadable() -> Self { Self::Unreadable }
+    pub fn unreadable() -> Self {
+        Self::Unreadable
+    }
 }
 
 /// Generic unwrapped message type containing possible message contents

iota-streams-app-channels/src/api/tangle/user.rs

@@ -410,29 +410,22 @@ impl<Trans: Transport + Clone> User<Trans> {
             let preparsed = msg.parse_header()?;
             let link = preparsed.header.link.clone();
             match preparsed.header.content_type {
-                message::SIGNED_PACKET => {
-                    match self.user.handle_signed_packet(msg, MsgInfo::SignedPacket) {
-                        Ok(m) =>
-                            return Ok(m.map(|(pk, public, masked)| MessageContent::new_signed_packet(pk, public, masked))),
-                        Err(e) => {
-                            match sequenced {
-                                true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
-                                false => return Err(e)
-                            }
-                        }
+                message::SIGNED_PACKET => match self.user.handle_signed_packet(msg, MsgInfo::SignedPacket) {
+                    Ok(m) => {
+                        return Ok(m.map(|(pk, public, masked)| MessageContent::new_signed_packet(pk, public, masked)))
                     }
-                }
-                message::TAGGED_PACKET => {
-                    match self.user.handle_tagged_packet(msg, MsgInfo::TaggedPacket) {
-                        Ok(m) => return Ok(m.map(|(public, masked)| MessageContent::new_tagged_packet(public, masked))),
-                        Err(e) => {
-                            match sequenced {
-                                true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
-                                false => return Err(e)
-                            }
-                        }
-                    }
-                }
+                    Err(e) => match sequenced {
+                        true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
+                        false => return Err(e),
+                    },
+                },
+                message::TAGGED_PACKET => match self.user.handle_tagged_packet(msg, MsgInfo::TaggedPacket) {
+                    Ok(m) => return Ok(m.map(|(public, masked)| MessageContent::new_tagged_packet(public, masked))),
+                    Err(e) => match sequenced {
+                        true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
+                        false => return Err(e),
+                    },
+                },
                 message::KEYLOAD => {
                     // So long as the unwrap has not failed, we will return a blank object to
                     // inform the user that a message was present, even if the use wasn't part of
@@ -716,29 +709,22 @@ impl<Trans: Transport + Clone> User<Trans> {
             let preparsed = msg.parse_header()?;
             let link = preparsed.header.link.clone();
             match preparsed.header.content_type {
-                message::SIGNED_PACKET => {
-                    match self.user.handle_signed_packet(msg, MsgInfo::SignedPacket) {
-                        Ok(m) =>
-                            return Ok(m.map(|(pk, public, masked)| MessageContent::new_signed_packet(pk, public, masked))),
-                        Err(e) => {
-                            match sequenced {
-                                true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
-                                false => return Err(e)
-                            }
-                        }
+                message::SIGNED_PACKET => match self.user.handle_signed_packet(msg, MsgInfo::SignedPacket) {
+                    Ok(m) => {
+                        return Ok(m.map(|(pk, public, masked)| MessageContent::new_signed_packet(pk, public, masked)))
                     }
-                }
-                message::TAGGED_PACKET => {
-                    match self.user.handle_tagged_packet(msg, MsgInfo::TaggedPacket) {
-                        Ok(m) => return Ok(m.map(|(public, masked)| MessageContent::new_tagged_packet(public, masked))),
-                        Err(e) => {
-                            match sequenced {
-                                true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
-                                false => return Err(e)
-                            }
-                        }
-                    }
-                }
+                    Err(e) => match sequenced {
+                        true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
+                        false => return Err(e),
+                    },
+                },
+                message::TAGGED_PACKET => match self.user.handle_tagged_packet(msg, MsgInfo::TaggedPacket) {
+                    Ok(m) => return Ok(m.map(|(public, masked)| MessageContent::new_tagged_packet(public, masked))),
+                    Err(e) => match sequenced {
+                        true => return Ok(UnwrappedMessage::new(link, MessageContent::unreadable())),
+                        false => return Err(e),
+                    },
+                },
                 message::KEYLOAD => {
                     // So long as the unwrap has not failed, we will return a blank object to
                     // inform the user that a message was present, even if the use wasn't part of