simplifies Serialize/Deserialize implementations for ShredType (#24601)

Cargo.lock

@@ -5023,9 +5023,8 @@ dependencies = [
  "log",
  "lru",
  "matches",
- "num-derive",
- "num-traits",
  "num_cpus",
+ "num_enum",
  "prost",
  "rand 0.7.3",
  "rand_chacha 0.2.2",

ledger/Cargo.toml

@@ -23,9 +23,8 @@ lazy_static = "1.4.0"
 libc = "0.2.124"
 log = { version = "0.4.14" }
 lru = "0.7.5"
-num-derive = "0.3"
-num-traits = "0.2"
 num_cpus = "1.13.1"
+num_enum = "0.5.4"
 prost = "0.10.0"
 rand = "0.7.0"
 rand_chacha = "0.2.2"

ledger/src/shred.rs

@@ -53,10 +53,9 @@ pub use crate::shred_stats::{ProcessShredsStats, ShredFetchStats};
 use {
     crate::{blockstore::MAX_DATA_SHREDS_PER_SLOT, erasure::Session},
     bincode::config::Options,
-    num_derive::FromPrimitive,
+    num_enum::{IntoPrimitive, TryFromPrimitive},
-    num_traits::FromPrimitive,
     rayon::{prelude::*, ThreadPool},
-    serde::{Deserialize, Deserializer, Serialize, Serializer},
+    serde::{Deserialize, Serialize},
     solana_entry::entry::{create_ticks, Entry},
     solana_measure::measure::Measure,
     solana_perf::packet::{limited_deserialize, Packet},
@@ -136,7 +135,21 @@ pub enum ShredError {
 pub type Result<T> = std::result::Result<T, ShredError>;
 
 #[repr(u8)]
-#[derive(Copy, Clone, Debug, Eq, FromPrimitive, Hash, PartialEq, AbiEnumVisitor, AbiExample)]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Eq,
+    Hash,
+    PartialEq,
+    AbiEnumVisitor,
+    AbiExample,
+    Deserialize,
+    IntoPrimitive,
+    Serialize,
+    TryFromPrimitive,
+)]
+#[serde(into = "u8", try_from = "u8")]
 pub enum ShredType {
     Data = 0b1010_0101,
     Code = 0b0101_1010,
@@ -148,26 +161,6 @@ impl Default for ShredType {
     }
 }
 
-impl Serialize for ShredType {
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        (*self as u8).serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for ShredType {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let shred_type = u8::deserialize(deserializer)?;
-        Self::from_u8(shred_type)
-            .ok_or_else(|| serde::de::Error::custom(ShredError::InvalidShredType))
-    }
-}
-
 /// A common header that is present in data and code shred headers
 #[derive(Serialize, Clone, Deserialize, Default, PartialEq, Debug)]
 pub struct ShredCommonHeader {
@@ -1110,12 +1103,12 @@ pub fn get_shred_slot_index_type(
         }
     };
 
-    let shred_type = match ShredType::from_u8(p.data[OFFSET_OF_SHRED_TYPE]) {
+    let shred_type = match ShredType::try_from(p.data[OFFSET_OF_SHRED_TYPE]) {
-        None => {
+        Err(_) => {
             stats.bad_shred_type += 1;
             return None;
         }
-        Some(shred_type) => shred_type,
+        Ok(shred_type) => shred_type,
     };
     Some((slot, index, shred_type))
 }
@@ -2013,12 +2006,13 @@ pub mod tests {
     #[test]
     fn test_shred_type_compat() {
         assert_eq!(std::mem::size_of::<ShredType>(), std::mem::size_of::<u8>());
-        assert_eq!(ShredType::from_u8(0), None);
+        assert_matches!(ShredType::try_from(0u8), Err(_));
-        assert_eq!(ShredType::from_u8(1), None);
+        assert_matches!(ShredType::try_from(1u8), Err(_));
         assert_matches!(bincode::deserialize::<ShredType>(&[0u8]), Err(_));
+        assert_matches!(bincode::deserialize::<ShredType>(&[1u8]), Err(_));
         // data shred
         assert_eq!(ShredType::Data as u8, 0b1010_0101);
-        assert_eq!(ShredType::from_u8(0b1010_0101), Some(ShredType::Data));
+        assert_eq!(ShredType::try_from(0b1010_0101), Ok(ShredType::Data));
         let buf = bincode::serialize(&ShredType::Data).unwrap();
         assert_eq!(buf, vec![0b1010_0101]);
         assert_matches!(
@@ -2027,7 +2021,7 @@ pub mod tests {
         );
         // coding shred
         assert_eq!(ShredType::Code as u8, 0b0101_1010);
-        assert_eq!(ShredType::from_u8(0b0101_1010), Some(ShredType::Code));
+        assert_eq!(ShredType::try_from(0b0101_1010), Ok(ShredType::Code));
         let buf = bincode::serialize(&ShredType::Code).unwrap();
         assert_eq!(buf, vec![0b0101_1010]);
         assert_matches!(

programs/bpf/Cargo.lock

@@ -4529,9 +4529,8 @@ dependencies = [
  "libc",
  "log",
  "lru",
- "num-derive",
- "num-traits",
  "num_cpus",
+ "num_enum",
  "prost",
  "rand 0.7.3",
  "rand_chacha 0.2.2",