Struct Array 

pub struct Array<T>(/* private fields */);

Array - T[]

Trait Implementations

impl<T: EventTopic> EventTopic for Array<T>

fn topic_preimage_length(rust: &Self::RustType) -> usize

The number of bytes this type occupies in another topic’s preimage, usually a multiple of 32.

fn encode_topic_preimage(rust: &Self::RustType, out: &mut Vec<u8>)

Encodes this type as preimage bytes which are then hashed in complex types’ encode_topic.

fn encode_topic(rust: &Self::RustType) -> WordToken

Indexed event parameter encoding.

impl<T: SolType> SolType for Array<T>

const SOL_NAME: &'static str

The name of this type in Solidity.

const ENCODED_SIZE: Option<usize> = None

The statically-known ABI-encoded size of the type.

const PACKED_ENCODED_SIZE: Option<usize> = None

The statically-known Non-standard Packed Mode ABI-encoded size of the type.

type RustType = Vec<<T as SolType>::RustType>

The corresponding Rust type.

type Token<'a> = DynSeqToken<<T as SolType>::Token<'a>>

The corresponding ABI token type.

fn valid_token(token: &Self::Token<'_>) -> bool

Returns true if the given token can be detokenized with this type.

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

Detokenize this type’s value from the given token.

const DYNAMIC: bool = _

Whether the ABI-encoded size is dynamic.

fn abi_encoded_size<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> usize

Calculate the ABI-encoded size of the data, counting both head and tail words. For a single-word type this will always be 32.

fn type_check(token: &Self::Token<'_>) -> Result<()>

Returns an error if the given token cannot be detokenized with this type.

fn tokenize<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> Self::Token<'_>

Tokenizes the given value into this type’s token.

fn eip712_data_word<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> Word

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

fn abi_packed_encoded_size<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> usize

Returns the length of this value when ABI-encoded in Non-standard Packed Mode.

fn abi_encode_packed_to<E: ?Sized + SolTypeValue<Self>>( rust: &E, out: &mut Vec<u8>, )

Non-standard Packed Mode ABI encoding.

fn abi_encode_packed<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> Vec<u8>

Non-standard Packed Mode ABI encoding.

fn abi_encode<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> Vec<u8>

Tokenizes and ABI-encodes the given value by wrapping it in a single-element sequence.

fn abi_encode_params<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> Vec<u8>

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

Tokenizes and ABI-encodes the given value as function parameters.

fn abi_encode_sequence<E: ?Sized + SolTypeValue<Self>>(rust: &E) -> Vec<u8>

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

Tokenizes and ABI-encodes the given value as a sequence.

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

Decodes this type’s value from an ABI blob by interpreting it as a single-element sequence.

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

Decodes this type’s value from an ABI blob by interpreting it as single-element sequence, with validation.

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

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as function parameters.

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

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as function parameters, with validation.

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

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as a sequence.

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

where Self::Token<'de>: TokenSeq<'de>,

Decodes this type’s value from an ABI blob by interpreting it as sequence, with validation.

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