swap bool out for more descriptive new type on checksum API

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "async-io-typed"
-version = "2.0.0"
+version = "3.0.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Adapts any AsyncRead or AsyncWrite type to send serde compatible types"

src/duplex.rs

@@ -1,6 +1,6 @@
 use crate::read::{AsyncReadState, AsyncReadTyped, ChecksumReadState};
 use crate::write::{AsyncWriteState, AsyncWriteTyped, MessageFeatures};
-use crate::{Error, PROTOCOL_VERSION};
+use crate::{ChecksumEnabled, Error, PROTOCOL_VERSION};
 use futures_core::Stream;
 use futures_io::{AsyncRead, AsyncWrite};
 use futures_util::{Sink, SinkExt};
@@ -34,7 +34,7 @@ impl<RW: AsyncRead + AsyncWrite + Unpin, T: Serialize + DeserializeOwned + Unpin
     /// if both the reader and the writer enable it. If either one disables it, then no checking is performed.**
     ///
     /// Be careful, large size limits might create a vulnerability to a Denial of Service attack.
-    pub fn new_with_limit(rw: RW, size_limit: u64, checksum_enabled: bool) -> Self {
+    pub fn new_with_limit(rw: RW, size_limit: u64, checksum_enabled: ChecksumEnabled) -> Self {
         Self {
             rw: Some(rw),
             read_state: AsyncReadState::ReadingVersion {
@@ -48,22 +48,18 @@ impl<RW: AsyncRead + AsyncWrite + Unpin, T: Serialize + DeserializeOwned + Unpin
             },
             write_buffer: Vec::new(),
             primed_values: VecDeque::new(),
-            checksum_read_state: if checksum_enabled {
-                ChecksumReadState::Yes
-            } else {
-                ChecksumReadState::No
-            },
+            checksum_read_state: checksum_enabled.into(),
             message_features: MessageFeatures {
                 size_limit,
-                checksum_enabled,
+                checksum_enabled: checksum_enabled.into(),
             },
         }
     }
 
     /// Creates a duplex typed reader and writer, initializing it with a default size limit of 1 MB per message.
     /// Checksums are used to validate that messages arrived without corruption. **The checksum will only be used
     /// if both the reader and the writer enable it. If either one disables it, then no checking is performed.**
-    pub fn new(rw: RW, checksum_enabled: bool) -> Self {
+    pub fn new(rw: RW, checksum_enabled: ChecksumEnabled) -> Self {
         Self::new_with_limit(rw, 1024_u64.pow(2), checksum_enabled)
     }
 

src/lib.rs

@@ -74,6 +74,37 @@ pub enum Error {
     ChecksumHandshakeFailed { checksum_value: u8 },
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ChecksumEnabled {
+    Yes,
+    No,
+}
+
+impl From<bool> for ChecksumEnabled {
+    fn from(value: bool) -> Self {
+        if value {
+            ChecksumEnabled::Yes
+        } else {
+            ChecksumEnabled::No
+        }
+    }
+}
+
+impl From<ChecksumEnabled> for bool {
+    fn from(value: ChecksumEnabled) -> Self {
+        value == ChecksumEnabled::Yes
+    }
+}
+
+impl From<ChecksumEnabled> for ChecksumReadState {
+    fn from(value: ChecksumEnabled) -> Self {
+        match value {
+            ChecksumEnabled::Yes => ChecksumReadState::Yes,
+            ChecksumEnabled::No => ChecksumReadState::No,
+        }
+    }
+}
+
 fn bincode_options(size_limit: u64) -> impl Options {
     // Two of these are defaults, so you might say this is over specified. I say it's future proof, as
     // bincode default changes won't introduce accidental breaking changes.

src/read.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Error, CHECKSUM_DISABLED, CHECKSUM_ENABLED, PROTOCOL_VERSION, U16_MARKER, U32_MARKER,
-    U64_MARKER, ZST_MARKER,
+    ChecksumEnabled, Error, CHECKSUM_DISABLED, CHECKSUM_ENABLED, PROTOCOL_VERSION, U16_MARKER,
+    U32_MARKER, U64_MARKER, ZST_MARKER,
 };
 use bincode::Options;
 use futures_core::Stream;
@@ -89,7 +89,7 @@ impl<R: AsyncRead + Unpin, T: Serialize + DeserializeOwned + Unpin> AsyncReadTyp
     /// Creates a typed reader, initializing it with the given size limit specified in bytes.
     ///
     /// Be careful, large limits might create a vulnerability to a Denial of Service attack.
-    pub fn new_with_limit(raw: R, size_limit: u64, checksum_enabled: bool) -> Self {
+    pub fn new_with_limit(raw: R, size_limit: u64, checksum_enabled: ChecksumEnabled) -> Self {
         Self {
             raw,
             size_limit,
@@ -98,17 +98,13 @@ impl<R: AsyncRead + Unpin, T: Serialize + DeserializeOwned + Unpin> AsyncReadTyp
                 version_in_progress_assigned: 0,
             },
             item_buffer: Vec::new(),
-            checksum_read_state: if checksum_enabled {
-                ChecksumReadState::Yes
-            } else {
-                ChecksumReadState::No
-            },
+            checksum_read_state: checksum_enabled.into(),
             _phantom: PhantomData,
         }
     }
 
     /// Creates a typed reader, initializing it with a default size limit of 1 MB.
-    pub fn new(raw: R, checksum_enabled: bool) -> Self {
+    pub fn new(raw: R, checksum_enabled: ChecksumEnabled) -> Self {
         Self::new_with_limit(raw, 1024u64.pow(2), checksum_enabled)
     }
 

src/tests.rs

@@ -131,7 +131,7 @@ fn basic_channel(max_size_per_write: usize) -> (BasicChannelSender, BasicChannel
 #[tokio::test]
 async fn bad_protocol_version() {
     let (mut sender, receiver) = basic_channel(1024);
-    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, false);
+    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, ChecksumEnabled::No);
     // Intentionally send a message with a bad checksum
     let sent_value = 5;
     let mut message = Vec::from(0u64.to_le_bytes());
@@ -154,7 +154,7 @@ async fn bad_protocol_version() {
 #[tokio::test]
 async fn bad_checksum_enabled_value() {
     let (mut sender, receiver) = basic_channel(1024);
-    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, false);
+    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, ChecksumEnabled::No);
     // Intentionally send a message with a bad checksum
     let sent_value = 5;
     const BAD_CHECKSUM_ENABLED_VALUE: u8 = 42;
@@ -177,7 +177,7 @@ async fn bad_checksum_enabled_value() {
 #[tokio::test]
 async fn checksum_ignored() {
     let (mut sender, receiver) = basic_channel(1024);
-    let mut typed_receiver = AsyncReadTyped::new(receiver, false);
+    let mut typed_receiver = AsyncReadTyped::new(receiver, ChecksumEnabled::No);
     // Intentionally send a message with a bad checksum
     let sent_value = 5;
     let mut message = Vec::from(PROTOCOL_VERSION.to_le_bytes());
@@ -193,7 +193,7 @@ async fn checksum_ignored() {
 #[tokio::test]
 async fn checksum_unavailable() {
     let (mut sender, receiver) = basic_channel(1024);
-    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, true);
+    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, ChecksumEnabled::Yes);
     assert!(typed_receiver.checksum_enabled());
     // Send two message without checksums.
     const SENT_VALUE: u8 = 5;
@@ -218,7 +218,7 @@ async fn checksum_unavailable() {
 #[tokio::test]
 async fn checksum_used() {
     let (mut sender, receiver) = basic_channel(1024);
-    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, true);
+    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, ChecksumEnabled::Yes);
     // Intentionally send a message with a bad checksum
     const SENT_VALUE: u8 = 5;
     const SENT_VALUE_CHECKSUM: u64 = 10536747468361244917;
@@ -251,7 +251,7 @@ async fn checksum_used() {
 #[tokio::test]
 async fn checksum_unused() {
     let (mut sender, receiver) = basic_channel(1024);
-    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, true);
+    let mut typed_receiver = AsyncReadTyped::<_, u8>::new(receiver, ChecksumEnabled::Yes);
     // Send two messages with no checksum
     const SENT_VALUE: u8 = 5;
     const SENT_VALUE_2: u8 = 20;
@@ -273,7 +273,7 @@ async fn checksum_unused() {
 #[tokio::test]
 async fn checksum_sent() {
     let (sender, mut receiver) = basic_channel(1024);
-    let mut typed_sender = AsyncWriteTyped::new(sender, true);
+    let mut typed_sender = AsyncWriteTyped::new(sender, ChecksumEnabled::Yes);
     const SENT_VALUE: u8 = 5;
     const SENT_VALUE_CHECKSUM: u64 = 10536747468361244917;
     typed_sender.send(SENT_VALUE).await.unwrap();
@@ -297,7 +297,7 @@ async fn checksum_sent() {
 #[tokio::test]
 async fn checksum_not_sent() {
     let (sender, mut receiver) = basic_channel(1024);
-    let mut typed_sender = AsyncWriteTyped::new(sender, false);
+    let mut typed_sender = AsyncWriteTyped::new(sender, ChecksumEnabled::No);
     const SENT_VALUE: u8 = 5;
     typed_sender.send(SENT_VALUE).await.unwrap();
     const SENT_VALUE_2: u8 = 20;
@@ -387,8 +387,8 @@ fn make_channel<T: DeserializeOwned + Serialize + Unpin>(
 ) {
     let (sender, receiver) = basic_channel(max_size_per_write);
     (
-        Some(AsyncWriteTyped::new(sender, sender_checksum_enabled)),
-        AsyncReadTyped::new(receiver, receiver_checksum_enabled),
+        Some(AsyncWriteTyped::new(sender, sender_checksum_enabled.into())),
+        AsyncReadTyped::new(receiver, receiver_checksum_enabled.into()),
     )
 }
 
@@ -511,10 +511,13 @@ async fn hello_world_tokio_tcp() {
             .await
             .unwrap()
             .compat(),
-        true,
+        ChecksumEnabled::Yes,
     );
     let (server_stream, _address) = accept_fut.await.unwrap();
-    let mut server_stream = Some(DuplexStreamTyped::new(server_stream.compat_write(), true));
+    let mut server_stream = Some(DuplexStreamTyped::new(
+        server_stream.compat_write(),
+        ChecksumEnabled::Yes,
+    ));
     let message = "Hello, world!".as_bytes().to_vec();
     let fut = start_send_helper(server_stream.take().unwrap(), message.clone());
     assert_eq!(client_stream.next().await.unwrap().unwrap(), message);

src/write.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Error, CHECKSUM_DISABLED, CHECKSUM_ENABLED, PROTOCOL_VERSION, U16_MARKER, U32_MARKER,
-    U64_MARKER, ZST_MARKER,
+    ChecksumEnabled, Error, CHECKSUM_DISABLED, CHECKSUM_ENABLED, PROTOCOL_VERSION, U16_MARKER,
+    U32_MARKER, U64_MARKER, ZST_MARKER,
 };
 use bincode::Options;
 use futures_io::AsyncWrite;
@@ -223,7 +223,7 @@ impl<W: AsyncWrite + Unpin, T: Serialize + DeserializeOwned + Unpin> AsyncWriteT
     /// if both the reader and the writer enable it. If either one disables it, then no checking is performed.**
     ///
     /// Be careful, large size limits might create a vulnerability to a Denial of Service attack.
-    pub fn new_with_limit(raw: W, size_limit: u64, checksum_enabled: bool) -> Self {
+    pub fn new_with_limit(raw: W, size_limit: u64, checksum_enabled: ChecksumEnabled) -> Self {
         Self {
             raw: Some(raw),
             write_buffer: Vec::new(),
@@ -233,7 +233,7 @@ impl<W: AsyncWrite + Unpin, T: Serialize + DeserializeOwned + Unpin> AsyncWriteT
             },
             message_features: MessageFeatures {
                 size_limit,
-                checksum_enabled,
+                checksum_enabled: checksum_enabled.into(),
             },
             primed_values: VecDeque::new(),
         }
@@ -242,7 +242,7 @@ impl<W: AsyncWrite + Unpin, T: Serialize + DeserializeOwned + Unpin> AsyncWriteT
     /// Creates a typed writer, initializing it with a default size limit of 1 MB per message.
     /// Checksums are used to validate that messages arrived without corruption. **The checksum will only be used
     /// if both the reader and the writer enable it. If either one disables it, then no checking is performed.**
-    pub fn new(raw: W, checksum_enabled: bool) -> Self {
+    pub fn new(raw: W, checksum_enabled: ChecksumEnabled) -> Self {
         Self::new_with_limit(raw, 1024u64.pow(2), checksum_enabled)
     }