Struct BlockHeader 

pub struct BlockHeader {
    pub compressed_size: u32,
    pub original_size: u32,
}

Sizes of one framed block, shared by both framings.

Each block on the wire holds the compressed size, the original size, and the payload, in that order.

Examples

use bzip3_rs::BlockHeader;

let header = BlockHeader::new(10, 100);
let bytes = header.to_bytes();
assert_eq!(bytes.len(), BlockHeader::LEN);
assert_eq!(BlockHeader::from_bytes(&bytes), header);

Fields

compressed_size: u32

Compressed payload bytes after this header.

original_size: u32

Original bytes the payload decodes to.

Implementations

impl BlockHeader

pub const LEN: usize = 8

Length of one block header on the wire.

pub const fn new(compressed_size: u32, original_size: u32) -> Self

Build a block header from both sizes.

Examples

use bzip3_rs::BlockHeader;

let header = BlockHeader::new(10, 100);
assert_eq!(header.compressed_size, 10);
assert_eq!(header.original_size, 100);

pub fn for_block(payload_len: usize, original_len: usize) -> Result<Self>

Build the header for one encoded block.

Errors

Returns Error::BlockTooLarge when a size does not fit 32 bits.

Examples

use bzip3_rs::BlockHeader;

let header = BlockHeader::for_block(10, 100)?;
assert_eq!(header, BlockHeader::new(10, 100));

pub const fn to_bytes(self) -> [u8; 8]

Encode the header as 8 little-endian bytes.

Examples

use bzip3_rs::BlockHeader;

let bytes = BlockHeader::new(1, 2).to_bytes();
assert_eq!(bytes, [1, 0, 0, 0, 2, 0, 0, 0]);

pub const fn from_bytes(bytes: &[u8; 8]) -> Self

Decode a header from 8 wire bytes.

Examples

use bzip3_rs::BlockHeader;

let header = BlockHeader::from_bytes(&[1, 0, 0, 0, 2, 0, 0, 0]);
assert_eq!(header, BlockHeader::new(1, 2));

Trait Implementations

impl Clone for BlockHeader

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for BlockHeader

impl Debug for BlockHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for BlockHeader

impl Hash for BlockHeader

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BlockHeader

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for BlockHeader