Fix serde module not to depend on std

Author: Gianmarco Garrisi

Cargo.toml

@@ -15,18 +15,19 @@ rust-version = "1.65.0"
 [dependencies]
 equivalent = "1.0.1"
 indexmap = {version = "2.2", features = [], default-features = false}
-serde = { version = "1", optional = true }
+serde = { version = "1", optional = true, features = ["alloc"], default-features = false }
 
 [dev-dependencies]
 serde_test = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 uuid = {version= "1", features = ["v4", "serde"] }
 hashbrown = "0.14"
+twox-hash = { version = "1.5", default-features = false }
 
 [features]
 default = ["std"]
-std = ["indexmap/std"]
+std = ["indexmap/std", "serde/std"]
 benchmarks = []
 
 [workspace]

src/double_priority_queue/mod.rs

@@ -1232,8 +1232,8 @@ where
 #[cfg(feature = "serde")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 mod serde {
-    use std::cmp::{Eq, Ord};
-    use std::hash::{BuildHasher, Hash};
+    use core::cmp::{Eq, Ord};
+    use core::hash::{BuildHasher, Hash};
 
     use serde::de::{Deserialize, Deserializer};
     use serde::ser::{Serialize, Serializer};

src/priority_queue/mod.rs

@@ -984,8 +984,8 @@ where
 #[cfg(feature = "serde")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serde")))]
 mod serde {
-    use std::cmp::{Eq, Ord};
-    use std::hash::{BuildHasher, Hash};
+    use core::cmp::{Eq, Ord};
+    use core::hash::{BuildHasher, Hash};
 
     use serde::de::{Deserialize, Deserializer};
     use serde::ser::{Serialize, Serializer};

src/store.rs

@@ -692,10 +692,11 @@ where
 mod serde {
     use crate::store::{Index, Position, Store};
 
-    use std::cmp::{Eq, Ord};
+    use core::cmp::{Eq, Ord};
+    use core::hash::{BuildHasher, Hash};
+    use core::marker::PhantomData;
+    #[cfg(feature = "std")]
     use std::collections::hash_map::RandomState;
-    use std::hash::{BuildHasher, Hash};
-    use std::marker::PhantomData;
 
     use serde::ser::{Serialize, SerializeSeq, Serializer};
 
@@ -733,13 +734,24 @@ mod serde {
         }
     }
 
+    #[cfg(feature = "std")]
     struct StoreVisitor<I, P, H = RandomState>
     where
         I: Hash + Eq,
         P: Ord,
     {
         marker: PhantomData<Store<I, P, H>>,
     }
+
+    #[cfg(not(feature = "std"))]
+    struct StoreVisitor<I, P, H>
+    where
+        I: Hash + Eq,
+        P: Ord,
+    {
+        marker: PhantomData<Store<I, P, H>>,
+    }
+
     impl<'de, I, P, H> Visitor<'de> for StoreVisitor<I, P, H>
     where
         I: Hash + Eq + Deserialize<'de>,
@@ -748,7 +760,7 @@ mod serde {
     {
         type Value = Store<I, P, H>;
 
-        fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
             write!(formatter, "A priority queue")
         }
 

tests/double_priority_queue.rs

@@ -1260,16 +1260,30 @@ mod doublepq_tests {
 mod serde_tests_basics {
     use priority_queue::DoublePriorityQueue;
     use serde_test::{assert_tokens, Token};
+
+    #[cfg(not(feature = "std"))]
+    use core::hash::BuildHasherDefault;
+    #[cfg(not(feature = "std"))]
+    use twox_hash::XxHash64;
+
     #[test]
     fn serde_empty() {
+        #[cfg(feature = "std")]
         let pq: DoublePriorityQueue<String, i32> = DoublePriorityQueue::new();
+        #[cfg(not(feature = "std"))]
+        let pq: DoublePriorityQueue<String, i32, BuildHasherDefault<XxHash64>> =
+            DoublePriorityQueue::default();
 
         assert_tokens(&pq, &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
     }
 
     #[test]
     fn serde() {
+        #[cfg(feature = "std")]
         let mut pq = DoublePriorityQueue::new();
+        #[cfg(not(feature = "std"))]
+        let mut pq: DoublePriorityQueue<&str, i32, BuildHasherDefault<XxHash64>> =
+            DoublePriorityQueue::default();
 
         pq.push("a", 1);
         pq.push("b", 2);
@@ -1317,6 +1331,11 @@ mod serde_tests_custom_structs {
     use std::time::Duration;
     use uuid::Uuid;
 
+    #[cfg(not(feature = "std"))]
+    use core::hash::BuildHasherDefault;
+    #[cfg(not(feature = "std"))]
+    use twox_hash::XxHash64;
+
     use serde::{Deserialize, Serialize};
 
     // Abusing Duration as a mutable std::time::Instant
@@ -1410,9 +1429,12 @@ mod serde_tests_custom_structs {
     fn test1() {
         println!("test1()");
 
+        #[cfg(feature = "std")]
         type PqType = DoublePriorityQueue<i32, i32>;
+        #[cfg(not(feature = "std"))]
+        type PqType = DoublePriorityQueue<i32, i32, BuildHasherDefault<XxHash64>>;
 
-        let mut pq: PqType = DoublePriorityQueue::new();
+        let mut pq: PqType = DoublePriorityQueue::default();
         pq.push(0, 0);
         pq.push(1, 1);
 
@@ -1429,9 +1451,12 @@ mod serde_tests_custom_structs {
     fn test2() {
         println!("\n\ntest2()");
 
+        #[cfg(feature = "std")]
         type PqType = DoublePriorityQueue<i32, EventComparables>;
+        #[cfg(not(feature = "std"))]
+        type PqType = DoublePriorityQueue<i32, EventComparables, BuildHasherDefault<XxHash64>>;
 
-        let mut pq: PqType = DoublePriorityQueue::new();
+        let mut pq: PqType = DoublePriorityQueue::default();
         pq.push(0, Default::default()); // Uuids will be different
         pq.push(1, Default::default());
 
@@ -1488,9 +1513,13 @@ mod serde_tests_custom_structs {
         assert_eq!(ec2, deserialized);
 
         {
+            #[cfg(feature = "std")]
             type PqType = DoublePriorityQueue<ConcreteEvent1, EventComparables>;
+            #[cfg(not(feature = "std"))]
+            type PqType =
+                DoublePriorityQueue<ConcreteEvent1, EventComparables, BuildHasherDefault<XxHash64>>;
 
-            let mut pq: PqType = DoublePriorityQueue::new();
+            let mut pq: PqType = DoublePriorityQueue::default();
             pq.push(ce1, ec1);
             pq.push(ce2, ec2);
 

tests/priority_queue.rs

@@ -1076,16 +1076,29 @@ mod pqueue_tests {
 mod serde_tests_basics {
     use priority_queue::PriorityQueue;
     use serde_test::{assert_tokens, Token};
+
+    #[cfg(not(feature = "std"))]
+    use core::hash::BuildHasherDefault;
+    #[cfg(not(feature = "std"))]
+    use twox_hash::XxHash64;
+
     #[test]
     fn serde_empty() {
+        #[cfg(feature = "std")]
         let pq: PriorityQueue<String, i32> = PriorityQueue::new();
+        #[cfg(not(feature = "std"))]
+        let pq: PriorityQueue<String, i32, BuildHasherDefault<XxHash64>> = PriorityQueue::default();
 
         assert_tokens(&pq, &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
     }
 
     #[test]
     fn serde() {
+        #[cfg(feature = "std")]
         let mut pq = PriorityQueue::new();
+        #[cfg(not(feature = "std"))]
+        let mut pq: PriorityQueue<&str, i32, BuildHasherDefault<XxHash64>> =
+            PriorityQueue::default();
 
         pq.push("a", 1);
         pq.push("b", 2);
@@ -1127,12 +1140,17 @@ mod serde_tests_basics {
 //thanks to ckaran
 #[cfg(all(feature = "serde", test))]
 mod serde_tests_custom_structs {
+    use core::cmp::{Ord, Ordering, PartialOrd};
+    use core::default::Default;
+    use core::time::Duration;
     use priority_queue::PriorityQueue;
-    use std::cmp::{Ord, Ordering, PartialOrd};
-    use std::default::Default;
-    use std::time::Duration;
     use uuid::Uuid;
 
+    #[cfg(not(feature = "std"))]
+    use core::hash::BuildHasherDefault;
+    #[cfg(not(feature = "std"))]
+    use twox_hash::XxHash64;
+
     use serde::{Deserialize, Serialize};
 
     // Abusing Duration as a mutable std::time::Instant
@@ -1226,9 +1244,12 @@ mod serde_tests_custom_structs {
     fn test1() {
         println!("test1()");
 
+        #[cfg(feature = "std")]
         type PqType = PriorityQueue<i32, i32>;
+        #[cfg(not(feature = "std"))]
+        type PqType = PriorityQueue<i32, i32, BuildHasherDefault<XxHash64>>;
 
-        let mut pq: PqType = PriorityQueue::new();
+        let mut pq: PqType = PriorityQueue::default();
         pq.push(0, 0);
         pq.push(1, 1);
 
@@ -1245,9 +1266,12 @@ mod serde_tests_custom_structs {
     fn test2() {
         println!("\n\ntest2()");
 
+        #[cfg(feature = "std")]
         type PqType = PriorityQueue<i32, EventComparables>;
+        #[cfg(not(feature = "std"))]
+        type PqType = PriorityQueue<i32, EventComparables, BuildHasherDefault<XxHash64>>;
 
-        let mut pq: PqType = PriorityQueue::new();
+        let mut pq: PqType = PriorityQueue::default();
         pq.push(0, Default::default()); // Uuids will be different
         pq.push(1, Default::default());
 
@@ -1304,9 +1328,13 @@ mod serde_tests_custom_structs {
         assert_eq!(ec2, deserialized);
 
         {
+            #[cfg(feature = "std")]
             type PqType = PriorityQueue<ConcreteEvent1, EventComparables>;
+            #[cfg(not(feature = "std"))]
+            type PqType =
+                PriorityQueue<ConcreteEvent1, EventComparables, BuildHasherDefault<XxHash64>>;
 
-            let mut pq: PqType = PriorityQueue::new();
+            let mut pq: PqType = PriorityQueue::default();
             pq.push(ce1, ec1);
             pq.push(ce2, ec2);