Struct LinkedByte

pub struct LinkedByte(/* private fields */);

An element in a series of Linked Bytes.

Implementations

impl LinkedByte

pub const LINK_MASK: u8 = 128u8

The link bit mask.

Use is_linked to easily check for this.

pub const VALUE_MASK: u8 = 127u8

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 = 0u8

The smallest value representable, as a u8.

Alias for ZERO_END.

pub const MAX: u8 = 127u8

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.

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.

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.

pub fn checked_add(self, rhs: Self) -> Option<Self>

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

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.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

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

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 Debug for LinkedByte

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

Formats the value using the given formatter.

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

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.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for LinkedByte

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for LinkedByte

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for LinkedByte

impl Eq for LinkedByte

impl StructuralPartialEq for LinkedByte