Struct bigbit::linkedbytes::LinkedByte

#[repr(transparent)]pub struct LinkedByte(_);

An element in a series of Linked Bytes.

Implementations

impl LinkedByte

pub const LINK_MASK: u8

The link bit mask.

Use is_linked to easily check for this.

pub const VALUE_MASK: u8

The value bit mask.

Use value to easily check for this.

pub const ZERO_END: Self

The zero value as an endpoint (no follow-up bytes expected).

pub const ZERO_LINK: Self

The zero value as a linked byte (one or more follow-up bytes expected).

pub const MIN: u8

The smallest value representable, as a u8.

Alias for ZERO_END.

pub const MAX: u8

The largest value representable, as a u8.

The value is 127, since the individual Linked Bytes are 7-bit, plus the link/end flag.

pub const fn is_linked(self) -> bool

Returns true if the byte is linked to a following byte, false otherwise.

The opposite of is_end.

pub const fn is_end(self) -> bool

Returns true if the byte is not linked to a following byte (i.e. is an endpoint), false otherwise.

The opposite of is_linked.

pub const fn value(self) -> u8

Returns the value of the linked byte, in the range from 0 to 127, inclusively.

The main use for this is performing arithmetic with linked bytes.

#[must_use = "this is not an in-place operation"]pub const fn into_linked(self) -> Self

Sets the link bit to true (linked state).

pub fn make_linked(&mut self)

Converts self into the linked state in place.

#[must_use = "this is not an in-place operation"]pub const fn into_end(self) -> Self

Sets the link bit to false (endpoint state).

pub fn make_end(&mut self)

Converts self into the linked state in place.

#[must_use = "this is not an in-place operation"]pub fn checked_add(self, rhs: Self) -> Option<Self>

Performs checked addition. None is returned if the result overflows the limit of 127.

#[must_use = "this is not an in-place operation"]pub fn add_with_carry(self, rhs: Self) -> (Self, bool)

Performs checked wrapping addition. Unlike checked_add, this method returns a tuple, in which the first value is the result, which wraps over if the result overflows the limit of 127, and the second value is whether the overflow actually occurred.

#[must_use = "this is not an in-place operation"]pub fn checked_sub(self, rhs: Self) -> Option<Self>

Performs checked subtraction. None is returned if the result underflows the limit of 0.

#[must_use = "this is not an in-place operation"]pub fn sub_with_borrow(self, rhs: Self) -> (Self, bool)

Performs checked wrapping subtraction. Unlike checked_sub, this method returns a tuple, in which the first value is the result, which wraps over if the result underflows the limit of 0, and the second value is whether the overflow actually occurred.

pub const fn into_inner(self) -> u8

Consumes the value and unwraps it into its inner u8, retaining the link bit if it's set.

Use into_int7 if you need only the value without the link bit, which is usually the case.

pub const fn into_int7(self) -> u8

Consumes the value and unwraps it into its inner 7-bit integer, i.e. dropping the link bit if it's set.

Use into_inner if you need the unmodified value with the link bit unmodified.

Trait Implementations

impl Clone for LinkedByte

fn clone(&self) -> LinkedByte

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for LinkedByte

impl Debug for LinkedByte

fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for LinkedByte

impl From<(u8, bool)> for LinkedByte

fn from(op: (u8, bool)) -> Self

Constructs either a linked or an endpoint byte depending on the second argument.

The most significant bit is silently dropped.

impl From<LinkedByte> for u8

fn from(op: LinkedByte) -> Self

Consumes the byte and unwraps it into its inner u8, retaining the link bit if it's set.

impl From<u8> for LinkedByte

fn from(op: u8) -> Self

Constructs an endpoint byte from a u8.

The most significant bit is silently dropped. Use into_linked to convert the result into a linked byte if you actually want to initialize it like that.

impl FromIterator<LinkedByte> for LBNum

fn from_iter<T: IntoIterator<Item = LinkedByte>>(op: T) -> Self

Converts an iterator over linked bytes into an LBNum. Little-endian byte order is assumed, regardless of platform.

If any of the bytes except for the last one are endpoints (most significant bit cleared), they are converted into linked (most significant bit set), and if the last byte is linked, it's converted into and endpoint.

If possible, use TryFrom or from_sequence instead.

impl FromIterator<LinkedByte> for LBSequence

#[must_use]fn from_iter<T: IntoIterator<Item = LinkedByte>>(op: T) -> Self

Converts an iterator over linked bytes into an LBSequence. Little-endian byte order is assumed, regardless of platform.

impl Ord for LinkedByte

fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<LinkedByte> for LinkedByte

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<LinkedByte> for LinkedByte

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for LinkedByte

impl StructuralPartialEq for LinkedByte