Builtin type std::prelude::u8

8-bit unsigned integer (byte)

This is also the "character" type, e.g. expression "hello"[0] has type u8.

Methods

• fn max_value() -> u8

  source

  Returns the maximum value of u8.

• fn min_value() -> u8

  source

  Returns the minimum value of u8.

Mixins

• mixin BitOps<u8>

• fn swap_bytes(self: Self) -> Self

  source

  Swaps the byte order (endianness) of the number.

  Example

  assert_eq!(0x0123u16.swap_bytes(), 0x2301);
  Run this example

• fn to_be(self: Self) -> Self

  source

  Converts the number into a big-endian representation.

  If the numbers of this type are represented in big-endian order on the target architecture, then this is an identity function.

  Example

  #[cfg(target_endian = "little")]
  assert_eq!(0x0123u16.to_be(), 0x2301);
  
  #[cfg(target_endian = "big")]
  assert_eq!(0x0123u16.to_be(), 0x0123);
  Run this example

• fn from_be(self: Self) -> Self

  source

  Converts the number from a big-endian representation.

  If the numbers of this type are represented in big-endian order on the target architecture, then this is an identity function.

  Example

  #[cfg(target_endian = "little")]
  assert_eq!(0x0123u16.from_be(), 0x2301);
  
  #[cfg(target_endian = "big")]
  assert_eq!(0x0123u16.from_be(), 0x0123);
  Run this example

• fn to_le(self: Self) -> Self

  source

  Converts the number into a little-endian representation.

  If the numbers of this type are represented in little-endian order on the target architecture, then this is an identity function.

  Example

  #[cfg(target_endian = "little")]
  assert_eq!(0x0123u16.to_le(), 0x0123);
  
  #[cfg(target_endian = "big")]
  assert_eq!(0x0123u16.to_le(), 0x2301);
  Run this example

• fn from_le(self: Self) -> Self

  source

  Converts the number from a little-endian representation.

  If the numbers of this type are represented in little-endian order on the target architecture, then this is an identity operation.

  Example

  #[cfg(target_endian = "little")]
  assert_eq!(0x0123u16.from_le(), 0x0123);
  
  #[cfg(target_endian = "big")]
  assert_eq!(0x0123u16.from_le(), 0x2301);
  Run this example

• fn count_ones(self: Self) -> u32

  source

  Returns the number of ones in the binary representation of the number.

  Example

  assert_eq!(0b10101000u8.count_ones(), 3);
  Run this example

• fn count_zeros(self: Self) -> u32

  source

  Returns the number of zeros in the binary representation of the number.

  Example

  assert_eq!(0b10101000u8.count_zeros(), 5);
  Run this example

• fn leading_zeros(self: Self) -> u32

  source

  Returns the number of leading zeros in the binary representation of the number.

  Example

  assert_eq!(0b00010000u8.leading_zeros(), 3);
  Run this example

• fn trailing_zeros(self: Self) -> u32

  source

  Returns the number of trailing zeros in the binary representation of the number.

  Example

  assert_eq!(0b00010000u8.trailing_zeros(), 4);
  Run this example

• fn leading_ones(self: Self) -> u32

  source

  Returns the number of leading ones in the binary representation of the number.

  Example

  assert_eq!(0b11111110u8.leading_ones(), 7);
  Run this example

• fn trailing_ones(self: Self) -> u32

  source

  Returns the number of trailing ones in the binary representation of the number.

  Example

  assert_eq!(0b00000111u8.trailing_ones(), 3);
  Run this example

• fn rotate_left(self: Self, n: usize) -> Self

  source

  Rotates the bits to the left by n bits.

  Example

  assert_eq!(0b01000111u8.rotate_left(2), 0b00011101u8);
  Run this example

• fn rotate_right(self: Self, n: usize) -> Self

  source

  Rotates the bits to the right by n bits.

  Example

  assert_eq!(0b01000111u8.rotate_right(2), 0b11010001u8);
  Run this example

• mixin WithOverflow<u8>

• fn wrapping_add(lhs: Self, rhs: Self) -> Self

  source

  Adds two numbers, wrapping around at the boundary of the type.

• fn wrapping_sub(lhs: Self, rhs: Self) -> Self

  source

  Subtracts two numbers, wrapping around at the boundary of the type.

• fn wrapping_mul(lhs: Self, rhs: Self) -> Self

  source

  Multiplies two numbers, wrapping around at the boundary of the type.

• fn wrapping_div(lhs: Self, rhs: Self) -> Self

  source

  Divides two numbers, wrapping around at the boundary of the type.

  The only case where such wrapping can occur is when one divides MIN / -1 on a signed type. This is equivalent to -MIN, a number that is too large to represent in the type. In such a case, this function returns MIN itself.

• fn checked_add(lhs: Self, rhs: Self) -> Option<Self>

  source

  Tries to add two numbers, returning Option::none() if overflow occurrs.

• fn checked_sub(lhs: Self, rhs: Self) -> Option<Self>

  source

  Tries to subtract two numbers, returning Option::none() if overflow occurrs.

• fn checked_mul(lhs: Self, rhs: Self) -> Option<Self>

  source

  Tries to multiply two numbers, returning Option::none() if overflow occurrs.

• fn checked_div(lhs: Self, rhs: Self) -> Option<Self>

  source

  Tries to divide two numbers, returning Option::none() if overflow occurrs or rhs is zero.

  Overflow during division can only happen when one divides MIN / -1 on a signed type.

• mixin BuiltinComparable<u8>

• fn equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if arguments are equal, false otherwise

  See Equatable for details.

• fn not_equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns false if arguments are equal, true otherwise

• fn compare(lhs: &Self, rhs: &Self) -> Ordering

  source

  Compare the value

  See Comparable for details.

• fn less_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is strictly less than rhs, false otherwise

• fn less_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is less or equal to rhs, false otherwise

• fn greater_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs strictly greater than rhs, false otherwise

• fn greater_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs greater than or equal rhs, false otherwise

• mixin<H> Hashable<u8, H>

  H: Hasher<H>

• fn hash(a: &Self, hasher: &mut H)

  source

  Update hasher state with the contents of this object.

  See Hashable for details.

• mixin<F> IntegerFormattable<u8, F>

  F: Formatter<F>

• fn fmt(self: &Self, formatter: &mut F) -> Result<(), Error>

  source

  Write the object into a given formatter.

  See Formattable for details.

• mixin IntegerParsable<u8>

• fn parse(s: &[u8]) -> Option<Self>

  source

  Parses the integer from a base-10 string.

  If the string does not represent a valid integer, Option::none() is returned.

  Example

  assert_eq!(i32::parse("10"), Option::some(10));
  assert_eq!(i32::parse("foo"), Option::none());
  Run this example

• fn parse_with_radix(s: &[u8], radix: u16) -> Option<Self>

  source

  Parses the integer from a string in a given base.

  If the string does not represent a valid integer in the given base, Option::none() is returned.

  Example

  assert_eq!(i32::parse_with_radix("10", 2), Option::some(2));
  assert_eq!(u64::parse_with_radix("deadbeef", 16), Option::some(0xdeadbeefu64));
  assert_eq!(i32::parse_with_radix("foo", 10), Option::none());
  Run this example