maintain binary structure

Author: isabelatkinson

src/binary.rs

@@ -56,7 +56,7 @@ impl Binary {
         input: impl AsRef<str>,
         subtype: impl Into<Option<BinarySubtype>>,
     ) -> Result<Self> {
-        let bytes = base64::decode(input.as_ref()).map_err(Error::invalid_value)?;
+        let bytes = base64::decode(input.as_ref()).map_err(Error::binary)?;
         let subtype = match subtype.into() {
             Some(s) => s,
             None => BinarySubtype::Generic,

src/binary/vector.rs

@@ -93,12 +93,12 @@ impl PackedBitVector {
     pub fn new(vector: Vec<u8>, padding: impl Into<Option<u8>>) -> Result<Self> {
         let padding = padding.into().unwrap_or(0);
         if !(0..8).contains(&padding) {
-            return Err(Error::invalid_value(format!(
-                "padding must be within 0-7 inclusive, got {padding}"
+            return Err(Error::binary(format!(
+                "vector padding must be within 0-7 inclusive, got {padding}"
             )));
         }
         if padding != 0 && vector.is_empty() {
-            return Err(Error::invalid_value(format!(
+            return Err(Error::binary(format!(
                 "cannot specify non-zero padding if the provided vector is empty, got {padding}",
             )));
         }
@@ -114,16 +114,16 @@ impl Vector {
         let bytes = bytes.as_ref();
 
         if bytes.len() < 2 {
-            return Err(Error::invalid_value(format!(
-                "the provided bytes must have a length of at least 2, got {}",
+            return Err(Error::binary(format!(
+                "the provided vector bytes must have a length of at least 2, got {}",
                 bytes.len()
             )));
         }
 
         let d_type = bytes[0];
         let padding = bytes[1];
         if d_type != PACKED_BIT && padding != 0 {
-            return Err(Error::invalid_value(format!(
+            return Err(Error::binary(format!(
                 "padding can only be specified for a packed bit vector (data type {}), got type {}",
                 PACKED_BIT, d_type
             )));
@@ -144,7 +144,7 @@ impl Vector {
                 let mut vector = Vec::new();
                 for chunk in number_bytes.chunks(F32_BYTES) {
                     let bytes: [u8; F32_BYTES] = chunk.try_into().map_err(|_| {
-                        Error::invalid_value(format!(
+                        Error::binary(format!(
                             "f32 vector values must be {} bytes, got {:?}",
                             F32_BYTES, chunk,
                         ))
@@ -157,7 +157,7 @@ impl Vector {
                 let packed_bit_vector = PackedBitVector::new(number_bytes.to_vec(), padding)?;
                 Ok(Self::PackedBit(packed_bit_vector))
             }
-            other => Err(Error::invalid_value(format!(
+            other => Err(Error::binary(format!(
                 "unsupported vector data type: {other}"
             ))),
         }
@@ -222,7 +222,7 @@ impl TryFrom<&Binary> for Vector {
 
     fn try_from(binary: &Binary) -> Result<Self> {
         if binary.subtype != BinarySubtype::Vector {
-            return Err(Error::invalid_value(format!(
+            return Err(Error::binary(format!(
                 "expected vector binary subtype, got {:?}",
                 binary.subtype
             )));

src/error.rs

@@ -42,6 +42,13 @@ impl std::fmt::Display for Error {
 #[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub enum ErrorKind {
+    /// An error related to the [`Binary`](crate::Binary) type occurred.
+    #[error("A Binary-related error occurred: {message}")]
+    Binary {
+        /// A message describing the error.
+        message: String,
+    },
+
     /// An error related to the [`DateTime`](crate::DateTime) type occurred.
     #[error("A DateTime-related error occurred: {kind}")]
     DateTime {
@@ -113,15 +120,15 @@ impl Error {
         self
     }
 
-    pub(crate) fn malformed_bytes(message: impl ToString) -> Self {
-        ErrorKind::MalformedBytes {
+    pub(crate) fn binary(message: impl ToString) -> Self {
+        ErrorKind::Binary {
             message: message.to_string(),
         }
         .into()
     }
 
-    pub(crate) fn invalid_value(message: impl ToString) -> Self {
-        ErrorKind::InvalidValue {
+    pub(crate) fn malformed_bytes(message: impl ToString) -> Self {
+        ErrorKind::MalformedBytes {
             message: message.to_string(),
         }
         .into()