style: formatting

Author: noamteyssier

src/error.rs

@@ -26,14 +26,14 @@ pub enum Error {
 #[derive(thiserror::Error, Debug)]
 pub enum HeaderError {
     /// The magic number in the header does not match the expected value
-    /// 
+    ///
     /// # Arguments
     /// * `u32` - The invalid magic number that was found
     #[error("Invalid magic number: {0}")]
     InvalidMagicNumber(u32),
 
     /// The format version in the header is not supported
-    /// 
+    ///
     /// # Arguments
     /// * `u8` - The unsupported version number that was found
     #[error("Invalid format version: {0}")]
@@ -44,7 +44,7 @@ pub enum HeaderError {
     InvalidReservedBytes,
 
     /// The size of the data does not match what was specified in the header
-    /// 
+    ///
     /// # Arguments
     /// * First `usize` - The actual number of bytes provided
     /// * Second `usize` - The expected number of bytes according to the header
@@ -60,7 +60,7 @@ pub enum ReadError {
     IncompatibleFile,
 
     /// The file appears to be truncated or corrupted
-    /// 
+    ///
     /// # Arguments
     /// * `usize` - The byte position where the truncation was detected
     #[error(
@@ -69,7 +69,7 @@ pub enum ReadError {
     FileTruncation(usize),
 
     /// Attempted to access a record index that is beyond the available range
-    /// 
+    ///
     /// # Arguments
     /// * First `usize` - The requested record index
     /// * Second `usize` - The maximum available record index
@@ -81,15 +81,15 @@ pub enum ReadError {
 #[derive(thiserror::Error, Debug)]
 pub enum WriteError {
     /// The length of the sequence being written does not match what was specified in the header
-    /// 
+    ///
     /// # Fields
     /// * `expected` - The sequence length specified in the header
     /// * `got` - The actual length of the sequence being written
     #[error("Sequence length ({got}) does not match the header ({expected})")]
     UnexpectedSequenceLength { expected: u32, got: usize },
 
     /// The sequence contains invalid nucleotide characters
-    /// 
+    ///
     /// # Arguments
     /// * `String` - Description of the invalid nucleotides found
     #[error("Invalid nucleotides found in sequence: {0}")]

src/header.rs

@@ -10,25 +10,25 @@ use std::io::{Read, Write};
 use crate::{error::Result, HeaderError};
 
 /// Current magic number: "BSEQ" in ASCII (in little-endian byte order)
-/// 
+///
 /// This is used to identify binary sequence files and verify file integrity.
 const MAGIC: u32 = 0x51455342;
 
 /// Current format version of the binary sequence file format
-/// 
+///
 /// This version number allows for future format changes while maintaining backward compatibility.
 const FORMAT: u8 = 1;
 
 /// Size of the header in bytes
-/// 
+///
 /// The header has a fixed size to ensure consistent reading and writing of binary sequence files.
 pub const SIZE_HEADER: usize = 32;
 
 /// Header structure for binary sequence files
-/// 
+///
 /// The `BinseqHeader` contains metadata about the binary sequence data stored in a file,
 /// including format information, sequence lengths, and space for future extensions.
-/// 
+///
 /// The total size of this structure is 32 bytes, with a fixed layout to ensure
 /// consistent reading and writing across different platforms.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -60,17 +60,17 @@ pub struct BinseqHeader {
 }
 impl BinseqHeader {
     /// Creates a new header with the specified sequence length
-    /// 
+    ///
     /// This constructor initializes a standard header with the given sequence length,
     /// setting the magic number and format version to their default values.
     /// The extended sequence length (xlen) is set to 0.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `slen` - The length of sequences in the file
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// A new `BinseqHeader` instance
     pub fn new(slen: u32) -> Self {
         Self {
@@ -83,17 +83,17 @@ impl BinseqHeader {
     }
 
     /// Creates a new header with both primary and extended sequence lengths
-    /// 
+    ///
     /// This constructor initializes a header for files that contain both primary
     /// and secondary sequence data, such as quality scores or annotations.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `slen` - The length of primary sequences in the file
     /// * `xlen` - The length of secondary/extended sequences in the file
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// A new `BinseqHeader` instance with extended sequence information
     pub fn new_extended(slen: u32, xlen: u32) -> Self {
         Self {
@@ -106,21 +106,21 @@ impl BinseqHeader {
     }
 
     /// Parses a header from a fixed-size byte array
-    /// 
+    ///
     /// This method validates the magic number and format version before constructing
     /// a header instance. If validation fails, appropriate errors are returned.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `buffer` - A byte array of exactly `SIZE_HEADER` bytes containing the header data
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// * `Ok(BinseqHeader)` - A valid header parsed from the buffer
     /// * `Err(Error)` - If the buffer contains invalid header data
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if:
     /// * The magic number is incorrect
     /// * The format version is unsupported
@@ -150,22 +150,22 @@ impl BinseqHeader {
     }
 
     /// Parses a header from an arbitrarily sized buffer
-    /// 
+    ///
     /// This method extracts the header from the beginning of a buffer that may be larger
     /// than the header size. It checks that the buffer is at least as large as the header
     /// before attempting to parse it.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `buffer` - A byte slice containing at least `SIZE_HEADER` bytes
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// * `Ok(BinseqHeader)` - A valid header parsed from the buffer
     /// * `Err(Error)` - If the buffer is too small or contains invalid header data
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if:
     /// * The buffer is smaller than `SIZE_HEADER`
     /// * The header data is invalid (see `from_bytes` for validation details)
@@ -179,21 +179,21 @@ impl BinseqHeader {
     }
 
     /// Writes the header to a writer
-    /// 
+    ///
     /// This method serializes the header to its binary representation and writes it
     /// to the provided writer.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `writer` - Any type that implements the `Write` trait
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// * `Ok(())` - If the header was successfully written
     /// * `Err(Error)` - If writing to the writer failed
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if writing to the writer fails (typically an I/O error).
     pub fn write_bytes<W: Write>(&self, writer: &mut W) -> Result<()> {
         let mut buffer = [0u8; SIZE_HEADER];
@@ -207,21 +207,21 @@ impl BinseqHeader {
     }
 
     /// Reads a header from a reader
-    /// 
+    ///
     /// This method reads exactly `SIZE_HEADER` bytes from the provided reader and
     /// parses them into a header structure.
-    /// 
+    ///
     /// # Arguments
-    /// 
+    ///
     /// * `reader` - Any type that implements the `Read` trait
-    /// 
+    ///
     /// # Returns
-    /// 
+    ///
     /// * `Ok(BinseqHeader)` - A valid header read from the reader
     /// * `Err(Error)` - If reading from the reader failed or the header data is invalid
-    /// 
+    ///
     /// # Errors
-    /// 
+    ///
     /// Returns an error if:
     /// * Reading from the reader fails (typically an I/O error)
     /// * The header data is invalid (see `from_bytes` for validation details)

src/lib.rs

@@ -1,42 +1,42 @@
 #![doc = include_str!("../README.md")]
-//! 
+//!
 //! # Overview
-//! 
+//!
 //! The `binseq` library provides efficient tools for working with binary-encoded
 //! nucleotide sequences. It offers:
-//! 
+//!
 //! - Compact 2-bit encoding of nucleotide sequences
 //! - Memory-mapped file access for efficient reading
 //! - Parallel processing capabilities
 //! - Configurable policies for handling invalid nucleotides
 //! - Support for both single and paired-end sequences
-//! 
+//!
 //! # Core Components
-//! 
+//!
 //! - [`BinseqWriter`]: Writes sequences to binary format
 //! - [`MmapReader`]: Reads sequences using memory mapping
 //! - [`BinseqHeader`]: Defines file format and sequence lengths
 //! - [`Policy`]: Configures invalid nucleotide handling
 //! - [`ParallelProcessor`]: Enables parallel sequence processing
-//! 
+//!
 //! # Example
-//! 
+//!
 //! ```
 //! use binseq::{BinseqHeader, BinseqWriterBuilder, MmapReader, Policy, Result};
 //! use std::io::Cursor;
-//! 
+//!
 //! fn main() -> Result<()> {
 //!     // Create a writer for sequences of length 100
 //!     let header = BinseqHeader::new(100);
-//! 
+//!
 //!     let mut writer = BinseqWriterBuilder::default()
 //!         .header(header)
 //!         .build(Cursor::new(Vec::new()))?;
-//! 
+//!
 //!     // Write a sequence
 //!     let sequence = b"ACGT".repeat(25); // 100 nucleotides
 //!     writer.write_nucleotides(0, &sequence)?;
-//! 
+//!
 //!     Ok(())
 //! }
 //! ```