Struct IntBitCount 

pub struct IntBitCount<const N: usize>;

Specifies the number of bits in an Int or Uint as a type.

Trait Implementations

impl SupportedInt for IntBitCount<104>

const UINT_NAME: &'static str = "uint104"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int104"

The name of the Int type: int<N>

const BITS: usize = 104usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<104, 2>

The signed integer Rust representation.

type Uint = Uint<104, 2>

The unsigned integer Rust representation.

fn tokenize_int(int: I104) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I104

Detokenizes a signed integer.

fn encode_packed_to_int(int: I104, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U104) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U104

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U104, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<112>

const UINT_NAME: &'static str = "uint112"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int112"

The name of the Int type: int<N>

const BITS: usize = 112usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<112, 2>

The signed integer Rust representation.

type Uint = Uint<112, 2>

The unsigned integer Rust representation.

fn tokenize_int(int: I112) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I112

Detokenizes a signed integer.

fn encode_packed_to_int(int: I112, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U112) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U112

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U112, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<120>

const UINT_NAME: &'static str = "uint120"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int120"

The name of the Int type: int<N>

const BITS: usize = 120usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<120, 2>

The signed integer Rust representation.

type Uint = Uint<120, 2>

The unsigned integer Rust representation.

fn tokenize_int(int: I120) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I120

Detokenizes a signed integer.

fn encode_packed_to_int(int: I120, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U120) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U120

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U120, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<128>

const UINT_NAME: &'static str = "uint128"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int128"

The name of the Int type: int<N>

const BITS: usize = 128usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = i128

The signed integer Rust representation.

type Uint = u128

The unsigned integer Rust representation.

fn tokenize_int(int: i128) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> i128

Detokenizes a signed integer.

fn encode_packed_to_int(int: i128, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: u128) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> u128

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: u128, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<136>

const UINT_NAME: &'static str = "uint136"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int136"

The name of the Int type: int<N>

const BITS: usize = 136usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<136, 3>

The signed integer Rust representation.

type Uint = Uint<136, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I136) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I136

Detokenizes a signed integer.

fn encode_packed_to_int(int: I136, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U136) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U136

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U136, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<144>

const UINT_NAME: &'static str = "uint144"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int144"

The name of the Int type: int<N>

const BITS: usize = 144usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<144, 3>

The signed integer Rust representation.

type Uint = Uint<144, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I144) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I144

Detokenizes a signed integer.

fn encode_packed_to_int(int: I144, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U144) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U144

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U144, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<152>

const UINT_NAME: &'static str = "uint152"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int152"

The name of the Int type: int<N>

const BITS: usize = 152usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<152, 3>

The signed integer Rust representation.

type Uint = Uint<152, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I152) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I152

Detokenizes a signed integer.

fn encode_packed_to_int(int: I152, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U152) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U152

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U152, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<16>

const UINT_NAME: &'static str = "uint16"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int16"

The name of the Int type: int<N>

const BITS: usize = 16usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = i16

The signed integer Rust representation.

type Uint = u16

The unsigned integer Rust representation.

fn tokenize_int(int: i16) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> i16

Detokenizes a signed integer.

fn encode_packed_to_int(int: i16, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: u16) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> u16

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: u16, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<160>

const UINT_NAME: &'static str = "uint160"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int160"

The name of the Int type: int<N>

const BITS: usize = 160usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<160, 3>

The signed integer Rust representation.

type Uint = Uint<160, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I160) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I160

Detokenizes a signed integer.

fn encode_packed_to_int(int: I160, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U160) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U160

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U160, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<168>

const UINT_NAME: &'static str = "uint168"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int168"

The name of the Int type: int<N>

const BITS: usize = 168usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<168, 3>

The signed integer Rust representation.

type Uint = Uint<168, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I168) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I168

Detokenizes a signed integer.

fn encode_packed_to_int(int: I168, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U168) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U168

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U168, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<176>

const UINT_NAME: &'static str = "uint176"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int176"

The name of the Int type: int<N>

const BITS: usize = 176usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<176, 3>

The signed integer Rust representation.

type Uint = Uint<176, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I176) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I176

Detokenizes a signed integer.

fn encode_packed_to_int(int: I176, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U176) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U176

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U176, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<184>

const UINT_NAME: &'static str = "uint184"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int184"

The name of the Int type: int<N>

const BITS: usize = 184usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<184, 3>

The signed integer Rust representation.

type Uint = Uint<184, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I184) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I184

Detokenizes a signed integer.

fn encode_packed_to_int(int: I184, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U184) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U184

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U184, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<192>

const UINT_NAME: &'static str = "uint192"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int192"

The name of the Int type: int<N>

const BITS: usize = 192usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<192, 3>

The signed integer Rust representation.

type Uint = Uint<192, 3>

The unsigned integer Rust representation.

fn tokenize_int(int: I192) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I192

Detokenizes a signed integer.

fn encode_packed_to_int(int: I192, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U192) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U192

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U192, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<200>

const UINT_NAME: &'static str = "uint200"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int200"

The name of the Int type: int<N>

const BITS: usize = 200usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<200, 4>

The signed integer Rust representation.

type Uint = Uint<200, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I200) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I200

Detokenizes a signed integer.

fn encode_packed_to_int(int: I200, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U200) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U200

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U200, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<208>

const UINT_NAME: &'static str = "uint208"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int208"

The name of the Int type: int<N>

const BITS: usize = 208usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<208, 4>

The signed integer Rust representation.

type Uint = Uint<208, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I208) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I208

Detokenizes a signed integer.

fn encode_packed_to_int(int: I208, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U208) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U208

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U208, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<216>

const UINT_NAME: &'static str = "uint216"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int216"

The name of the Int type: int<N>

const BITS: usize = 216usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<216, 4>

The signed integer Rust representation.

type Uint = Uint<216, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I216) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I216

Detokenizes a signed integer.

fn encode_packed_to_int(int: I216, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U216) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U216

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U216, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<224>

const UINT_NAME: &'static str = "uint224"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int224"

The name of the Int type: int<N>

const BITS: usize = 224usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<224, 4>

The signed integer Rust representation.

type Uint = Uint<224, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I224) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I224

Detokenizes a signed integer.

fn encode_packed_to_int(int: I224, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U224) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U224

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U224, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<232>

const UINT_NAME: &'static str = "uint232"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int232"

The name of the Int type: int<N>

const BITS: usize = 232usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<232, 4>

The signed integer Rust representation.

type Uint = Uint<232, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I232) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I232

Detokenizes a signed integer.

fn encode_packed_to_int(int: I232, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U232) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U232

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U232, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<24>

const UINT_NAME: &'static str = "uint24"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int24"

The name of the Int type: int<N>

const BITS: usize = 24usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<24, 1>

The signed integer Rust representation.

type Uint = Uint<24, 1>

The unsigned integer Rust representation.

fn tokenize_int(int: I24) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I24

Detokenizes a signed integer.

fn encode_packed_to_int(int: I24, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U24) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U24

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U24, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<240>

const UINT_NAME: &'static str = "uint240"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int240"

The name of the Int type: int<N>

const BITS: usize = 240usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<240, 4>

The signed integer Rust representation.

type Uint = Uint<240, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I240) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I240

Detokenizes a signed integer.

fn encode_packed_to_int(int: I240, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U240) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U240

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U240, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<248>

const UINT_NAME: &'static str = "uint248"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int248"

The name of the Int type: int<N>

const BITS: usize = 248usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<248, 4>

The signed integer Rust representation.

type Uint = Uint<248, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I248) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I248

Detokenizes a signed integer.

fn encode_packed_to_int(int: I248, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U248) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U248

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U248, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<256>

const UINT_NAME: &'static str = "uint256"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int256"

The name of the Int type: int<N>

const BITS: usize = 256usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<256, 4>

The signed integer Rust representation.

type Uint = Uint<256, 4>

The unsigned integer Rust representation.

fn tokenize_int(int: I256) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I256

Detokenizes a signed integer.

fn encode_packed_to_int(int: I256, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U256) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U256

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U256, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<32>

const UINT_NAME: &'static str = "uint32"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int32"

The name of the Int type: int<N>

const BITS: usize = 32usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = i32

The signed integer Rust representation.

type Uint = u32

The unsigned integer Rust representation.

fn tokenize_int(int: i32) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> i32

Detokenizes a signed integer.

fn encode_packed_to_int(int: i32, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: u32) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> u32

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: u32, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<40>

const UINT_NAME: &'static str = "uint40"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int40"

The name of the Int type: int<N>

const BITS: usize = 40usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<40, 1>

The signed integer Rust representation.

type Uint = Uint<40, 1>

The unsigned integer Rust representation.

fn tokenize_int(int: I40) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I40

Detokenizes a signed integer.

fn encode_packed_to_int(int: I40, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U40) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U40

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U40, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<48>

const UINT_NAME: &'static str = "uint48"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int48"

The name of the Int type: int<N>

const BITS: usize = 48usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<48, 1>

The signed integer Rust representation.

type Uint = Uint<48, 1>

The unsigned integer Rust representation.

fn tokenize_int(int: I48) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I48

Detokenizes a signed integer.

fn encode_packed_to_int(int: I48, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U48) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U48

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U48, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<56>

const UINT_NAME: &'static str = "uint56"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int56"

The name of the Int type: int<N>

const BITS: usize = 56usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<56, 1>

The signed integer Rust representation.

type Uint = Uint<56, 1>

The unsigned integer Rust representation.

fn tokenize_int(int: I56) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I56

Detokenizes a signed integer.

fn encode_packed_to_int(int: I56, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U56) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U56

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U56, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<64>

const UINT_NAME: &'static str = "uint64"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int64"

The name of the Int type: int<N>

const BITS: usize = 64usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = i64

The signed integer Rust representation.

type Uint = u64

The unsigned integer Rust representation.

fn tokenize_int(int: i64) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> i64

Detokenizes a signed integer.

fn encode_packed_to_int(int: i64, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: u64) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> u64

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: u64, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<72>

const UINT_NAME: &'static str = "uint72"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int72"

The name of the Int type: int<N>

const BITS: usize = 72usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<72, 2>

The signed integer Rust representation.

type Uint = Uint<72, 2>

The unsigned integer Rust representation.

fn tokenize_int(int: I72) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I72

Detokenizes a signed integer.

fn encode_packed_to_int(int: I72, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U72) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U72

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U72, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<8>

const UINT_NAME: &'static str = "uint8"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int8"

The name of the Int type: int<N>

const BITS: usize = 8usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = i8

The signed integer Rust representation.

type Uint = u8

The unsigned integer Rust representation.

fn tokenize_int(int: i8) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> i8

Detokenizes a signed integer.

fn encode_packed_to_int(int: i8, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: u8) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> u8

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: u8, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<80>

const UINT_NAME: &'static str = "uint80"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int80"

The name of the Int type: int<N>

const BITS: usize = 80usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<80, 2>

The signed integer Rust representation.

type Uint = Uint<80, 2>

The unsigned integer Rust representation.

fn tokenize_int(int: I80) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I80

Detokenizes a signed integer.

fn encode_packed_to_int(int: I80, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U80) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U80

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U80, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<88>

const UINT_NAME: &'static str = "uint88"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int88"

The name of the Int type: int<N>

const BITS: usize = 88usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<88, 2>

The signed integer Rust representation.

type Uint = Uint<88, 2>

The unsigned integer Rust representation.

fn tokenize_int(int: I88) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I88

Detokenizes a signed integer.

fn encode_packed_to_int(int: I88, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U88) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U88

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U88, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

impl SupportedInt for IntBitCount<96>

const UINT_NAME: &'static str = "uint96"

The name of the Uint type: uint<N>

const INT_NAME: &'static str = "int96"

The name of the Int type: int<N>

const BITS: usize = 96usize

The number of bits in the integer: BITS

const SKIP_BYTES: usize = 0usize

The difference between the representation’s and this integer’s bytes: (Self::Int::BITS - Self::BITS) / 8

type Int = Signed<96, 2>

The signed integer Rust representation.

type Uint = Uint<96, 2>

The unsigned integer Rust representation.

fn tokenize_int(int: I96) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> I96

Detokenizes a signed integer.

fn encode_packed_to_int(int: I96, out: &mut Vec<u8>)

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: U96) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> U96

Detokenizes an unsigned integer.

fn encode_packed_to_uint(uint: U96, out: &mut Vec<u8>)

ABI-encode an unsigned integer in packed mode.

const BYTES: usize = _

The number of bytes in the integer: BITS / 8

const WORD_MSB: usize = _

The index of the most significant byte in the Word type.

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