implement 'BitStore' for usize (#41)

Author: danieleades

arithmetic-coding-core/src/bitstore.rs

@@ -5,8 +5,6 @@ use std::ops::{Add, AddAssign, Div, Mul, Shl, ShlAssign, Sub};
 pub trait BitStore:
     Shl<u32, Output = Self>
     + ShlAssign<u32>
-    + Sized
-    + From<u32>
     + Sub<Output = Self>
     + Add<Output = Self>
     + Mul<Output = Self>
@@ -46,3 +44,4 @@ macro_rules! impl_bitstore {
 impl_bitstore! {u32}
 impl_bitstore! {u64}
 impl_bitstore! {u128}
+impl_bitstore! {usize}

examples/sherlock.rs

@@ -24,27 +24,28 @@ impl StringModel {
 pub struct Error(char);
 
 impl Model for StringModel {
+    type B = usize;
     type Symbol = char;
     type ValueError = Error;
 
-    fn probability(&self, symbol: Option<&Self::Symbol>) -> Result<Range<u32>, Error> {
+    fn probability(&self, symbol: Option<&Self::Symbol>) -> Result<Range<usize>, Error> {
         if let Some(char) = symbol {
             match self.alphabet.iter().position(|x| x == char) {
-                Some(index) => Ok((index as u32)..(index as u32 + 1)),
+                Some(index) => Ok(index..(index + 1)),
                 None => Err(Error(*char)),
             }
         } else {
-            let alphabet_length = self.alphabet.len() as u32;
+            let alphabet_length = self.alphabet.len();
             Ok(alphabet_length..(alphabet_length + 1))
         }
     }
 
-    fn symbol(&self, value: u32) -> Option<Self::Symbol> {
-        self.alphabet.get(value as usize).copied()
+    fn symbol(&self, value: usize) -> Option<Self::Symbol> {
+        self.alphabet.get(value).copied()
     }
 
-    fn max_denominator(&self) -> u32 {
-        self.alphabet.len() as u32 + 1
+    fn max_denominator(&self) -> usize {
+        self.alphabet.len() + 1
     }
 }
 

fenwick-model/src/simple.rs

@@ -29,7 +29,7 @@ impl Builder {
         Self { model }
     }
 
-    pub fn panic_on_saturation(mut self) -> Self {
+    pub const fn panic_on_saturation(mut self) -> Self {
         self.model.panic_on_saturation = true;
         self
     }

src/encoder.rs

@@ -81,7 +81,10 @@ where
         }
     }
 
-    /// todo
+    /// Create an encoder from an existing [`State`].
+    ///
+    /// This is useful for manually chaining a shared buffer through multiple
+    /// encoders.
     pub const fn with_state(state: State<'a, M::B, W>, model: M) -> Self {
         Self { model, state }
     }
@@ -185,7 +188,10 @@ where
     B: BitStore,
     W: BitWrite,
 {
-    /// todo
+    /// Manually construct a [`State`].
+    ///
+    /// Normally this would be done automatically using the [`Encoder::new`]
+    /// method.
     pub fn new(precision: u32, output: &'a mut W) -> Self {
         let low = B::ZERO;
         let high = B::ONE << precision;
@@ -228,7 +234,6 @@ where
                 self.high <<= 1;
                 self.low <<= 1;
             } else {
-                // self.low >= self.half()
                 self.emit(true)?;
                 self.low = (self.low - self.half()) << 1;
                 self.high = (self.high - self.half()) << 1;
@@ -253,7 +258,11 @@ where
         Ok(())
     }
 
-    /// todo
+    /// Flush the internal buffer and write all remaining bits to the output
+    ///
+    /// # Errors
+    ///
+    /// This method can fail if the output cannot be written to
     pub fn flush(&mut self) -> io::Result<()> {
         self.pending += 1;
         if self.low <= self.quarter() {

tests/sherlock.rs

@@ -15,27 +15,27 @@ pub struct StringModel;
 pub struct Error(char);
 
 impl Model for StringModel {
+    type B = usize;
     type Symbol = char;
     type ValueError = Error;
 
     fn probability(&self, symbol: Option<&Self::Symbol>) -> Result<Range<Self::B>, Error> {
         if let Some(char) = symbol {
             match ALPHABET.chars().position(|x| &x == char) {
-                Some(index) => Ok((index as u32)..(index as u32 + 1)),
+                Some(index) => Ok(index..(index + 1)),
                 None => Err(Error(*char)),
             }
         } else {
-            let alphabet_length = ALPHABET.len() as u32;
-            Ok(alphabet_length..(alphabet_length + 1))
+            Ok(ALPHABET.len()..(ALPHABET.len() + 1))
         }
     }
 
     fn symbol(&self, value: Self::B) -> Option<Self::Symbol> {
-        ALPHABET.chars().nth(value as usize)
+        ALPHABET.chars().nth(value)
     }
 
     fn max_denominator(&self) -> Self::B {
-        ALPHABET.len() as u32 + 1
+        ALPHABET.len() + 1
     }
 }