Bit-bi-parse

Very simple library for binary printer/parser (encoding/decoding). That is, this library allows you to write/read, by offset, individual bit sequences.

Example simple printer:

	struct Sample {
		// offset: 0,   bis_size: 6
		field1: u64,
		// offset: 6,   bis_size: 32
		field2: u64,
		// offset: 38,  bis_size: 4
		field3: u64,
		// offset: 42,  bis_size: 64
		field4: u64,
		// offset: 108, bis_size: 6
		field5: u64,
	}

	#[derive(Debug)]
	struct SamplePrinterError {
		field_name: String,
		value: u64,
		max_value: u64,
	}

	impl fmt::Display for SamplePrinterError {
		fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
			write!(
				f,
				"Error: field '{}' has value {}, which exceeds the maximum value {}.",
				self.field_name, self.value, self.max_value
			)
		}
	}

	impl Error for SamplePrinterError {}


	impl TryInto<[u8; 14]> for Sample {
		type Error = Vec<&'static str>;

		fn try_into(self) -> Result<[u8; 14], Self::Error> {
			/*
				CONVERT values to bytes for passing to the 
				verification function
			*/
			let b_field1 = self.field1.to_be_bytes();
			let b_field2 = self.field2.to_be_bytes();
			let b_field3 = self.field3.to_be_bytes();
			let b_field4 = self.field4.to_be_bytes();
			let b_field5 = self.field5.to_be_bytes();
			/*
				CONVERT END
			*/

			/*
				CHECK that stored values do not go beyond the storage 
				(there are enough bits for encoding)
			*/
			let mut errors = vec![];
			if !is_in_range(6, &b_field1, b_field1.len()) {
				errors.push(SamplePrinterError{
					field_name: "field1".to_string(),
					value: field1,
					max_value: bits_to_max_hold(6) as u64,
				});
			}
			if !is_in_range(32, &b_field2, b_field2.len()) {
				errors.push(SamplePrinterError{
					field_name: "field2".to_string(),
					value: field2,
					max_value: bits_to_max_hold(32) as u64,
				});
			}
			if !is_in_range(4, &b_field3, b_field3.len()) {
				errors.push(SamplePrinterError{
					field_name: "field3".to_string(),
					value: field3,
					max_value: bits_to_max_hold(4) as u64,
				});
			}
			if !is_in_range(64, &b_field4, b_field4.len()) {
				errors.push(SamplePrinterError{
					field_name: "field4".to_string(),
					value: field4,
					max_value: bits_to_max_hold(64) as u64,
				});
			}
			if !is_in_range(6, &b_field5, b_field5.len()) {
				errors.push(SamplePrinterError{
					field_name: "field5".to_string(),
					value: field5,
					max_value: bits_to_max_hold(6) as u64,
				});
			}

			if !errors.is_empty() {
				return Err(errors);
			}
			/*
				CHECK END
			*/

			/*
				WRITE to a byte array
			*/
			let mut target = [0u8; 14];
			let mut offset = 0;

			bit_write(&mut target, offset, 6, &b_field1, b_field1.len());
			offset += 6;

			bit_write(&mut target, offset, 32, &b_field2, b_field2.len());
			offset += 32;

			bit_write(&mut target, offset, 4, &b_field3, b_field3.len());
			offset += 4;

			bit_write(&mut target, offset, 64, &b_field4, b_field4.len());
			offset += 64;

			bit_write(&mut target, offset, 6, &b_field5, b_field5.len());
			/*
				WRITE END
			*/

			Ok(target)
		}
	}

Example simple parser:

	struct Sample {
		// offset: 0,   bis_size: 6
		field1: u64,
		// offset: 6,   bis_size: 32
		field2: u64,
		// offset: 38,  bis_size: 4
		field3: u64,
		// offset: 42,  bis_size: 64
		field4: u64,
		// offset: 108, bis_size: 6
		field5: u64,
	}

	impl TryFrom<[u8; 14]> for Sample {
		type Error = ();

		fn try_from(bytes: [u8; 14]) -> Result<Self, Self::Error> {
			let mut offset = 0;

			let mut field1 = [0u8; 8];
			let b_field1_len = field1.len();

			let mut field2 = [0u8; 8];
			let b_field2_len = field2.len();
			
			let mut field3 = [0u8; 8];
			let b_field3_len = field3.len();
			
			let mut field4 = [0u8; 8];
			let b_field4_len = field4.len();
			
			let mut field5 = [0u8; 8];
			let b_field5_len = field5.len();

			bit_read(&bytes, offset, 6, &mut field1, field1_len);
			offset += 6;

			bit_read(&bytes, offset, 32, &mut field2, b_field2_len);
			offset += 32;

			bit_read(&bytes, offset, 4, &mut field3, b_field3_len);
			offset += 4;

			bit_read(&bytes, offset, 64, &mut field4, b_field4_len);
			offset += 64;

			bit_read(&bytes, offset, 6, &mut field5, b_field5_len);

			Ok(Sample {
				field1: u64::from_be_bytes(field1),
				field2: u64::from_be_bytes(field2),
				field3: u64::from_be_bytes(field3),
				field4: u64::from_be_bytes(field4),
				field5: u64::from_be_bytes(field5),
			})
		}
	}

Interesting membitcpy function. This function uses offset for the source as well. In essence, this function can be view as bidirectional lens, since only with it can both a parser and a printer be implemented:

// lets parse something

let mut target = [0u8; 2];
let source = u64::from_be_bytes([
	0b00000000, 0b00000000, 0b10011111, 0b11100000, 0b00000000, 
	0b00000000, 0b00000000, 0b00000000,
]);

let b_source = source.to_be_bytes();

let source_bit_offset = 16;
membitcpy(
	&mut target, 
	4, 
	11, 
	&b_source, 
	source_bit_offset,
);

assert_eq!(target, [0b00001001, 0b11111110]);

// now lets print what we parse

let mut new_target = [0u8; 8];

membitcpy(
	&mut new_target,
	8*2,
	11,
	&target,
	4,
);

// here we can see that our new target equivalent 
// our primary source 

assert_eq!(new_target, b_source);

Similar libraries:

godcodehunter/bit-bi-parse

ErrorLooks like something went wrong!

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Languages

Error
Looks like something went wrong!

Packages