Struct bigbit::linkedbytes::LBNum

pub struct LBNum(_);

A number in the Linked Bytes format, capable of storing arbitrarily large non-negative integers.

See the module-level documentation for more.

Methods

impl LBNum

pub const ZERO: Self

The zero value.

This does not allocate memory.

#[must_use]pub fn num_bytes(&self) -> usize

The amount of bytes used in the number.

pub fn increment(&mut self)

Increments the value.

pub fn decrement(&mut self)

Decrements the value.

Panics

If the value was 0, a panic is produced. Use checked_decrement to properly handle such a situation.

pub fn make_zero(&mut self)

Converts the number into 0 without deallocating memory.

This is useful for buffers used for converting a collection of primitive integers into derivatives of LBNum, namely in the FromIterator implementation of LBString.

pub fn checked_decrement(&mut self) -> bool

Decrements the value, returning true if the decrement did anything and false if self was zero.

#[must_use]pub const fn inner(&self) -> &LBSequence

Returns an immutable reference to the inner sequence.

Use this to locate bytes at arbitrary indicies.

#[must_use]pub fn into_inner(self) -> LBSequence

Consumes the number and returns its inner sequence.

pub fn iter_le(
    &self
) -> impl Iterator<Item = LinkedByte> + DoubleEndedIterator + '_

Returns an iterator over the linked bytes, in little-endian byte order.

pub fn iter_be(
    &self
) -> impl Iterator<Item = LinkedByte> + DoubleEndedIterator + '_

Returns an iterator over the linked bytes, in big-endian byte order.

pub fn from_sequence(op: LBSequence) -> Self

Creates an LBNum from an LBSequence, correcting any and all incorrect bytes into their valid state. 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.

pub fn check_slice(op: &[LinkedByte]) -> bool

Checks whether the operand is a compliant LB sequence.

See InvalidLBSequence for reasons why it might not be compliant.

pub fn fix_in_place(op: &mut [LinkedByte])

Makes a slice of LinkedBytes suitable for storage in a HBNum by marking the last byte as an endpoint and the rest as linked ones.

impl LBNum

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

Performs checked subtraction. Returns None if the result underflowed 0, or the result wrapped in Some otherwise.

impl LBNum

pub fn into_string_with_radix(self, radix: u8) -> String

Converts a Linked Bytes number into a string with an arbitrary radix (base), from 2 to 36 inclusively.

All alphabetic characters in the result are uppercase — use make_ascii_lowercase if you want LowerHex-style formatting.

Panics

Passing a radix less than 2 or greater than 36 results an immediate panic, even if the value is 0.

impl LBNum

#[must_use = "this is an expensive non-in-place operation"]pub fn logb(self, base: LBNum) -> Self

Consumes self and returns the logarithm of the given base.

Trait Implementations

impl<'_> Add<&'_ LBNum> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self

Performs the + operation.

impl Add<LBNum> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl Add<LBNum> for u8

type Output = LBNum

The resulting type after applying the + operator.

fn add(self, rhs: LBNum) -> LBNum

Performs the + operation.

impl Add<LBNum> for u16

type Output = LBNum

The resulting type after applying the + operator.

fn add(self, rhs: LBNum) -> LBNum

Performs the + operation.

impl Add<LBNum> for u32

type Output = LBNum

The resulting type after applying the + operator.

fn add(self, rhs: LBNum) -> LBNum

Performs the + operation.

impl Add<LBNum> for u64

type Output = LBNum

The resulting type after applying the + operator.

fn add(self, rhs: LBNum) -> LBNum

Performs the + operation.

impl Add<LBNum> for u128

type Output = LBNum

The resulting type after applying the + operator.

fn add(self, rhs: LBNum) -> LBNum

Performs the + operation.

impl Add<LBNum> for usize

type Output = LBNum

The resulting type after applying the + operator.

fn add(self, rhs: LBNum) -> LBNum

Performs the + operation.

impl<'_> Add<LBNumRef<'_>> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: LBNumRef) -> Self

Performs the + operation.

impl Add<u128> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Self

Performs the + operation.

impl Add<u16> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self

Performs the + operation.

impl Add<u32> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self

Performs the + operation.

impl Add<u64> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self

Performs the + operation.

impl Add<u8> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self

Performs the + operation.

impl Add<usize> for LBNum

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self

Performs the + operation.

impl<'_> AddAssign<&'_ LBNum> for LBNum

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl AddAssign<LBNum> for LBNum

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<LBNum> for u8

fn add_assign(&mut self, rhs: LBNum)

Performs the += operation.

impl AddAssign<LBNum> for u16

fn add_assign(&mut self, rhs: LBNum)

Performs the += operation.

impl AddAssign<LBNum> for u32

fn add_assign(&mut self, rhs: LBNum)

Performs the += operation.

impl AddAssign<LBNum> for u64

fn add_assign(&mut self, rhs: LBNum)

Performs the += operation.

impl AddAssign<LBNum> for u128

fn add_assign(&mut self, rhs: LBNum)

Performs the += operation.

impl AddAssign<LBNum> for usize

fn add_assign(&mut self, rhs: LBNum)

Performs the += operation.

impl<'_> AddAssign<LBNumRef<'_>> for LBNum

fn add_assign(&mut self, rhs: LBNumRef)

Performs the += operation.

impl AddAssign<u128> for LBNum

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for LBNum

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for LBNum

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for LBNum

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for LBNum

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddAssign<usize> for LBNum

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl AsRef<[LinkedByte]> for LBNum

fn as_ref(&self) -> &[LinkedByte]

Performs the conversion.

impl Binary for LBNum

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

Formats the value using the given formatter.

impl Borrow<[LinkedByte]> for LBNum

fn borrow(&self) -> &[LinkedByte]

Immutably borrows from an owned value.

impl Clone for LBNum

fn clone(&self) -> LBNum

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LBNum

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

Formats the value using the given formatter.

impl Display for LBNum

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

Formats the value using the given formatter.

impl<'_> Div<&'_ LBNum> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self

Performs integer division.

Panics

Dividing by 0 triggers an immediate panic.

impl Div<LBNum> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs integer division.

Panics

Dividing by 0 triggers an immediate panic.

impl Div<u128> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> Self

Performs the / operation.

impl Div<u16> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self

Performs the / operation.

impl Div<u32> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self

Performs the / operation.

impl Div<u64> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self

Performs the / operation.

impl Div<u8> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self

Performs the / operation.

impl Div<usize> for LBNum

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self

Performs the / operation.

impl<'_> DivAssign<&'_ LBNum> for LBNum

fn div_assign(&mut self, rhs: &Self)

Performs integer division in place.

Panics

Dividing by 0 triggers an immediate panic.

impl DivAssign<LBNum> for LBNum

fn div_assign(&mut self, rhs: Self)

Performs integer division in place.

Panics

Dividing by 0 triggers an immediate panic.

impl DivAssign<u128> for LBNum

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl DivAssign<u16> for LBNum

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for LBNum

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for LBNum

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for LBNum

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl DivAssign<usize> for LBNum

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<'_> DivRem<&'_ LBNum> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The type for the remainder.

fn div_rem(self, rhs: &Self) -> (Self, Self)

Performs combined integer division and remainder calculation.

Panics

Dividing by 0 triggers an immediate panic.

impl DivRem<LBNum> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The type for the remainder.

fn div_rem(self, rhs: Self) -> (Self, Self)

Performs combined integer division and remainder calculation.

Panics

Dividing by 0 triggers an immediate panic.

impl DivRem<u128> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem(self, rhs: u128) -> (Self, Self)

Performs combined quotient and remainder calculation.

impl DivRem<u16> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem(self, rhs: u16) -> (Self, Self)

Performs combined quotient and remainder calculation.

impl DivRem<u32> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem(self, rhs: u32) -> (Self, Self)

Performs combined quotient and remainder calculation.

impl DivRem<u64> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem(self, rhs: u64) -> (Self, Self)

Performs combined quotient and remainder calculation.

impl DivRem<u8> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem(self, rhs: u8) -> (Self, Self)

Performs combined quotient and remainder calculation.

impl DivRem<usize> for LBNum

type Quotient = Self

The type for the quotient.

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem(self, rhs: usize) -> (Self, Self)

Performs combined quotient and remainder calculation.

impl<'_> DivRemAssign<&'_ LBNum> for LBNum

type Remainder = Self

The type for the remainder.

fn div_rem_assign(&mut self, rhs: &Self) -> Self

Performs in-place integer division combined with returning the remainder.

Panics

Dividing by 0 triggers an immediate panic.

impl DivRemAssign<LBNum> for LBNum

type Remainder = Self

The type for the remainder.

fn div_rem_assign(&mut self, rhs: Self) -> Self

Performs in-place integer division combined with returning the remainder.

Panics

Dividing by 0 triggers an immediate panic.

impl DivRemAssign<u128> for LBNum

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem_assign(&mut self, rhs: u128) -> Self

Performs combined quotient and remainder calculation, returning the remainder and setting the left operand to the quotient.

impl DivRemAssign<u16> for LBNum

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem_assign(&mut self, rhs: u16) -> Self

Performs combined quotient and remainder calculation, returning the remainder and setting the left operand to the quotient.

impl DivRemAssign<u32> for LBNum

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem_assign(&mut self, rhs: u32) -> Self

Performs combined quotient and remainder calculation, returning the remainder and setting the left operand to the quotient.

impl DivRemAssign<u64> for LBNum

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem_assign(&mut self, rhs: u64) -> Self

Performs combined quotient and remainder calculation, returning the remainder and setting the left operand to the quotient.

impl DivRemAssign<u8> for LBNum

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem_assign(&mut self, rhs: u8) -> Self

Performs combined quotient and remainder calculation, returning the remainder and setting the left operand to the quotient.

impl DivRemAssign<usize> for LBNum

type Remainder = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn div_rem_assign(&mut self, rhs: usize) -> Self

Performs combined quotient and remainder calculation, returning the remainder and setting the left operand to the quotient.

impl Eq for LBNum

impl<'a> From<&'a LBNum> for LBNumRef<'a>

fn from(op: &'a LBNum) -> Self

Performs the conversion.

impl From<u128> for LBNum

fn from(op: u128) -> Self

Performs the conversion.

impl From<u16> for LBNum

fn from(op: u16) -> Self

Performs the conversion.

impl From<u32> for LBNum

fn from(op: u32) -> Self

Performs the conversion.

impl From<u64> for LBNum

fn from(op: u64) -> Self

Performs the conversion.

impl From<u8> for LBNum

fn from(op: u8) -> Self

Performs the conversion.

impl From<usize> for LBNum

fn from(op: usize) -> Self

Performs the conversion.

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 LowerHex for LBNum

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

Formats the value using the given formatter.

impl Mul<LBNum> for LBNum

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Multiplies self by another LBNum. This will consume rhs.

impl Mul<u128> for LBNum

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> Self

Performs the * operation.

impl Mul<u16> for LBNum

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self

Performs the * operation.

impl Mul<u32> for LBNum

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self

Performs the * operation.

impl Mul<u64> for LBNum

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self

Performs the * operation.

impl Mul<u8> for LBNum

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self

Performs the * operation.

impl Mul<usize> for LBNum

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self

Performs the * operation.

impl MulAssign<LBNum> for LBNum

fn mul_assign(&mut self, rhs: Self)

Multiplies self by another LBNum in place. This will consume rhs.

impl MulAssign<u128> for LBNum

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl MulAssign<u16> for LBNum

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for LBNum

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for LBNum

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for LBNum

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl MulAssign<usize> for LBNum

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl Octal for LBNum

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

Formats the value using the given formatter.

impl Ord for LBNum

fn cmp(&self, rhs: &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<LBNum> for LBNum

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

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

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

This method tests for !=.

impl PartialEq<LBNum> for u8

fn eq(&self, rhs: &LBNum) -> bool

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

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

This method tests for !=.

impl PartialEq<LBNum> for u16

fn eq(&self, rhs: &LBNum) -> bool

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

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

This method tests for !=.

impl PartialEq<LBNum> for u32

fn eq(&self, rhs: &LBNum) -> bool

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

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

This method tests for !=.

impl PartialEq<LBNum> for u64

fn eq(&self, rhs: &LBNum) -> bool

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

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

This method tests for !=.

impl PartialEq<LBNum> for u128

fn eq(&self, rhs: &LBNum) -> bool

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

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

This method tests for !=.

impl PartialEq<LBNum> for usize

fn eq(&self, rhs: &LBNum) -> bool

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

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

This method tests for !=.

impl PartialEq<u128> for LBNum

fn eq(&self, rhs: &u128) -> bool

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

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

This method tests for !=.

impl PartialEq<u16> for LBNum

fn eq(&self, rhs: &u16) -> bool

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

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

This method tests for !=.

impl PartialEq<u32> for LBNum

fn eq(&self, rhs: &u32) -> bool

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

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

This method tests for !=.

impl PartialEq<u64> for LBNum

fn eq(&self, rhs: &u64) -> bool

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

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

This method tests for !=.

impl PartialEq<u8> for LBNum

fn eq(&self, rhs: &u8) -> bool

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

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

This method tests for !=.

impl PartialEq<usize> for LBNum

fn eq(&self, rhs: &usize) -> bool

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

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

This method tests for !=.

impl PartialOrd<LBNum> for LBNum

fn partial_cmp(&self, rhs: &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 PartialOrd<LBNum> for u8

fn partial_cmp(&self, rhs: &LBNum) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<LBNum> for u16

fn partial_cmp(&self, rhs: &LBNum) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<LBNum> for u32

fn partial_cmp(&self, rhs: &LBNum) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<LBNum> for u64

fn partial_cmp(&self, rhs: &LBNum) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<LBNum> for u128

fn partial_cmp(&self, rhs: &LBNum) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<LBNum> for usize

fn partial_cmp(&self, rhs: &LBNum) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<u128> for LBNum

fn partial_cmp(&self, rhs: &u128) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<u16> for LBNum

fn partial_cmp(&self, rhs: &u16) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<u32> for LBNum

fn partial_cmp(&self, rhs: &u32) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<u64> for LBNum

fn partial_cmp(&self, rhs: &u64) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<u8> for LBNum

fn partial_cmp(&self, rhs: &u8) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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 PartialOrd<usize> for LBNum

fn partial_cmp(&self, rhs: &usize) -> Option<Ordering>

Compares self and rhs.

Never fails, a return value of Some can be relied upon.

#[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<'_> Rem<&'_ LBNum> for LBNum

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: &Self) -> Self

Performs integer modulo.

Panics

Dividing by 0 triggers an immediate panic.

impl Rem<LBNum> for LBNum

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self

Performs integer modulo.

Panics

Dividing by 0 triggers an immediate panic.

impl Rem<u128> for LBNum

type Output = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn rem(self, rhs: u128) -> Self

Performs the % operation.

impl Rem<u16> for LBNum

type Output = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn rem(self, rhs: u16) -> Self

Performs the % operation.

impl Rem<u32> for LBNum

type Output = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn rem(self, rhs: u32) -> Self

Performs the % operation.

impl Rem<u64> for LBNum

type Output = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn rem(self, rhs: u64) -> Self

Performs the % operation.

impl Rem<u8> for LBNum

type Output = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn rem(self, rhs: u8) -> Self

Performs the % operation.

impl Rem<usize> for LBNum

type Output = Self

The remainder type.

The reason why this is Self instead of the type of the divisor is that the remainder as available when the division is finished is still of type LBNum: it's never converted to the divisor type. As a result, the remainder is returned as-is to avoid situations when the remainder is required to be an LBNum yet has been converted to the divisor type, which would require converting it back into LBNum, which would require another allocation and performing the conversion process itself and would also waste the previous buffer.

fn rem(self, rhs: usize) -> Self

Performs the % operation.

impl<'_> RemAssign<&'_ LBNum> for LBNum

fn rem_assign(&mut self, rhs: &Self)

Performs integer modulo in place.

Panics

Dividing by 0 triggers an immediate panic.

impl RemAssign<LBNum> for LBNum

fn rem_assign(&mut self, rhs: Self)

Performs integer modulo in place.

Panics

Dividing by 0 triggers an immediate panic.

impl RemAssign<u128> for LBNum

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl RemAssign<u16> for LBNum

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl RemAssign<u32> for LBNum

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl RemAssign<u64> for LBNum

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl RemAssign<u8> for LBNum

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl RemAssign<usize> for LBNum

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl<'_> Sub<&'_ LBNum> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self

Subtracts an LBNum from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl Sub<LBNum> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Subtracts an LBNum from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl Sub<u128> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self

Subtracts rhs from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl Sub<u16> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self

Subtracts rhs from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl Sub<u32> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self

Subtracts rhs from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl Sub<u64> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self

Subtracts rhs from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl Sub<u8> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self

Subtracts rhs from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl Sub<usize> for LBNum

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self

Subtracts rhs from self.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl<'_> SubAssign<&'_ LBNum> for LBNum

fn sub_assign(&mut self, rhs: &Self)

Subtracts an LBNum from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl SubAssign<LBNum> for LBNum

fn sub_assign(&mut self, rhs: Self)

Subtracts an LBNum from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

impl SubAssign<u128> for LBNum

Subtracts rhs from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for LBNum

Subtracts rhs from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for LBNum

Subtracts rhs from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for LBNum

Subtracts rhs from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for LBNum

Subtracts rhs from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubAssign<usize> for LBNum

Subtracts rhs from self in place.

Panics

Subtraction underflow is undefined for the Linked Bytes format, since it only specifies unsigned integers.

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<'a> TryFrom<&'a LBNum> for u8

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<u8, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for u16

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<u16, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for isize

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<isize, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for i16

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<i16, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for u32

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<u32, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for i32

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<i32, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for u64

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<u64, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for i64

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<i64, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for u128

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<u128, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for i128

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<i128, TryFromIntError>

Performs the conversion.

impl<'a> TryFrom<&'a LBNum> for usize

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: &'a LBNum) -> Result<usize, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for u8

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<u8, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for u16

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<u16, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for isize

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<isize, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for i16

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<i16, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for u32

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<u32, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for i32

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<i32, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for u64

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<u64, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for i64

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<i64, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for u128

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<u128, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for i128

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<i128, TryFromIntError>

Performs the conversion.

impl TryFrom<LBNum> for usize

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(op: LBNum) -> Result<usize, TryFromIntError>

Performs the conversion.

impl TryFrom<LBSequence> for LBNum

type Error = InvalidLBSequence

The type returned in the event of a conversion error.

fn try_from(op: LBSequence) -> DecodeResult

Converts an LBSequence into an LBNum. Little-endian byte order is assumed, regardless of platform.

Errors

See InvalidLBSequence.

impl TryFrom<Vec<LinkedByte>> for LBNum

type Error = InvalidLBSequence

The type returned in the event of a conversion error.

fn try_from(op: Vec<LinkedByte>) -> DecodeResult

Converts a Vec<LinkedByte> into an LBNum. Little-endian byte order is assumed, regardless of platform.

Errors

See InvalidLBSequence.

impl UpperHex for LBNum

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

Formats the value using the given formatter.