Getting closer to no-std being done

1 files changed, 36 insertions, 35 deletions

diff --git a/src/packet_content.rs b/src/packet_content.rs
index d13c663..26230e1 100644
--- a/src/packet_content.rs
+++ b/src/packet_content.rs
@@ -1,10 +1,10 @@
-use std::fmt::{Debug, Display};
 use bytes::{Buf, Bytes};
-use structdiff::{Difference, StructDiff};
-use crate::{ack::Ack, advert::Advert, anon_req::AnonReq, identity::Keystore, multipart::MultiPart, path::Path, request::Request, response::Response, text::{GroupData, GroupText, Text}, trace::Trace};
+use crate::{ack::Ack, advert::Advert, anon_req::AnonReq, multipart::MultiPart, path::Path, request::Request, response::Response, text::{GroupData, GroupText, Text}, trace::Trace};
 
-#[derive(PartialEq, Debug, Clone, Difference)]
-#[difference(expose)]
+#[cfg(feature = "std")]
+use crate::std_identity::Keystore;
+
+#[derive(PartialEq, Clone, core::fmt::Debug)]
 pub enum PacketContent {
     Request(Request),
     Response(Response),
@@ -62,23 +62,23 @@ impl PacketContent {
     }
 }
 
-impl Display for PacketContent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for PacketContent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str(self.justified_name())?;
 
         match self {
-            PacketContent::Request(c)     => std::fmt::Display::fmt(&c, f),
-            PacketContent::Response(c)   => std::fmt::Display::fmt(&c, f),
-            PacketContent::Text(c)           => std::fmt::Display::fmt(&c, f),
-            PacketContent::Ack(c)             => std::fmt::Display::fmt(&c, f),
-            PacketContent::Advert(c)       => std::fmt::Display::fmt(&c, f),
-            PacketContent::GroupText(c) => std::fmt::Display::fmt(&c, f),
-            PacketContent::GroupData(c) => std::fmt::Display::fmt(&c, f),
-            PacketContent::AnonReq(c)     => std::fmt::Display::fmt(&c, f),
-            PacketContent::Path(c)           => std::fmt::Display::fmt(&c, f),
-            PacketContent::Trace(c)         => std::fmt::Display::fmt(&c, f),
-            PacketContent::Multipart(c) => std::fmt::Display::fmt(&c, f),
-            PacketContent::Raw(c)             => std::fmt::Display::fmt(&c, f),
+            PacketContent::Request(c)     => core::fmt::Display::fmt(&c, f),
+            PacketContent::Response(c)   => core::fmt::Display::fmt(&c, f),
+            PacketContent::Text(c)           => core::fmt::Display::fmt(&c, f),
+            PacketContent::Ack(c)             => core::fmt::Display::fmt(&c, f),
+            PacketContent::Advert(c)       => core::fmt::Display::fmt(&c, f),
+            PacketContent::GroupText(c) => core::fmt::Display::fmt(&c, f),
+            PacketContent::GroupData(c) => core::fmt::Display::fmt(&c, f),
+            PacketContent::AnonReq(c)     => core::fmt::Display::fmt(&c, f),
+            PacketContent::Path(c)           => core::fmt::Display::fmt(&c, f),
+            PacketContent::Trace(c)         => core::fmt::Display::fmt(&c, f),
+            PacketContent::Multipart(c) => core::fmt::Display::fmt(&c, f),
+            PacketContent::Raw(c)             => core::fmt::Display::fmt(&c, f),
             PacketContent::Invalid                  => f.write_str("INVALID")
         }
     }
@@ -106,8 +106,7 @@ impl From<u8> for NodeType {
     }
 }
 
-#[derive(PartialEq, Debug, Clone, Difference)]
-#[difference(expose)]
+#[derive(PartialEq, Debug, Clone)]
 pub struct PeerToPeerCipher {
     pub destination: u8,
     pub source: u8,
@@ -141,6 +140,7 @@ impl From<Bytes> for PeerToPeerCipher {
 }
 
 impl PeerToPeerCipher {
+    #[cfg(feature = "std")]
     pub fn try_decrypt(&mut self, keystore: &Keystore) -> bool {  
         let decrypt = keystore.decrypt_and_id_p2p(
             self.source,
@@ -163,28 +163,29 @@ pub struct Raw {
     pub(crate) bytes: Bytes
 }
 
-impl Display for Raw {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Debug::fmt(&self, f)
+impl core::fmt::Display for Raw {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(&self, f)
     }
 }
 
+// Tests for std operations
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn node_type() {
-        assert!(NodeType::Invalid  == NodeType::from(0x00));
-        assert!(NodeType::Invalid  == NodeType::from(0xF8));
-        assert!(NodeType::Chat     == NodeType::from(0x01));
-        assert!(NodeType::Chat     == NodeType::from(0xF9));
-        assert!(NodeType::Repeater == NodeType::from(0x02));
-        assert!(NodeType::Repeater == NodeType::from(0xFA));
-        assert!(NodeType::Room     == NodeType::from(0x03));
-        assert!(NodeType::Room     == NodeType::from(0xFB));
-        assert!(NodeType::Sensor   == NodeType::from(0x04));
-        assert!(NodeType::Sensor   == NodeType::from(0xFC));
-        assert!(NodeType::Invalid  == NodeType::from(0x05));
+        assert_eq!(NodeType::Invalid,  NodeType::from(0x00));
+        assert_eq!(NodeType::Invalid,  NodeType::from(0xF8));
+        assert_eq!(NodeType::Chat,     NodeType::from(0x01));
+        assert_eq!(NodeType::Chat,     NodeType::from(0xF9));
+        assert_eq!(NodeType::Repeater, NodeType::from(0x02));
+        assert_eq!(NodeType::Repeater, NodeType::from(0xFA));
+        assert_eq!(NodeType::Room,     NodeType::from(0x03));
+        assert_eq!(NodeType::Room,     NodeType::from(0xFB));
+        assert_eq!(NodeType::Sensor,   NodeType::from(0x04));
+        assert_eq!(NodeType::Sensor,   NodeType::from(0xFC));
+        assert_eq!(NodeType::Invalid,  NodeType::from(0x05));
     }
 }
\ No newline at end of file