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.