Remove unnecessary macros

Author: slowli

matterdb/src/macros.rs

@@ -17,97 +17,3 @@ macro_rules! concat_keys {
         buf
     });
 }
-
-/// Implements `BinaryKey` trait for any type that implements `BinaryValue`.
-#[macro_export]
-macro_rules! impl_binary_key_for_binary_value {
-    ($type:ty) => {
-        impl matterdb::BinaryKey for $type {
-            fn size(&self) -> usize {
-                matterdb::BinaryValue::to_bytes(self).len()
-            }
-
-            fn write(&self, buffer: &mut [u8]) -> usize {
-                let mut bytes = matterdb::BinaryValue::to_bytes(self);
-                buffer.swap_with_slice(&mut bytes);
-                bytes.len()
-            }
-
-            fn read(buffer: &[u8]) -> Self::Owned {
-                // `unwrap` is safe because only this code uses for
-                // serialize and deserialize these keys.
-                <Self as matterdb::BinaryValue>::from_bytes(buffer.into()).unwrap()
-            }
-        }
-    };
-}
-
-/// Hex conversions for the given `BinaryValue`.
-///
-/// Implements `hex::FromHex` and `hex::ToHex` conversions for the given `BinaryValue` and uses them in
-/// the implementation of the following traits:
-///
-/// `FromStr`, `Display`, `Serialize`, `Deserialize`.
-///
-/// Pay attention that macro uses `serde_str` under the hood.
-#[macro_export]
-macro_rules! impl_serde_hex_for_binary_value {
-    ($name:ident) => {
-        impl hex::ToHex for $name {
-            fn encode_hex<T: std::iter::FromIterator<char>>(&self) -> T {
-                use $crate::BinaryValue;
-                BinaryValue::to_bytes(self).encode_hex()
-            }
-
-            fn encode_hex_upper<T: std::iter::FromIterator<char>>(&self) -> T {
-                use $crate::BinaryValue;
-                BinaryValue::to_bytes(self).encode_hex_upper()
-            }
-        }
-
-        impl hex::FromHex for $name {
-            type Error = $crate::_reexports::Error;
-
-            fn from_hex<T: AsRef<[u8]>>(v: T) -> Result<Self, Self::Error> {
-                use $crate::BinaryValue;
-
-                let bytes = Vec::<u8>::from_hex(v)?;
-                <Self as BinaryValue>::from_bytes(bytes.into()).map_err(From::from)
-            }
-        }
-
-        impl std::fmt::Display for $name {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                use hex::ToHex;
-                write!(f, "{}", <Self as ToHex>::encode_hex::<String>(self))
-            }
-        }
-
-        impl std::str::FromStr for $name {
-            type Err = $crate::_reexports::Error;
-
-            fn from_str(s: &str) -> Result<Self, Self::Err> {
-                use hex::FromHex;
-                <Self as FromHex>::from_hex(s)
-            }
-        }
-
-        impl<'de> serde::Deserialize<'de> for $name {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: serde::de::Deserializer<'de>,
-            {
-                serde_str::deserialize(deserializer)
-            }
-        }
-
-        impl serde::Serialize for $name {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                serde_str::serialize(self, serializer)
-            }
-        }
-    };
-}