Trait alloy_sol_types::sol_data::SupportedInt

pub trait SupportedInt: Sealed {
    type Int: Sized + Copy + PartialOrd + Ord + Eq + Hash + Not + BitAnd + BitOr + BitXor + Add + Sub + Mul + Div + Rem + AddAssign + SubAssign + MulAssign + DivAssign + RemAssign + Debug + Display + LowerHex + UpperHex + Octal + Binary;
    type Uint: Sized + Copy + PartialOrd + Ord + Eq + Hash + Not + BitAnd + BitOr + BitXor + Add + Sub + Mul + Div + Rem + AddAssign + SubAssign + MulAssign + DivAssign + RemAssign + Debug + Display + LowerHex + UpperHex + Octal + Binary;

    const INT_NAME: &'static str;
    const UINT_NAME: &'static str;
    const BITS: usize;
    const SKIP_BYTES: usize;
    const BYTES: usize = _;
    const WORD_MSB: usize = _;

    // Required methods
    fn tokenize_int(int: Self::Int) -> WordToken;
    fn detokenize_int(token: WordToken) -> Self::Int;
    fn encode_packed_to_int(int: Self::Int, out: &mut Vec<u8>);
    fn tokenize_uint(uint: Self::Uint) -> WordToken;
    fn detokenize_uint(token: WordToken) -> Self::Uint;
    fn encode_packed_to_uint(uint: Self::Uint, out: &mut Vec<u8>);
}

Expand description

Statically guarantees that a Int or Uint bit count is marked as supported.

This trait is sealed: the list of implementors below is total.

Users do not have the ability to mark additional IntBitCount<N> values as supported. Only Int and Uint with supported byte counts are constructable.

Required Associated Types§

type Int: Sized + Copy + PartialOrd + Ord + Eq + Hash + Not + BitAnd + BitOr + BitXor + Add + Sub + Mul + Div + Rem + AddAssign + SubAssign + MulAssign + DivAssign + RemAssign + Debug + Display + LowerHex + UpperHex + Octal + Binary

The signed integer Rust representation.

type Uint: Sized + Copy + PartialOrd + Ord + Eq + Hash + Not + BitAnd + BitOr + BitXor + Add + Sub + Mul + Div + Rem + AddAssign + SubAssign + MulAssign + DivAssign + RemAssign + Debug + Display + LowerHex + UpperHex + Octal + Binary

The unsigned integer Rust representation.

Required Associated Constants§

const INT_NAME: &'static str

The name of the Int type: int<N>

const UINT_NAME: &'static str

The name of the Uint type: uint<N>

const BITS: usize

The number of bits in the integer: BITS

Note that this is not equal to Self::Int::BITS.

const SKIP_BYTES: usize

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

E.g.: word[Self::WORD_MSB - Self::SKIP_BYTES..] == int.to_be_bytes()

Provided Associated Constants§

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.

E.g.: word[Self::WORD_MSB..] == int.to_be_bytes()[Self::SKIP_BYTES..]

Required Methods§

fn tokenize_int(int: Self::Int) -> WordToken

Tokenizes a signed integer.

fn detokenize_int(token: WordToken) -> Self::Int

Detokenizes a signed integer.

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

ABI-encode a signed integer in packed mode.

fn tokenize_uint(uint: Self::Uint) -> WordToken

Tokenizes an unsigned integer.

fn detokenize_uint(token: WordToken) -> Self::Uint

Detokenizes an unsigned integer.

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

ABI-encode an unsigned integer in packed mode.

Object Safety§

This trait is not object safe.

Implementors§

impl SupportedInt for IntBitCount<8>

type Int = i8

type Uint = u8

const UINT_NAME: &'static str = "uint8"

const INT_NAME: &'static str = "int8"

const BITS: usize = 8usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<16>

type Int = i16

type Uint = u16

const UINT_NAME: &'static str = "uint16"

const INT_NAME: &'static str = "int16"

const BITS: usize = 16usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<24>

type Int = Signed<24, 1>

type Uint = Uint<24, 1>

const UINT_NAME: &'static str = "uint24"

const INT_NAME: &'static str = "int24"

const BITS: usize = 24usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<32>

type Int = i32

type Uint = u32

const UINT_NAME: &'static str = "uint32"

const INT_NAME: &'static str = "int32"

const BITS: usize = 32usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<40>

type Int = Signed<40, 1>

type Uint = Uint<40, 1>

const UINT_NAME: &'static str = "uint40"

const INT_NAME: &'static str = "int40"

const BITS: usize = 40usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<48>

type Int = Signed<48, 1>

type Uint = Uint<48, 1>

const UINT_NAME: &'static str = "uint48"

const INT_NAME: &'static str = "int48"

const BITS: usize = 48usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<56>

type Int = Signed<56, 1>

type Uint = Uint<56, 1>

const UINT_NAME: &'static str = "uint56"

const INT_NAME: &'static str = "int56"

const BITS: usize = 56usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<64>

type Int = i64

type Uint = u64

const UINT_NAME: &'static str = "uint64"

const INT_NAME: &'static str = "int64"

const BITS: usize = 64usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<72>

type Int = Signed<72, 2>

type Uint = Uint<72, 2>

const UINT_NAME: &'static str = "uint72"

const INT_NAME: &'static str = "int72"

const BITS: usize = 72usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<80>

type Int = Signed<80, 2>

type Uint = Uint<80, 2>

const UINT_NAME: &'static str = "uint80"

const INT_NAME: &'static str = "int80"

const BITS: usize = 80usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<88>

type Int = Signed<88, 2>

type Uint = Uint<88, 2>

const UINT_NAME: &'static str = "uint88"

const INT_NAME: &'static str = "int88"

const BITS: usize = 88usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<96>

type Int = Signed<96, 2>

type Uint = Uint<96, 2>

const UINT_NAME: &'static str = "uint96"

const INT_NAME: &'static str = "int96"

const BITS: usize = 96usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<104>

type Int = Signed<104, 2>

type Uint = Uint<104, 2>

const UINT_NAME: &'static str = "uint104"

const INT_NAME: &'static str = "int104"

const BITS: usize = 104usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<112>

type Int = Signed<112, 2>

type Uint = Uint<112, 2>

const UINT_NAME: &'static str = "uint112"

const INT_NAME: &'static str = "int112"

const BITS: usize = 112usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<120>

type Int = Signed<120, 2>

type Uint = Uint<120, 2>

const UINT_NAME: &'static str = "uint120"

const INT_NAME: &'static str = "int120"

const BITS: usize = 120usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<128>

type Int = i128

type Uint = u128

const UINT_NAME: &'static str = "uint128"

const INT_NAME: &'static str = "int128"

const BITS: usize = 128usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<136>

type Int = Signed<136, 3>

type Uint = Uint<136, 3>

const UINT_NAME: &'static str = "uint136"

const INT_NAME: &'static str = "int136"

const BITS: usize = 136usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<144>

type Int = Signed<144, 3>

type Uint = Uint<144, 3>

const UINT_NAME: &'static str = "uint144"

const INT_NAME: &'static str = "int144"

const BITS: usize = 144usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<152>

type Int = Signed<152, 3>

type Uint = Uint<152, 3>

const UINT_NAME: &'static str = "uint152"

const INT_NAME: &'static str = "int152"

const BITS: usize = 152usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<160>

type Int = Signed<160, 3>

type Uint = Uint<160, 3>

const UINT_NAME: &'static str = "uint160"

const INT_NAME: &'static str = "int160"

const BITS: usize = 160usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<168>

type Int = Signed<168, 3>

type Uint = Uint<168, 3>

const UINT_NAME: &'static str = "uint168"

const INT_NAME: &'static str = "int168"

const BITS: usize = 168usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<176>

type Int = Signed<176, 3>

type Uint = Uint<176, 3>

const UINT_NAME: &'static str = "uint176"

const INT_NAME: &'static str = "int176"

const BITS: usize = 176usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<184>

type Int = Signed<184, 3>

type Uint = Uint<184, 3>

const UINT_NAME: &'static str = "uint184"

const INT_NAME: &'static str = "int184"

const BITS: usize = 184usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<192>

type Int = Signed<192, 3>

type Uint = Uint<192, 3>

const UINT_NAME: &'static str = "uint192"

const INT_NAME: &'static str = "int192"

const BITS: usize = 192usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<200>

type Int = Signed<200, 4>

type Uint = Uint<200, 4>

const UINT_NAME: &'static str = "uint200"

const INT_NAME: &'static str = "int200"

const BITS: usize = 200usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<208>

type Int = Signed<208, 4>

type Uint = Uint<208, 4>

const UINT_NAME: &'static str = "uint208"

const INT_NAME: &'static str = "int208"

const BITS: usize = 208usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<216>

type Int = Signed<216, 4>

type Uint = Uint<216, 4>

const UINT_NAME: &'static str = "uint216"

const INT_NAME: &'static str = "int216"

const BITS: usize = 216usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<224>

type Int = Signed<224, 4>

type Uint = Uint<224, 4>

const UINT_NAME: &'static str = "uint224"

const INT_NAME: &'static str = "int224"

const BITS: usize = 224usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<232>

type Int = Signed<232, 4>

type Uint = Uint<232, 4>

const UINT_NAME: &'static str = "uint232"

const INT_NAME: &'static str = "int232"

const BITS: usize = 232usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<240>

type Int = Signed<240, 4>

type Uint = Uint<240, 4>

const UINT_NAME: &'static str = "uint240"

const INT_NAME: &'static str = "int240"

const BITS: usize = 240usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<248>

type Int = Signed<248, 4>

type Uint = Uint<248, 4>

const UINT_NAME: &'static str = "uint248"

const INT_NAME: &'static str = "int248"

const BITS: usize = 248usize

const SKIP_BYTES: usize = 0usize

impl SupportedInt for IntBitCount<256>

type Int = Signed<256, 4>

type Uint = Uint<256, 4>

const UINT_NAME: &'static str = "uint256"

const INT_NAME: &'static str = "int256"

const BITS: usize = 256usize

const SKIP_BYTES: usize = 0usize