doc: document the missing few items (#57)

This PR is the last in the row of PRs to improve the documentation
(since now every item has docs)

Author: CommanderStorm

Cargo.toml

@@ -45,6 +45,7 @@ rand = "0.10.0"
 dead_code = "allow"
 unused_assignments = "allow"
 unused_qualifications = "warn"
+missing_docs = "warn"
 
 [lints.clippy]
 cargo = { level = "warn", priority = -1 }

benches/fastpfor_benchmark.rs

@@ -1,3 +1,5 @@
+//! Benchmark suite for `FastPFOR` compression codecs.
+
 use core::ops::Range;
 use std::hint::black_box;
 use std::io::Cursor;

build.rs

@@ -1,32 +1,39 @@
-fn main() {
-    #[cfg(feature = "cpp")]
-    {
-        use std::path::Path;
+//! Build script for `FastPFOR-rs`.
 
-        assert!(
-            Path::new("cpp/CMakeLists.txt").exists(),
-            "FastPFOR submodule not initialized. Run `git submodule update --init`."
-        );
+/// Builds the C++ `FastPFOR` library and bridge when the `cpp` feature is enabled.
+#[cfg(feature = "cpp")]
+fn build_fastpfor() {
+    use std::path::Path;
 
-        // Compile FastPFOR using CMake
-        println!("cargo:rerun-if-changed=cpp");
-        let lib_path = cmake::Config::new("cpp")
-            .define("WITH_TEST", "OFF")
-            .build()
-            .join("lib");
-        let lib_path = lib_path.to_str().unwrap();
+    assert!(
+        Path::new("cpp/CMakeLists.txt").exists(),
+        "FastPFOR submodule not initialized. Run `git submodule update --init`."
+    );
 
-        // Compile the bridge
-        println!("cargo:rerun-if-changed=src/cpp/fastpfor_bridge.h");
-        println!("cargo:rerun-if-changed=src/cpp/mod.rs");
-        cxx_build::bridge("src/cpp/mod.rs")
-            .include("cpp/headers")
-            .include("src/cpp")
-            .std("c++14")
-            .compile("fastpfor_bridge");
+    // Compile FastPFOR using CMake
+    println!("cargo:rerun-if-changed=cpp");
+    let lib_path = cmake::Config::new("cpp")
+        .define("WITH_TEST", "OFF")
+        .build()
+        .join("lib");
+    let lib_path = lib_path.to_str().unwrap();
 
-        // Link the FastPFOR library - must be done after the bridge is compiled
-        println!("cargo:rustc-link-search=native={lib_path}");
-        println!("cargo:rustc-link-lib=static=FastPFOR");
-    }
+    // Compile the bridge
+    println!("cargo:rerun-if-changed=src/cpp/fastpfor_bridge.h");
+    println!("cargo:rerun-if-changed=src/cpp/mod.rs");
+    cxx_build::bridge("src/cpp/mod.rs")
+        .include("cpp/headers")
+        .include("src/cpp")
+        .std("c++14")
+        .compile("fastpfor_bridge");
+
+    // Link the FastPFOR library - must be done after the bridge is compiled
+    println!("cargo:rustc-link-search=native={lib_path}");
+    println!("cargo:rustc-link-lib=static=FastPFOR");
+}
+
+/// Build script entry point.
+fn main() {
+    #[cfg(feature = "cpp")]
+    build_fastpfor();
 }

fuzz/fuzz_targets/fastpfor_rust.rs

@@ -1,10 +1,10 @@
 #![no_main]
 
 use std::io::Cursor;
+use std::num::NonZeroU32;
 
-use fastpfor::rust::{FastPFOR, Integer, BLOCK_SIZE_128, BLOCK_SIZE_256, DEFAULT_PAGE_SIZE};
+use fastpfor::rust::{BLOCK_SIZE_128, BLOCK_SIZE_256, DEFAULT_PAGE_SIZE, FastPFOR, Integer};
 use libfuzzer_sys::fuzz_target;
-use std::num::NonZeroU32;
 
 fuzz_target!(|data: FuzzInput| {
     let input = data.data;

src/rust/cursor.rs

@@ -1,7 +1,10 @@
 use std::io::Cursor;
 
+/// Extension trait for `Cursor<u32>` providing position increment operations.
 pub trait IncrementCursor {
+    /// Increments the cursor position by 1.
     fn increment(&mut self);
+    /// Adds `n` to the cursor position.
     fn add(&mut self, n: u32);
 }
 

src/rust/integer_compression/bitpacking.rs

@@ -1,5 +1,6 @@
 #![expect(clippy::identity_op)]
 
+/// Packs 32 integers from `input` into `output` using `bit` bits per integer.
 pub fn fast_pack(input: &[u32], inpos: usize, output: &mut [u32], outpos: usize, bit: u8) {
     match bit {
         0 => (),
@@ -1299,6 +1300,7 @@ fn fast_pack32(input: &[u32], inpos: usize, output: &mut [u32], outpos: usize) {
     output[outpos..outpos + 32].copy_from_slice(&input[inpos..inpos + 32]);
 }
 
+/// Unpacks 32 integers from `input` into `output` using `bit` bits per integer.
 pub fn fast_unpack(input: &[u32], inpos: usize, output: &mut [u32], outpos: usize, bit: u8) {
     match bit {
         0 => fast_unpack0(output, outpos),

src/rust/integer_compression/codec.rs

@@ -1,8 +1,14 @@
 use crate::rust::{FastPFOR, JustCopy, VariableByte};
 
+/// Type-erased wrapper for compression codecs.
+///
+/// Allows different codec types to be used interchangeably through a unified interface.
 pub enum Codec {
+    /// [`FastPFOR`] compression codec
     FastPFor(Box<FastPFOR>),
+    /// [`VariableByte`] compression codec
     VariableByte(VariableByte),
+    /// Pass-through codec (no compression)
     JustCopy(JustCopy),
 }
 

src/rust/integer_compression/composition.rs

@@ -3,12 +3,16 @@ use std::io::Cursor;
 use crate::rust::cursor::IncrementCursor;
 use crate::rust::{Codec, FastPForResult, Integer};
 
+/// Chains two codecs together, applying them sequentially.
+///
+/// Compresses data first with `c1`, then with `c2` on the remaining data.
 pub struct Composition {
     c1: Codec,
     c2: Codec,
 }
 
 impl Composition {
+    /// Creates a new instance of the composition codec.
     pub fn new<C1, C2>(c1: C1, c2: C2) -> Self
     where
         C1: Into<Codec>,

src/rust/integer_compression/differential/mod.rs

@@ -1,14 +1,17 @@
 use std::ops::{Add, AddAssign};
 
+/// Delta encoding/decoding utility for integer compression.
 pub struct Delta;
 
 impl Delta {
+    /// Creates a new instance
     pub fn new() -> Delta {
         Delta
     }
 
     // C++ port as it supports any type of numeric data
     // source: https://github.com/fast-pack/FastPFor/blob/49d44d94773518ef26486f7a58f8da08e8a498bb/headers/deltautil.h#L274
+    /// Applies inverse delta encoding to decompress delta-encoded data in place.
     pub fn fast_inverse_delta<T>(data: &mut [T])
     where
         T: Copy + Add<Output = T> + AddAssign,

src/rust/integer_compression/fastpfor.rs

@@ -40,8 +40,11 @@ pub struct FastPFOR {
     /// Frequency count for each bit width:
     /// `freqs[i]` = count of values needing exactly i bits
     pub freqs: [u32; 33],
+    /// Optimal number of bits chosen for the current block
     pub optimal_bits: u32,
+    /// Number of exceptions that don't fit in the optimal bit width
     pub exception_count: u32,
+    /// Maximum bit width required for any value in the block
     pub max_bits: u32,
     /// Integers per block (128 or 256)
     pub block_size: u32,