Struct Function

#[repr(transparent)]
pub struct Function(pub FixedBytes<24>);

An Ethereum ABI function pointer, 24 bytes in length.

An address (20 bytes), followed by a function selector (4 bytes). Encoded identical to bytes24.

Tuple Fields

0: FixedBytes<24>

Implementations

impl Function

pub const ZERO: Function

Array of Zero bytes.

pub const fn new(bytes: [u8; 24]) -> Function

Wraps the given byte array in this type.

pub const fn with_last_byte(x: u8) -> Function

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

pub const fn repeat_byte(byte: u8) -> Function

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

pub const fn len_bytes() -> usize

Returns the size of this array in bytes.

pub fn random() -> Function

Creates a new fixed byte array with the default cryptographic random number generator.

This is rand::thread_rng if the “rand” and “std” features are enabled, otherwise it uses getrandom::getrandom. Both are cryptographically secure.

pub fn try_random() -> Result<Function, Error>

Tries to create a new fixed byte array with the default cryptographic random number generator.

See random for more details.

pub fn randomize(&mut self)

Fills this fixed byte array with the default cryptographic random number generator.

See random for more details.

pub fn try_randomize(&mut self) -> Result<(), Error>

Tries to fill this fixed byte array with the default cryptographic random number generator.

See random for more details.

pub fn random_with<R>(rng: &mut R) -> Function

where R: RngCore + ?Sized,

Creates a new fixed byte array with the given random number generator.

pub fn try_random_with<R>( rng: &mut R, ) -> Result<Function, <R as TryRngCore>::Error>

where R: TryRngCore + ?Sized,

Tries to create a new fixed byte array with the given random number generator.

pub fn randomize_with<R>(&mut self, rng: &mut R)

where R: RngCore + ?Sized,

Fills this fixed byte array with the given random number generator.

pub fn try_randomize_with<R>( &mut self, rng: &mut R, ) -> Result<(), <R as TryRngCore>::Error>

where R: TryRngCore + ?Sized,

Tries to fill this fixed byte array with the given random number generator.

pub fn from_slice(src: &[u8]) -> Function

Create a new byte array from the given slice src.

For a fallible version, use the TryFrom<&[u8]> implementation.

Note

The given bytes are interpreted in big endian order.

Panics

If the length of src and the number of bytes in Self do not match.

pub fn left_padding_from(value: &[u8]) -> Function

Create a new byte array from the given slice src, left-padding it with zeroes if necessary.

Note

The given bytes are interpreted in big endian order.

Panics

Panics if src.len() > N.

pub fn right_padding_from(value: &[u8]) -> Function

Create a new byte array from the given slice src, right-padding it with zeroes if necessary.

Note

The given bytes are interpreted in big endian order.

Panics

Panics if src.len() > N.

pub const fn into_array(self) -> [u8; 24]

Returns the inner bytes array.

pub fn covers(&self, b: &Function) -> bool

Returns true if all bits set in b are also set in self.

pub const fn const_eq(&self, other: &Function) -> bool

Compile-time equality. NOT constant-time equality.

pub const fn bit_and(self, rhs: Function) -> Function

Computes the bitwise AND of two FixedBytes.

pub const fn bit_or(self, rhs: Function) -> Function

Computes the bitwise OR of two FixedBytes.

pub const fn bit_xor(self, rhs: Function) -> Function

Computes the bitwise XOR of two FixedBytes.

impl Function

pub fn from_word(word: FixedBytes<32>) -> Function

Creates an Ethereum function from an EVM word’s lower 24 bytes (word[..24]).

Note that this is different from Address::from_word, which uses the upper 20 bytes.

pub fn into_word(&self) -> FixedBytes<32>

Right-pads the function to 32 bytes (EVM word size).

Note that this is different from Address::into_word, which left-pads the address.

pub fn from_address_and_selector<A, S>(address: A, selector: S) -> Function

where A: Borrow<[u8; 20]>, S: Borrow<[u8; 4]>,

Creates an Ethereum function from an address and selector.

pub fn as_address_and_selector(&self) -> (&Address, &FixedBytes<4>)

Returns references to the address and selector of the function.

pub fn to_address_and_selector(&self) -> (Address, FixedBytes<4>)

Returns the address and selector of the function.

Methods from Deref<Target = FixedBytes<24>>

pub const ZERO: FixedBytes<N>

pub fn randomize(&mut self)

Fills this FixedBytes with the default cryptographic random number generator.

See random for more details.

pub fn try_randomize(&mut self) -> Result<(), Error>

Tries to fill this FixedBytes with the default cryptographic random number generator.

See random for more details.

pub fn randomize_with<R>(&mut self, rng: &mut R)

where R: RngCore + ?Sized,

Fills this FixedBytes with the given random number generator.

pub fn try_randomize_with<R>( &mut self, rng: &mut R, ) -> Result<(), <R as TryRngCore>::Error>

where R: TryRngCore + ?Sized,

Tries to fill this FixedBytes with the given random number generator.

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

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

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

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

pub fn covers(&self, other: &FixedBytes<N>) -> bool

Returns true if all bits set in self are also set in b.

pub fn const_eq(&self, other: &FixedBytes<N>) -> bool

Compile-time equality. NOT constant-time equality.

pub fn is_zero(&self) -> bool

Returns true if no bits are set.

pub fn const_is_zero(&self) -> bool

Returns true if no bits are set.

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

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

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

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)

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.

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

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

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

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

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);

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)

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)

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)

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)

Divides one mutable 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 mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
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]);

Trait Implementations

impl<'a> Arbitrary<'a> for Function

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

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

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Function, 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 Arbitrary for Function

type Parameters = <FixedBytes<24> as Arbitrary>::Parameters

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

type Strategy = Map<<FixedBytes<24> as Arbitrary>::Strategy, fn(FixedBytes<24>) -> Function>

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

fn arbitrary() -> <Function as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

fn arbitrary_with( args: <Function as Arbitrary>::Parameters, ) -> <Function 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.

impl AsMut<[u8]> for Function

fn as_mut(&mut self) -> &mut [u8]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<[u8; 24]> for Function

fn as_mut(&mut self) -> &mut [u8; 24]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<FixedBytes<24>> for Function

fn as_mut(&mut self) -> &mut FixedBytes<24>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[u8]> for Function

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

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[u8; 24]> for Function

fn as_ref(&self) -> &[u8; 24]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<FixedBytes<24>> for Function

fn as_ref(&self) -> &FixedBytes<24>

Converts this type into a shared reference of the (usually inferred) input type.

impl BitAnd<&Function> for Function

type Output = Function

The resulting type after applying the & operator.

fn bitand(self, rhs: &Function) -> Function

Performs the & operation.

impl BitAnd for Function

type Output = Function

The resulting type after applying the & operator.

fn bitand(self, rhs: Function) -> Function

Performs the & operation.

impl BitAndAssign<&Function> for Function

fn bitand_assign(&mut self, rhs: &Function)

Performs the &= operation.

impl BitAndAssign for Function

fn bitand_assign(&mut self, rhs: Function)

Performs the &= operation.

impl BitOr<&Function> for Function

type Output = Function

The resulting type after applying the | operator.

fn bitor(self, rhs: &Function) -> Function

Performs the | operation.

impl BitOr for Function

type Output = Function

The resulting type after applying the | operator.

fn bitor(self, rhs: Function) -> Function

Performs the | operation.

impl BitOrAssign<&Function> for Function

fn bitor_assign(&mut self, rhs: &Function)

Performs the |= operation.

impl BitOrAssign for Function

fn bitor_assign(&mut self, rhs: Function)

Performs the |= operation.

impl BitXor<&Function> for Function

type Output = Function

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Function) -> Function

Performs the ^ operation.

impl BitXor for Function

type Output = Function

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Function) -> Function

Performs the ^ operation.

impl BitXorAssign<&Function> for Function

fn bitxor_assign(&mut self, rhs: &Function)

Performs the ^= operation.

impl BitXorAssign for Function

fn bitxor_assign(&mut self, rhs: Function)

Performs the ^= operation.

impl Borrow<[u8]> for &Function

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

Immutably borrows from an owned value.

impl Borrow<[u8]> for &mut Function

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

Immutably borrows from an owned value.

impl Borrow<[u8]> for Function

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

Immutably borrows from an owned value.

impl Borrow<[u8; 24]> for &Function

fn borrow(&self) -> &[u8; 24]

Immutably borrows from an owned value.

impl Borrow<[u8; 24]> for &mut Function

fn borrow(&self) -> &[u8; 24]

Immutably borrows from an owned value.

impl Borrow<[u8; 24]> for Function

fn borrow(&self) -> &[u8; 24]

Immutably borrows from an owned value.

impl BorrowMut<[u8]> for &mut Function

fn borrow_mut(&mut self) -> &mut [u8]

Mutably borrows from an owned value.

impl BorrowMut<[u8]> for Function

fn borrow_mut(&mut self) -> &mut [u8]

Mutably borrows from an owned value.

impl BorrowMut<[u8; 24]> for &mut Function

fn borrow_mut(&mut self) -> &mut [u8; 24]

Mutably borrows from an owned value.

impl BorrowMut<[u8; 24]> for Function

fn borrow_mut(&mut self) -> &mut [u8; 24]

Mutably borrows from an owned value.

impl Clone for Function

fn clone(&self) -> Function

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Function

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

Formats the value using the given formatter.

impl Decodable for Function

fn decode(buf: &mut &[u8]) -> Result<Function, Error>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl Default for Function

fn default() -> Function

Returns the “default value” for a type.

impl Deref for Function

type Target = FixedBytes<24>

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Function

fn deref_mut(&mut self) -> &mut <Function as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for Function

fn deserialize<D>( deserializer: D, ) -> Result<Function, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Function

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

Formats the value using the given formatter.

impl Distribution<Function> for StandardUniform

fn sample<R>(&self, rng: &mut R) -> Function

where R: Rng + ?Sized,

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Encodable for Function

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

impl<'a> From<&'a [u8; 24]> for &'a Function

fn from(value: &'a [u8; 24]) -> &'a Function

Converts to this type from the input type.

impl<'a> From<&'a [u8; 24]> for Function

fn from(value: &'a [u8; 24]) -> Function

Converts to this type from the input type.

impl<'a> From<&'a Function> for &'a [u8; 24]

fn from(value: &'a Function) -> &'a [u8; 24]

Converts to this type from the input type.

impl<'a> From<&'a mut [u8; 24]> for &'a Function

fn from(value: &'a mut [u8; 24]) -> &'a Function

Converts to this type from the input type.

impl<'a> From<&'a mut [u8; 24]> for &'a mut Function

fn from(value: &'a mut [u8; 24]) -> &'a mut Function

Converts to this type from the input type.

impl<'a> From<&'a mut [u8; 24]> for Function

fn from(value: &'a mut [u8; 24]) -> Function

Converts to this type from the input type.

impl<'a> From<&'a mut Function> for &'a [u8; 24]

fn from(value: &'a mut Function) -> &'a [u8; 24]

Converts to this type from the input type.

impl<'a> From<&'a mut Function> for &'a mut [u8; 24]

fn from(value: &'a mut Function) -> &'a mut [u8; 24]

Converts to this type from the input type.

impl From<[u8; 24]> for Function

fn from(value: [u8; 24]) -> Function

Converts to this type from the input type.

impl<A, S> From<(A, S)> for Function

where A: Borrow<[u8; 20]>, S: Borrow<[u8; 4]>,

fn from(_: (A, S)) -> Function

Converts to this type from the input type.

impl From<FixedBytes<24>> for Function

fn from(value: FixedBytes<24>) -> Function

Converts to this type from the input type.

impl From<Function> for [u8; 24]

fn from(value: Function) -> [u8; 24]

Converts to this type from the input type.

impl From<Function> for FixedBytes<24>

fn from(value: Function) -> FixedBytes<24>

Converts to this type from the input type.

impl FromHex for Function

type Error = FromHexError

The associated error which can be returned from parsing.

fn from_hex<T>(hex: T) -> Result<Function, <Function as FromHex>::Error>

where T: AsRef<[u8]>,

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

impl FromStr for Function

type Err = <FixedBytes<24> as FromStr>::Err

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Function, <FixedBytes<24> as FromStr>::Err>

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

impl Hash for Function

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

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<__IdxT> Index<__IdxT> for Function

where FixedBytes<24>: Index<__IdxT>,

type Output = <FixedBytes<24> as Index<__IdxT>>::Output

The returned type after indexing.

fn index(&self, idx: __IdxT) -> &<Function as Index<__IdxT>>::Output

Performs the indexing (container[index]) operation.

impl<__IdxT> IndexMut<__IdxT> for Function

where FixedBytes<24>: IndexMut<__IdxT>,

fn index_mut(&mut self, idx: __IdxT) -> &mut <Function as Index<__IdxT>>::Output

Performs the mutable indexing (container[index]) operation.

impl<'__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime Function

where &'__deriveMoreLifetime FixedBytes<24>: IntoIterator,

type Item = <&'__deriveMoreLifetime FixedBytes<24> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime FixedBytes<24> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<'__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime mut Function

where &'__deriveMoreLifetime mut FixedBytes<24>: IntoIterator,

type Item = <&'__deriveMoreLifetime mut FixedBytes<24> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime mut FixedBytes<24> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl IntoIterator for Function

where FixedBytes<24>: IntoIterator,

type Item = <FixedBytes<24> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <FixedBytes<24> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Function as IntoIterator>::IntoIter

Creates an iterator from a value.

impl LowerHex for Function

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

Formats the value using the given formatter.

impl MaxEncodedLenAssoc for Function

const LEN: usize = 25usize

The maximum length.

impl Not for Function

type Output = Function

The resulting type after applying the ! operator.

fn not(self) -> Function

Performs the unary ! operation.

impl Ord for Function

fn cmp(&self, other: &Function) -> 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<&[u8]> for Function

fn eq(&self, other: &&[u8]) -> 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 PartialEq<&[u8; 24]> for Function

fn eq(&self, other: &&[u8; 24]) -> 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 PartialEq<&Function> for [u8]

fn eq(&self, other: &&Function) -> 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 PartialEq<&Function> for [u8; 24]

fn eq(&self, other: &&Function) -> 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 PartialEq<[u8]> for &Function

fn eq(&self, other: &[u8]) -> 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 PartialEq<[u8]> for Function

fn eq(&self, other: &[u8]) -> 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 PartialEq<[u8; 24]> for &Function

fn eq(&self, other: &[u8; 24]) -> 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 PartialEq<[u8; 24]> for Function

fn eq(&self, other: &[u8; 24]) -> 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 PartialEq<Function> for &[u8]

fn eq(&self, other: &Function) -> 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 PartialEq<Function> for &[u8; 24]

fn eq(&self, other: &Function) -> 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 PartialEq<Function> for [u8]

fn eq(&self, other: &Function) -> 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 PartialEq<Function> for [u8; 24]

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

fn eq(&self, other: &Function) -> 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<&[u8]> for Function

fn partial_cmp(&self, other: &&[u8]) -> 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 PartialOrd<&Function> for [u8]

fn partial_cmp(&self, other: &&Function) -> 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 PartialOrd<[u8]> for &Function

fn partial_cmp(&self, other: &[u8]) -> 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 PartialOrd<[u8]> for Function

fn partial_cmp(&self, other: &[u8]) -> 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 PartialOrd<Function> for &[u8]

fn partial_cmp(&self, other: &Function) -> 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 PartialOrd<Function> for [u8]

fn partial_cmp(&self, other: &Function) -> 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 PartialOrd for Function

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

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 SolValue for Function

type SolType = Function

The Solidity type that this type corresponds to.

fn sol_name(&self) -> &'static str

The name of the associated Solidity type.

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

👎Deprecated since 0.6.3: use sol_name instead

The name of the associated Solidity type.

fn tokenize(&self) -> <Self::SolType as SolType>::Token<'_>

Tokenizes the given value into this type’s token.

fn detokenize(token: <Self::SolType as SolType>::Token<'_>) -> Self

where Self: From<<Self::SolType as SolType>::RustType>,

Detokenize a value from the given token.

fn abi_encoded_size(&self) -> usize

Calculate the ABI-encoded size of the data.

fn eip712_data_word(&self) -> FixedBytes<32>

Encode this data according to EIP-712 encodeData rules, and hash it if necessary.

fn abi_encode_packed_to(&self, out: &mut Vec<u8>)

Non-standard Packed Mode ABI encoding.

fn abi_encode_packed(&self) -> Vec<u8>

Non-standard Packed Mode ABI encoding.

fn abi_encode(&self) -> Vec<u8>

ABI-encodes the value.

fn abi_encode_sequence(&self) -> Vec<u8>

where <Self::SolType as SolType>::Token<'a>: for<'a> TokenSeq<'a>,

Encodes an ABI sequence.

fn abi_encode_params(&self) -> Vec<u8>

where <Self::SolType as SolType>::Token<'a>: for<'a> TokenSeq<'a>,

Encodes an ABI sequence suitable for function parameters.

fn abi_decode(data: &[u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>,

ABI-decode this type from the given data.

fn abi_decode_validate(data: &[u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>,

ABI-decode this type from the given data, with validation.

fn abi_decode_params<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data.

fn abi_decode_params_validate<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data, with validation.

fn abi_decode_sequence<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data.

fn abi_decode_sequence_validate<'de>(data: &'de [u8]) -> Result<Self, Error>

where Self: From<<Self::SolType as SolType>::RustType>, <Self::SolType as SolType>::Token<'de>: TokenSeq<'de>,

ABI-decode this type from the given data, with validation.

impl<'a> TryFrom<&'a [u8]> for &'a Function

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from( slice: &'a [u8], ) -> Result<&'a Function, <&'a Function as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl TryFrom<&[u8]> for Function

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from( slice: &[u8], ) -> Result<Function, <Function as TryFrom<&[u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a mut [u8]> for &'a mut Function

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from( slice: &'a mut [u8], ) -> Result<&'a mut Function, <&'a mut Function as TryFrom<&'a mut [u8]>>::Error>

Performs the conversion.

impl TryFrom<&mut [u8]> for Function

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from( slice: &mut [u8], ) -> Result<Function, <Function as TryFrom<&mut [u8]>>::Error>

Performs the conversion.

impl UpperHex for Function

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

Formats the value using the given formatter.

impl Copy for Function

impl Eq for Function

impl MaxEncodedLen<alloy_primitives::::bits::function::{impl#90}::{constant#0}> for Function

impl StructuralPartialEq for Function

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: 24 bytes