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

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 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 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 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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl SupportedInt for IntBitCount<8>

const UINT_NAME: &'static str = "uint8"

const INT_NAME: &'static str = "int8"

const BITS: usize = 8usize

const SKIP_BYTES: usize = 0usize

type Int = i8

type Uint = u8

impl SupportedInt for IntBitCount<16>

const UINT_NAME: &'static str = "uint16"

const INT_NAME: &'static str = "int16"

const BITS: usize = 16usize

const SKIP_BYTES: usize = 0usize

type Int = i16

type Uint = u16

impl SupportedInt for IntBitCount<24>

const UINT_NAME: &'static str = "uint24"

const INT_NAME: &'static str = "int24"

const BITS: usize = 24usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<24, 1>

type Uint = Uint<24, 1>

impl SupportedInt for IntBitCount<32>

const UINT_NAME: &'static str = "uint32"

const INT_NAME: &'static str = "int32"

const BITS: usize = 32usize

const SKIP_BYTES: usize = 0usize

type Int = i32

type Uint = u32

impl SupportedInt for IntBitCount<40>

const UINT_NAME: &'static str = "uint40"

const INT_NAME: &'static str = "int40"

const BITS: usize = 40usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<40, 1>

type Uint = Uint<40, 1>

impl SupportedInt for IntBitCount<48>

const UINT_NAME: &'static str = "uint48"

const INT_NAME: &'static str = "int48"

const BITS: usize = 48usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<48, 1>

type Uint = Uint<48, 1>

impl SupportedInt for IntBitCount<56>

const UINT_NAME: &'static str = "uint56"

const INT_NAME: &'static str = "int56"

const BITS: usize = 56usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<56, 1>

type Uint = Uint<56, 1>

impl SupportedInt for IntBitCount<64>

const UINT_NAME: &'static str = "uint64"

const INT_NAME: &'static str = "int64"

const BITS: usize = 64usize

const SKIP_BYTES: usize = 0usize

type Int = i64

type Uint = u64

impl SupportedInt for IntBitCount<72>

const UINT_NAME: &'static str = "uint72"

const INT_NAME: &'static str = "int72"

const BITS: usize = 72usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<72, 2>

type Uint = Uint<72, 2>

impl SupportedInt for IntBitCount<80>

const UINT_NAME: &'static str = "uint80"

const INT_NAME: &'static str = "int80"

const BITS: usize = 80usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<80, 2>

type Uint = Uint<80, 2>

impl SupportedInt for IntBitCount<88>

const UINT_NAME: &'static str = "uint88"

const INT_NAME: &'static str = "int88"

const BITS: usize = 88usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<88, 2>

type Uint = Uint<88, 2>

impl SupportedInt for IntBitCount<96>

const UINT_NAME: &'static str = "uint96"

const INT_NAME: &'static str = "int96"

const BITS: usize = 96usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<96, 2>

type Uint = Uint<96, 2>

impl SupportedInt for IntBitCount<104>

const UINT_NAME: &'static str = "uint104"

const INT_NAME: &'static str = "int104"

const BITS: usize = 104usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<104, 2>

type Uint = Uint<104, 2>

impl SupportedInt for IntBitCount<112>

const UINT_NAME: &'static str = "uint112"

const INT_NAME: &'static str = "int112"

const BITS: usize = 112usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<112, 2>

type Uint = Uint<112, 2>

impl SupportedInt for IntBitCount<120>

const UINT_NAME: &'static str = "uint120"

const INT_NAME: &'static str = "int120"

const BITS: usize = 120usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<120, 2>

type Uint = Uint<120, 2>

impl SupportedInt for IntBitCount<128>

const UINT_NAME: &'static str = "uint128"

const INT_NAME: &'static str = "int128"

const BITS: usize = 128usize

const SKIP_BYTES: usize = 0usize

type Int = i128

type Uint = u128

impl SupportedInt for IntBitCount<136>

const UINT_NAME: &'static str = "uint136"

const INT_NAME: &'static str = "int136"

const BITS: usize = 136usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<136, 3>

type Uint = Uint<136, 3>

impl SupportedInt for IntBitCount<144>

const UINT_NAME: &'static str = "uint144"

const INT_NAME: &'static str = "int144"

const BITS: usize = 144usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<144, 3>

type Uint = Uint<144, 3>

impl SupportedInt for IntBitCount<152>

const UINT_NAME: &'static str = "uint152"

const INT_NAME: &'static str = "int152"

const BITS: usize = 152usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<152, 3>

type Uint = Uint<152, 3>

impl SupportedInt for IntBitCount<160>

const UINT_NAME: &'static str = "uint160"

const INT_NAME: &'static str = "int160"

const BITS: usize = 160usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<160, 3>

type Uint = Uint<160, 3>

impl SupportedInt for IntBitCount<168>

const UINT_NAME: &'static str = "uint168"

const INT_NAME: &'static str = "int168"

const BITS: usize = 168usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<168, 3>

type Uint = Uint<168, 3>

impl SupportedInt for IntBitCount<176>

const UINT_NAME: &'static str = "uint176"

const INT_NAME: &'static str = "int176"

const BITS: usize = 176usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<176, 3>

type Uint = Uint<176, 3>

impl SupportedInt for IntBitCount<184>

const UINT_NAME: &'static str = "uint184"

const INT_NAME: &'static str = "int184"

const BITS: usize = 184usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<184, 3>

type Uint = Uint<184, 3>

impl SupportedInt for IntBitCount<192>

const UINT_NAME: &'static str = "uint192"

const INT_NAME: &'static str = "int192"

const BITS: usize = 192usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<192, 3>

type Uint = Uint<192, 3>

impl SupportedInt for IntBitCount<200>

const UINT_NAME: &'static str = "uint200"

const INT_NAME: &'static str = "int200"

const BITS: usize = 200usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<200, 4>

type Uint = Uint<200, 4>

impl SupportedInt for IntBitCount<208>

const UINT_NAME: &'static str = "uint208"

const INT_NAME: &'static str = "int208"

const BITS: usize = 208usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<208, 4>

type Uint = Uint<208, 4>

impl SupportedInt for IntBitCount<216>

const UINT_NAME: &'static str = "uint216"

const INT_NAME: &'static str = "int216"

const BITS: usize = 216usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<216, 4>

type Uint = Uint<216, 4>

impl SupportedInt for IntBitCount<224>

const UINT_NAME: &'static str = "uint224"

const INT_NAME: &'static str = "int224"

const BITS: usize = 224usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<224, 4>

type Uint = Uint<224, 4>

impl SupportedInt for IntBitCount<232>

const UINT_NAME: &'static str = "uint232"

const INT_NAME: &'static str = "int232"

const BITS: usize = 232usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<232, 4>

type Uint = Uint<232, 4>

impl SupportedInt for IntBitCount<240>

const UINT_NAME: &'static str = "uint240"

const INT_NAME: &'static str = "int240"

const BITS: usize = 240usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<240, 4>

type Uint = Uint<240, 4>

impl SupportedInt for IntBitCount<248>

const UINT_NAME: &'static str = "uint248"

const INT_NAME: &'static str = "int248"

const BITS: usize = 248usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<248, 4>

type Uint = Uint<248, 4>

impl SupportedInt for IntBitCount<256>

const UINT_NAME: &'static str = "uint256"

const INT_NAME: &'static str = "int256"

const BITS: usize = 256usize

const SKIP_BYTES: usize = 0usize

type Int = Signed<256, 4>

type Uint = Uint<256, 4>