Struct CompactU256 

pub struct CompactU256(pub Uint<256, 4>);

Available on crate feature provider only.

Wrapper struct so it can use StructFlags from Compact, when used as pure table values.

Tuple Fields

0: Uint<256, 4>

Implementations

impl CompactU256

pub const fn bitflag_encoded_bytes() -> usize

Used bytes by CompactU256Flags

pub const fn bitflag_unused_bits() -> usize

Unused bits for new fields by CompactU256Flags

Methods from Deref<Target = Uint<256, 4>>

pub fn to_base_le(&self, base: u64) -> impl Iterator<Item = u64>

Available on crate feature evm only.

Returns an iterator over the base base digits of the number in little-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Panics

Panics if the base is less than 2.

pub fn to_base_be(&self, base: u64) -> impl Iterator<Item = u64>

Available on crate feature evm only.

Returns an iterator over the base base digits of the number in big-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Use to_base_be_2 to extract the maximum number of digits at once more efficiently.

Panics

Panics if the base is less than 2.

Examples

let n = ruint::aliases::U64::from(1234);
assert_eq!(n.to_base_be(10).collect::<Vec<_>>(), [1, 2, 3, 4]);
assert_eq!(n.to_base_be(1000000).collect::<Vec<_>>(), [1234]);

// `to_base_be_2` always returns digits maximally packed into `u64`s.
assert_eq!(n.to_base_be_2(10).collect::<Vec<_>>(), [1234]);
assert_eq!(n.to_base_be_2(1000000).collect::<Vec<_>>(), [1234]);

pub fn to_base_be_2(&self, base: u64) -> impl Iterator<Item = u64>

Available on crate feature evm only.

Returns an iterator over the base base digits of the number in big-endian order.

Always returns digits maximally packed into u64s. Unlike to_base_be, this method:

• never heap-allocates memory, so it’s always faster
• always returns digits maximally packed into u64s, so passing the constant base like 2, 8, instead of the highest power that fits in u64 is not needed

Panics

Panics if the base is less than 2.

Examples

See to_base_be.

pub fn bit(&self, index: usize) -> bool

Available on crate feature evm only.

Returns whether a specific bit is set.

Returns false if index exceeds the bit width of the number.

pub fn byte(&self, index: usize) -> u8

Available on crate feature evm only.

Returns a specific byte. The byte at index 0 is the least significant byte (little endian).

Panics

Panics if index is greater than or equal to the byte width of the number.

Examples

let x = uint!(0x1234567890_U64);
let bytes = [
    x.byte(0), // 0x90
    x.byte(1), // 0x78
    x.byte(2), // 0x56
    x.byte(3), // 0x34
    x.byte(4), // 0x12
    x.byte(5), // 0x00
    x.byte(6), // 0x00
    x.byte(7), // 0x00
];
assert_eq!(bytes, x.to_le_bytes());

Panics if out of range.

let x = uint!(0x1234567890_U64);
let _ = x.byte(8);

pub fn checked_byte(&self, index: usize) -> Option<u8>

Available on crate feature evm only.

Returns a specific byte, or None if index is out of range. The byte at index 0 is the least significant byte (little endian).

Examples

let x = uint!(0x1234567890_U64);
assert_eq!(x.checked_byte(0), Some(0x90));
assert_eq!(x.checked_byte(7), Some(0x00));
// Out of range
assert_eq!(x.checked_byte(8), None);

pub fn leading_zeros(&self) -> usize

Available on crate feature evm only.

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

pub fn leading_ones(&self) -> usize

Available on crate feature evm only.

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

pub fn trailing_zeros(&self) -> usize

Available on crate feature evm only.

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

pub fn trailing_ones(&self) -> usize

Available on crate feature evm only.

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

pub fn count_ones(&self) -> usize

Available on crate feature evm only.

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

pub fn count_zeros(&self) -> usize

Available on crate feature evm only.

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

pub fn bit_len(&self) -> usize

Available on crate feature evm only.

Returns the dynamic length of this number in bits, ignoring leading zeros.

For the maximum length of the type, use Uint::BITS.

pub fn byte_len(&self) -> usize

Available on crate feature evm only.

Returns the dynamic length of this number in bytes, ignoring leading zeros.

For the maximum length of the type, use Uint::BYTES.

pub fn most_significant_bits(&self) -> (u64, usize)

Available on crate feature evm only.

Returns the most significant 64 bits of the number and the exponent.

Given return value $(\mathtt{bits}, \mathtt{exponent})$, the self can be approximated as

$$ \mathtt{self} ≈ \mathtt{bits} ⋅ 2^\mathtt{exponent} $$

If self is $<≥> 2^{63}$, then exponent will be zero and bits will have leading zeros.

pub const BYTES: usize

pub fn as_le_slice(&self) -> &[u8]

Available on crate feature evm only.

Access the underlying store as a little-endian slice of bytes.

Only available on little-endian targets.

If BITS does not evenly divide 8, it is padded with zero bits in the most significant position.

pub fn as_le_bytes(&self) -> Cow<'_, [u8]>

Available on crate feature evm only.

Access the underlying store as a little-endian bytes.

Uses an optimized implementation on little-endian targets.

pub fn as_le_bytes_trimmed(&self) -> Cow<'_, [u8]>

Available on crate feature evm only.

Access the underlying store as a little-endian bytes with trailing zeros removed.

Uses an optimized implementation on little-endian targets.

pub fn to_le_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Available on crate feature evm only.

Converts the Uint to a little-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_le_bytes_vec(&self) -> Vec<u8>

Available on crate feature evm only.

Converts the Uint to a little-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_le_bytes can not be used because byte size is not known compile time.

pub fn to_le_bytes_trimmed_vec(&self) -> Vec<u8>

Available on crate feature evm only.

Converts the Uint to a little-endian byte vector with trailing zeros bytes removed.

pub fn to_be_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Available on crate feature evm only.

Converts the Uint to a big-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_be_bytes_vec(&self) -> Vec<u8>

Available on crate feature evm only.

Converts the Uint to a big-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_be_bytes can not be used because byte size is not known compile time.

pub fn to_be_bytes_trimmed_vec(&self) -> Vec<u8>

Available on crate feature evm only.

Converts the Uint to a big-endian byte vector with leading zeros bytes removed.

pub fn copy_le_bytes_to(&self, buf: &mut [u8]) -> usize

Available on crate feature evm only.

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_le_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Available on crate feature evm only.

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn copy_be_bytes_to(&self, buf: &mut [u8]) -> usize

Available on crate feature evm only.

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_be_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Available on crate feature evm only.

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn is_zero(&self) -> bool

Available on crate feature evm only.

Returns true if the value is zero.

pub fn const_is_zero(&self) -> bool

Available on crate feature evm only.

Returns true if the value is zero.

Note that this currently might perform worse than is_zero.

pub fn const_eq(&self, other: &Uint<BITS, LIMBS>) -> bool

Available on crate feature evm only.

Returns true if self equals other.

Note that this currently might perform worse than the derived PartialEq (== operator).

pub fn to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>, T: Debug,

Available on crate feature evm only.

Panics

Panics if the conversion fails, for example if the value is too large for the bit-size of the target type.

Examples

assert_eq!(300_U12.to::<i16>(), 300_i16);
assert_eq!(300_U12.to::<U256>(), 300_U256);

pub fn wrapping_to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>,

Available on crate feature evm only.

Examples

assert_eq!(300_U12.wrapping_to::<i8>(), 44_i8);
assert_eq!(255_U32.wrapping_to::<i8>(), -1_i8);
assert_eq!(0x1337cafec0d3_U256.wrapping_to::<U32>(), 0xcafec0d3_U32);

pub fn saturating_to<T>(&self) -> T

where Uint<BITS, LIMBS>: UintTryTo<T>,

Available on crate feature evm only.

Examples

assert_eq!(300_U12.saturating_to::<i16>(), 300_i16);
assert_eq!(255_U32.saturating_to::<i8>(), 127);
assert_eq!(0x1337cafec0d3_U256.saturating_to::<U32>(), U32::MAX);

pub const LIMBS: usize

pub const MASK: u64

pub const BITS: usize = BITS

pub const ZERO: Uint<BITS, LIMBS>

pub const ONE: Uint<BITS, LIMBS>

pub const MIN: Uint<BITS, LIMBS> = Self::ZERO

pub const MAX: Uint<BITS, LIMBS>

pub fn as_limbs(&self) -> &[u64; LIMBS]

Available on crate feature evm only.

View the array of limbs.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for CompactU256

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<CompactU256, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<CompactU256, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for CompactU256

fn clone(&self) -> CompactU256

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Compact for CompactU256

fn to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

Takes a buffer which can be written to. Ideally, it returns the length written to.

fn from_compact(buf: &[u8], len: usize) -> (CompactU256, &[u8])

Takes a buffer which can be read from. Returns the object and buf with its internal cursor advanced (eg..advance(len)).

fn specialized_to_compact<B>(&self, buf: &mut B) -> usize

where B: BufMut + AsMut<[u8]>,

“Optional”: If there’s no good reason to use it, don’t.

fn specialized_from_compact(buf: &[u8], len: usize) -> (Self, &[u8])

“Optional”: If there’s no good reason to use it, don’t.

impl Compress for CompactU256

type Compressed = Vec<u8>

Compressed type.

fn compress_to_buf<B>(&self, buf: &mut B)

where B: BufMut + AsMut<[u8]>,

Compresses data to a given buffer.

fn uncompressable_ref(&self) -> Option<&[u8]>

If the type cannot be compressed, return its inner reference as Some(self.as_ref())

fn compress(self) -> Self::Compressed

Compresses data going into the database.

impl Debug for CompactU256

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

Formats the value using the given formatter.

impl Decompress for CompactU256

fn decompress(value: &[u8]) -> Result<CompactU256, DatabaseError>

Decompresses data coming from the database.

fn decompress_owned(value: Vec<u8>) -> Result<Self, DatabaseError>

Decompresses owned data coming from the database.

impl Default for CompactU256

fn default() -> CompactU256

Returns the “default value” for a type.

impl Deref for CompactU256

type Target = Uint<256, 4>

The resulting type after dereferencing.

fn deref(&self) -> &<CompactU256 as Deref>::Target

Dereferences the value.

impl<'de> Deserialize<'de> for CompactU256

fn deserialize<__D>( __deserializer: __D, ) -> Result<CompactU256, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<CompactU256> for Uint<256, 4>

fn from(value: CompactU256) -> Uint<256, 4>

Converts to this type from the input type.

impl From<Uint<256, 4>> for CompactU256

fn from(value: Uint<256, 4>) -> CompactU256

Converts to this type from the input type.

impl PartialEq for CompactU256

fn eq(&self, other: &CompactU256) -> 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 Serialize for CompactU256

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CompactU256

impl StructuralPartialEq for CompactU256

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes