Struct FixedBytes Copy item path

impl<const N: usize> FixedBytes<N>

pub const ZERO: FixedBytes<N>

Array of Zero bytes.

pub const fn new(bytes: [u8; N]) -> FixedBytes<N>

Wraps the given byte array in FixedBytes.

pub const fn with_last_byte(x: u8) -> FixedBytes<N>

Creates a new FixedBytes with the last byte set to x.

pub const fn repeat_byte(byte: u8) -> FixedBytes<N>

Creates a new FixedBytes where all bytes are set to byte.

pub const fn bit_xor(self, rhs: FixedBytes<N>) -> FixedBytes<N>

Computes the bitwise XOR of two FixedBytes.

Methods from Deref<Target = [u8; N]>§

pub fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char #110998)

Converts this array of bytes into an array of ASCII characters, or returns None if any of the characters is non-ASCII.

§Examples

#![feature(ascii_char)]

const HEX_DIGITS: [std::ascii::Char; 16] =
    *b"0123456789abcdef".as_ascii().unwrap();

assert_eq!(HEX_DIGITS[1].as_str(), "1");
assert_eq!(HEX_DIGITS[10].as_str(), "a");

pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char #110998)

Converts this array of bytes into an array of ASCII characters, without checking whether they’re valid.

§Safety

Every byte in the array must be in 0..=127, or else this is UB.

1.57.0 · Source

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

1.57.0 · Source

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

1.77.0 · Source

pub fn each_ref(&self) -> [&T; N]

Borrows each element and returns an array of references with the same size as self.

§Example

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

1.77.0 · Source

pub fn each_mut(&mut self) -> [&mut T; N]

Borrows each element mutably and returns an array of mutable references with the same size as self.

§Example


let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array #90091)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

§Panics

Panics if M > N.

§Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array #90091)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

§Panics

Panics if M > N.

§Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array #90091)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

§Panics

Panics if M > N.

§Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array #90091)

Divides one mutable array reference into two at an index from the end.

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

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

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. Read more

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. Read more

impl<const N: usize> Arbitrary for FixedBytes<N>

type Parameters = <[u8; N] as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<<[u8; N] as Arbitrary>::Strategy, fn(_: [u8; N]) -> FixedBytes<N>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( _top: <FixedBytes<N> as Arbitrary>::Parameters, ) -> <FixedBytes<N> as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args. Read more

impl<const N: usize> BitOrAssign for FixedBytes<N>

fn bitor_assign(&mut self, rhs: FixedBytes<N>)

Performs the |= operation. Read more

impl<const N: usize> BitXor for FixedBytes<N>

type Output = FixedBytes<N>

The resulting type after applying the ^ operator.

Performs copy-assignment from source. Read more

impl<const N: usize> Compact for FixedBytes<N>

fn to_compact(&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) -> (FixedBytes<N>, &[u8])

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

fn specialized_to_compact(&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 FixedBytes<32>

type Compressed = Vec<u8>

Compressed type.

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

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

fn compress_to_buf(self, buf: &mut B)
where B: BufMut + AsMut<[u8]>,

Compresses data to a given buffer.

Decodes owned data coming from the database.

impl<const N: usize> Decode for FixedBytes<N>

fn is_ssz_fixed_len() -> bool

Returns true if this object has a fixed-length. Read more

fn ssz_fixed_len() -> usize

The number of bytes this object occupies in the fixed-length portion of the SSZ bytes. Read more

fn from_ssz_bytes(bytes: &[u8]) -> Result<FixedBytes<N>, DecodeError>

Attempts to decode Self from bytes, returning a DecodeError on failure. Read more

impl Decompress for FixedBytes<32>

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

Decompresses data coming from the database.

fn sample<R>(&self, rng: &mut R) -> FixedBytes<N>
where R: Rng + ?Sized,

Creates an instance of type Self from the given hex string, or fails with a custom error type. Read more

impl<const N: usize> FromStr for FixedBytes<N>

type Err = FromHexError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<FixedBytes<N>, <FixedBytes<N> as FromStr>::Err>

Parses a string s to return a value of this type. Read more

impl<const N: usize> Hash for FixedBytes<N>

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

Feeds this value into the given Hasher. Read more

fn into_iter( self, ) -> <&'__deriveMoreLifetime FixedBytes<N> as IntoIterator>::IntoIter

Creates an iterator from a value. Read more

impl<'deriveMoreLifetime, const N: usize> IntoIterator for &'deriveMoreLifetime mut FixedBytes<N>
where &'__deriveMoreLifetime mut [u8; N]: IntoIterator,

type Item = <&'__deriveMoreLifetime mut [u8; N] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime mut [u8; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'__deriveMoreLifetime mut FixedBytes<N> as IntoIterator>::IntoIter

Creates an iterator from a value. Read more

impl<const N: usize> IntoIterator for FixedBytes<N>
where [u8; N]: IntoIterator,

type Item = <[u8; N] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <[u8; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

Performs the unary ! operation. Read more

impl<const N: usize> Ord for FixedBytes<N>

fn cmp(&self, other: &FixedBytes<N>) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · Source§

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

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

The name of the associated Solidity type. Read more

fn sol_type_name(&self) -> Cow<'static, str>

👎Deprecated since 0.6.3: use sol_name instead

Performs the conversion.

impl<const N: usize> UpperHex for FixedBytes<N>

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

Formats the value using the given formatter. Read more

fn as_byte_slice(&self) -> &[u8] ⓘ

impl<A, T> AsMutBits<T> for A
where A: AsMut<[T]>, T: BitStore,

fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O> ⓘ
where O: BitOrder,

Views self as a mutable bit-slice region with the O ordering.

fn try_as_mut_bits<O>(&mut self) -> Result<&mut BitSlice<T, O>, BitSpanError<T>>
where O: BitOrder,

Attempts to view self as a mutable bit-slice region with the O ordering. Read more

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> Conv for T

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> DynClone for T
where T: Clone,

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.

impl<T> ToHex for T
where T: AsRef<[u8]>,

fn encode_hex(&self) -> U
where U: FromIterator<char>,

👎Deprecated: use ToHexExt instead

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca).

fn encode_hex_upper(&self) -> U
where U: FromIterator<char>,

👎Deprecated: use ToHexExt instead

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA).

impl<T> ToHex for T
where T: AsRef<[u8]>,

fn encode_hex(&self) -> U
where U: FromIterator<char>,

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca)

fn encode_hex_upper(&self) -> U
where U: FromIterator<char>,

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA)

impl<T> ToHexExt for T
where T: AsRef<[u8]>,

fn encode_hex(&self) -> String

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca).

fn encode_hex_upper(&self) -> String

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA).

fn encode_hex_with_prefix(&self) -> String

Encode the hex strict representing self into the result with prefix 0x. Lower case letters are used (e.g. 0xf9b4ca).

fn encode_hex_upper_with_prefix(&self) -> String

Encode the hex strict representing self into the result with prefix 0X. Upper case letters are used (e.g. 0xF9B4CA).

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more