Struct chaindexing::I256

pub struct I256(/* private fields */);

Little-endian 256-bit signed integer.

Diversion from standard numeric types

The right shift operator on I256 doesn’t act in the same manner as standard numeric types (e.g. i8, i16 etc). On standard types if the number is negative right shift will perform an arithmetic shift, whereas on I256 this will perform a bit-wise shift. Arithmetic shift on I256 is done via the asr and asl functions.

Implementations

impl I256

pub const MAX: I256 = _

Maximum value.

pub const MIN: I256 = _

Minimum value.

pub const fn zero() -> I256

Zero (additive identity) of this type.

pub const fn one() -> I256

One (multiplicative identity) of this type.

pub const fn minus_one() -> I256

Minus one (multiplicative inverse) of this type.

pub const fn max_value() -> I256

The maximum value which can be inhabited by this type.

pub const fn min_value() -> I256

The minimum value which can be inhabited by this type.

pub fn overflowing_from_sign_and_abs(sign: Sign, abs: U256) -> (I256, bool)

Creates an I256 from a sign and an absolute value. Returns the value and a bool that is true if the conversion caused an overflow.

pub fn checked_from_sign_and_abs(sign: Sign, abs: U256) -> Option<I256>

Creates an I256 from an absolute value and a negative flag. Returns None if it would overflow an I256.

pub fn into_sign_and_abs(self) -> (Sign, U256)

Splits a I256 into its absolute value and negative flag.

pub const fn sign(self) -> Sign

Returns the sign of self.

pub const fn from_raw(raw: U256) -> I256

Coerces an unsigned integer into a signed one. If the unsigned integer is greater than the greater than or equal to 1 << 255, then the result will overflow into a negative value.

pub const fn into_raw(self) -> U256

Returns the signed integer as a unsigned integer. If the value of self negative, then the two’s complement of its absolute value will be returned.

pub fn from_dec_str(value: &str) -> Result<I256, ParseI256Error>

Convert from a decimal string.

pub fn from_hex_str(value: &str) -> Result<I256, ParseI256Error>

Convert from a hexadecimal string.

pub fn signum(self) -> I256

Returns a number representing sign of self.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

pub const fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

pub const fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

pub const fn is_zero(self) -> bool

Returns true if self is zero and false if the number is negative or positive.

pub fn bits(&self) -> u32

Return the least number of bits needed to represent the number.

pub const fn bit(&self, index: usize) -> bool

Return if specific bit is set.

Panics

If index exceeds the bit width of the number.

pub const fn byte(&self, index: usize) -> u8

Return specific byte.

Panics

If index exceeds the byte width of the number.

pub fn count_ones(&self) -> u32

Returns the number of ones in the binary representation of self.

pub fn count_zeros(&self) -> u32

Returns the number of zeros in the binary representation of self.

pub fn leading_zeros(&self) -> u32

Returns the number of leading zeros in the binary representation of self.

pub fn trailing_zeros(&self) -> u32

Returns the number of leading zeros in the binary representation of self.

pub fn to_big_endian(&self, bytes: &mut [u8])

Write to the slice in big-endian format.

Panics

If the given slice is not exactly 32 bytes long.

pub fn to_little_endian(&self, bytes: &mut [u8])

Write to the slice in little-endian format.

Panics

If the given slice is not exactly 32 bytes long.

impl I256

pub fn abs(self) -> I256

Computes the absolute value of self.

Overflow behavior

The absolute value of I256::MIN cannot be represented as an I256 and attempting to calculate it will cause an overflow. This means that code in debug mode will trigger a panic on this case and optimized code will return I256::MIN without a panic.

pub fn overflowing_abs(self) -> (I256, bool)

Computes the absolute value of self.

Returns a tuple of the absolute version of self along with a boolean indicating whether an overflow happened. If self is the minimum value then the minimum value will be returned again and true will be returned for an overflow happening.

pub fn checked_abs(self) -> Option<I256>

Checked absolute value. Computes self.abs(), returning None if self == MIN.

pub fn saturating_abs(self) -> I256

Saturating absolute value. Computes self.abs(), returning MAX if self == MIN instead of overflowing.

pub fn wrapping_abs(self) -> I256

Wrapping absolute value. Computes self.abs(), wrapping around at the boundary of the type.

pub fn unsigned_abs(self) -> U256

Computes the absolute value of self without any wrapping or panicking.

pub fn overflowing_neg(self) -> (I256, bool)

Negates self, overflowing if this is equal to the minimum value.

Returns a tuple of the negated version of self along with a boolean indicating whether an overflow happened. If self is the minimum value, then the minimum value will be returned again and true will be returned for an overflow happening.

pub fn checked_neg(self) -> Option<I256>

Checked negation. Computes -self, returning None if self == MIN.

pub fn saturating_neg(self) -> I256

Saturating negation. Computes -self, returning MAX if self == MIN instead of overflowing.

pub fn wrapping_neg(self) -> I256

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one negates MIN on a signed type (where MIN is the negative minimal value for the type); this is a positive value that is too large to represent in the type. In such a case, this function returns MIN itself.

pub fn overflowing_add(self, rhs: I256) -> (I256, bool)

Calculates self + rhs

Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

pub fn checked_add(self, rhs: I256) -> Option<I256>

Checked integer addition. Computes self + rhs, returning None if overflow occurred.

pub fn saturating_add(self, rhs: I256) -> I256

Saturating integer addition. Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_add(self, rhs: I256) -> I256

Wrapping (modular) addition. Computes self + rhs, wrapping around at the boundary of the type.

pub fn overflowing_sub(self, rhs: I256) -> (I256, bool)

Calculates self - rhs

Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

pub fn checked_sub(self, rhs: I256) -> Option<I256>

Checked integer subtraction. Computes self - rhs, returning None if overflow occurred.

pub fn saturating_sub(self, rhs: I256) -> I256

Saturating integer subtraction. Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_sub(self, rhs: I256) -> I256

Wrapping (modular) subtraction. Computes self - rhs, wrapping around at the boundary of the type.

pub fn overflowing_mul(self, rhs: I256) -> (I256, bool)

Calculates self * rhs

Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

pub fn checked_mul(self, rhs: I256) -> Option<I256>

Checked integer multiplication. Computes self * rhs, returning None if overflow occurred.

pub fn saturating_mul(self, rhs: I256) -> I256

Saturating integer multiplication. Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_mul(self, rhs: I256) -> I256

Wrapping (modular) multiplication. Computes self * rhs, wrapping around at the boundary of the type.

pub fn overflowing_div(self, rhs: I256) -> (I256, bool)

Calculates self / rhs

Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then self is returned.

Panics

If rhs is 0.

pub fn checked_div(self, rhs: I256) -> Option<I256>

Checked integer division. Computes self / rhs, returning None if rhs == 0 or the division results in overflow.

pub fn saturating_div(self, rhs: I256) -> I256

Saturating integer division. Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Panics

If rhs is 0.

pub fn wrapping_div(self, rhs: I256) -> I256

Wrapping (modular) division. Computes self / rhs, wrapping around at the boundary of the type.

The only case where such wrapping can occur is when one divides MIN / -1 on a signed type (where MIN is the negative minimal value for the type); this is equivalent to -MIN, a positive value that is too large to represent in the type. In such a case, this function returns MIN itself.

Panics

If rhs is 0.

pub fn overflowing_rem(self, rhs: I256) -> (I256, bool)

Calculates self % rhs

Returns a tuple of the remainder after dividing along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then 0 is returned.

Panics

If rhs is 0.

pub fn checked_rem(self, rhs: I256) -> Option<I256>

Checked integer remainder. Computes self % rhs, returning None if rhs == 0 or the division results in overflow.

pub fn wrapping_rem(self, rhs: I256) -> I256

Wrapping (modular) remainder. Computes self % rhs, wrapping around at the boundary of the type.

Such wrap-around never actually occurs mathematically; implementation artifacts make x % y invalid for MIN / -1 on a signed type (where MIN is the negative minimal value). In such a case, this function returns 0.

Panics

If rhs is 0.

pub fn div_euclid(self, rhs: I256) -> I256

Calculates the quotient of Euclidean division of self by rhs.

This computes the integer q such that self = q * rhs + r, with r = self.rem_euclid(rhs) and 0 <= r < abs(rhs).

In other words, the result is self / rhs rounded to the integer q such that self >= q * rhs. If self > 0, this is equal to round towards zero (the default in Rust); if self < 0, this is equal to round towards +/- infinity.

Panics

If rhs is 0 or the division results in overflow.

pub fn overflowing_div_euclid(self, rhs: I256) -> (I256, bool)

Calculates the quotient of Euclidean division self.div_euclid(rhs).

Returns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then self is returned.

Panics

If rhs is 0.

pub fn checked_div_euclid(self, rhs: I256) -> Option<I256>

Checked Euclidean division. Computes self.div_euclid(rhs), returning None if rhs == 0 or the division results in overflow.

pub fn wrapping_div_euclid(self, rhs: I256) -> I256

Wrapping Euclidean division. Computes self.div_euclid(rhs), wrapping around at the boundary of the type.

Wrapping will only occur in MIN / -1 on a signed type (where MIN is the negative minimal value for the type). This is equivalent to -MIN, a positive value that is too large to represent in the type. In this case, this method returns MIN itself.

Panics

If rhs is 0.

pub fn rem_euclid(self, rhs: I256) -> I256

Calculates the least nonnegative remainder of self (mod rhs).

This is done as if by the Euclidean division algorithm – given r = self.rem_euclid(rhs), self = rhs * self.div_euclid(rhs) + r, and 0 <= r < abs(rhs).

Panics

If rhs is 0 or the division results in overflow.

pub fn overflowing_rem_euclid(self, rhs: I256) -> (I256, bool)

Overflowing Euclidean remainder. Calculates self.rem_euclid(rhs).

Returns a tuple of the remainder after dividing along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would occur then 0 is returned.

Panics

If rhs is 0.

pub fn wrapping_rem_euclid(self, rhs: I256) -> I256

Wrapping Euclidean remainder. Computes self.rem_euclid(rhs), wrapping around at the boundary of the type.

Wrapping will only occur in MIN % -1 on a signed type (where MIN is the negative minimal value for the type). In this case, this method returns 0.

Panics

If rhs is 0.

pub fn checked_rem_euclid(self, rhs: I256) -> Option<I256>

Checked Euclidean remainder. Computes self.rem_euclid(rhs), returning None if rhs == 0 or the division results in overflow.

pub fn exp10(n: usize) -> I256

Create 10**n as this type.

Panics

If the result overflows the type.

pub fn pow(self, exp: u32) -> I256

Raises self to the power of exp, using exponentiation by squaring.

Panics

If the result overflows the type in debug mode.

pub fn overflowing_pow(self, exp: u32) -> (I256, bool)

Raises self to the power of exp, using exponentiation by squaring.

Returns a tuple of the exponentiation along with a bool indicating whether an overflow happened.

pub fn checked_pow(self, exp: u32) -> Option<I256>

Checked exponentiation. Computes self.pow(exp), returning None if overflow occurred.

pub fn saturating_pow(self, exp: u32) -> I256

Saturating integer exponentiation. Computes self.pow(exp), saturating at the numeric bounds instead of overflowing.

pub fn wrapping_pow(self, exp: u32) -> I256

Raises self to the power of exp, wrapping around at the boundary of the type.

pub fn overflowing_shl(self, rhs: usize) -> (I256, bool)

Shifts self left by rhs bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shift value was larger than or equal to the number of bits.

pub fn checked_shl(self, rhs: usize) -> Option<I256>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

pub fn wrapping_shl(self, rhs: usize) -> I256

Wrapping shift left. Computes self << rhs, returning 0 if larger than or equal to the number of bits in self.

pub fn overflowing_shr(self, rhs: usize) -> (I256, bool)

Shifts self right by rhs bits.

Returns a tuple of the shifted version of self along with a boolean indicating whether the shift value was larger than or equal to the number of bits.

pub fn checked_shr(self, rhs: usize) -> Option<I256>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

pub fn wrapping_shr(self, rhs: usize) -> I256

Wrapping shift right. Computes self >> rhs, returning 0 if larger than or equal to the number of bits in self.

pub fn asr(self, rhs: usize) -> I256

Arithmetic shift right operation. Computes self >> rhs maintaining the original sign. If the number is positive this is the same as logic shift right.

pub fn asl(self, rhs: usize) -> Option<I256>

Arithmetic shift left operation. Computes self << rhs, checking for overflow on the final result.

Returns None if the operation overflowed (most significant bit changes).

pub fn twos_complement(self) -> U256

Compute the two’s complement of this number.

impl I256

pub const fn low_u8(&self) -> u8

Low word.

pub fn as_u8(&self) -> u8

Conversion to u8 with overflow checking.

Panics

If the number is outside the u8 valid range.

pub const fn low_i8(&self) -> i8

Low word.

pub fn as_i8(&self) -> i8

Conversion to i8 with overflow checking.

Panics

If the number is outside the i8 valid range.

pub const fn low_u16(&self) -> u16

Low word.

pub fn as_u16(&self) -> u16

Conversion to u16 with overflow checking.

Panics

If the number is outside the u16 valid range.

pub const fn low_i16(&self) -> i16

Low word.

pub fn as_i16(&self) -> i16

Conversion to i16 with overflow checking.

Panics

If the number is outside the i16 valid range.

pub const fn low_u32(&self) -> u32

Low word.

pub fn as_u32(&self) -> u32

Conversion to u32 with overflow checking.

Panics

If the number is outside the u32 valid range.

pub const fn low_i32(&self) -> i32

Low word.

pub fn as_i32(&self) -> i32

Conversion to i32 with overflow checking.

Panics

If the number is outside the i32 valid range.

pub const fn low_u64(&self) -> u64

Low word.

pub fn as_u64(&self) -> u64

Conversion to u64 with overflow checking.

Panics

If the number is outside the u64 valid range.

pub const fn low_i64(&self) -> i64

Low word.

pub fn as_i64(&self) -> i64

Conversion to i64 with overflow checking.

Panics

If the number is outside the i64 valid range.

pub const fn low_usize(&self) -> usize

Low word.

pub fn as_usize(&self) -> usize

Conversion to usize with overflow checking.

Panics

If the number is outside the usize valid range.

pub const fn low_isize(&self) -> isize

Low word.

pub fn as_isize(&self) -> isize

Conversion to isize with overflow checking.

Panics

If the number is outside the isize valid range.

pub const fn low_u128(&self) -> u128

Low word.

pub fn as_u128(&self) -> u128

Conversion to u128 with overflow checking.

Panics

If the number is outside the u128 valid range.

pub const fn low_i128(&self) -> i128

Low word.

pub fn as_i128(&self) -> i128

Conversion to i128 with overflow checking.

Panics

If the number is outside the i128 valid range.

Trait Implementations

impl AbiDecode for I256

fn decode(bytes: impl AsRef<[u8]>) -> Result<I256, AbiError>

Decodes the ABI encoded data

fn decode_hex(data: impl AsRef<str>) -> Result<Self, AbiError>

Decode hex encoded ABI encoded data

impl AbiEncode for I256

fn encode(self) -> Vec<u8>

ABI encode the type

fn encode_hex(self) -> String

where Self: Sized,

Returns the encoded value as hex string, with a 0x prefix

impl AbiType for I256

fn param_type() -> ParamType

The native ABI type this type represents.

fn minimum_size() -> usize

A hint of the minimum number of bytes this type takes up in the ABI.

impl<T> Add<T> for I256

where T: Into<I256>,

type Output = I256

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <I256 as Add<T>>::Output

Performs the + operation.

impl<T> AddAssign<T> for I256

where T: Into<I256>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl BitAnd for I256

type Output = I256

The resulting type after applying the & operator.

fn bitand(self, rhs: I256) -> <I256 as BitAnd>::Output

Performs the & operation.

impl BitAndAssign for I256

fn bitand_assign(&mut self, rhs: I256)

Performs the &= operation.

impl BitOr for I256

type Output = I256

The resulting type after applying the | operator.

fn bitor(self, rhs: I256) -> <I256 as BitOr>::Output

Performs the | operation.

impl BitOrAssign for I256

fn bitor_assign(&mut self, rhs: I256)

Performs the |= operation.

impl BitXor for I256

type Output = I256

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: I256) -> <I256 as BitXor>::Output

Performs the ^ operation.

impl BitXorAssign for I256

fn bitxor_assign(&mut self, rhs: I256)

Performs the ^= operation.

impl Clone for I256

fn clone(&self) -> I256

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for I256

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for I256

fn default() -> I256

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for I256

fn deserialize<__D>( __deserializer: __D ) -> Result<I256, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for I256

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Div<T> for I256

where T: Into<I256>,

type Output = I256

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <I256 as Div<T>>::Output

Performs the / operation.

impl<T> DivAssign<T> for I256

where T: Into<I256>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl From<ParseUnits> for I256

fn from(n: ParseUnits) -> I256

Converts to this type from the input type.

impl From<i128> for I256

fn from(value: i128) -> I256

Converts to this type from the input type.

impl From<i16> for I256

fn from(value: i16) -> I256

Converts to this type from the input type.

impl From<i32> for I256

fn from(value: i32) -> I256

Converts to this type from the input type.

impl From<i64> for I256

fn from(value: i64) -> I256

Converts to this type from the input type.

impl From<i8> for I256

fn from(value: i8) -> I256

Converts to this type from the input type.

impl From<isize> for I256

fn from(value: isize) -> I256

Converts to this type from the input type.

impl From<u128> for I256

fn from(value: u128) -> I256

Converts to this type from the input type.

impl From<u16> for I256

fn from(value: u16) -> I256

Converts to this type from the input type.

impl From<u32> for I256

fn from(value: u32) -> I256

Converts to this type from the input type.

impl From<u64> for I256

fn from(value: u64) -> I256

Converts to this type from the input type.

impl From<u8> for I256

fn from(value: u8) -> I256

Converts to this type from the input type.

impl From<usize> for I256

fn from(value: usize) -> I256

Converts to this type from the input type.

impl FromStr for I256

type Err = ParseI256Error

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<I256, <I256 as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for I256

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for I256

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Mul<T> for I256

where T: Into<I256>,

type Output = I256

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <I256 as Mul<T>>::Output

Performs the * operation.

impl<T> MulAssign<T> for I256

where T: Into<I256>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl Neg for I256

type Output = I256

The resulting type after applying the - operator.

fn neg(self) -> <I256 as Neg>::Output

Performs the unary - operation.

impl Not for I256

type Output = I256

The resulting type after applying the ! operator.

fn not(self) -> <I256 as Not>::Output

Performs the unary ! operation.

impl Ord for I256

fn cmp(&self, other: &I256) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for I256

fn eq(&self, other: &I256) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for I256

fn partial_cmp(&self, other: &I256) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Product<T> for I256

where T: Into<I256>,

fn product<I>(iter: I) -> I256

where I: Iterator<Item = T>,

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T> Rem<T> for I256

where T: Into<I256>,

type Output = I256

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> <I256 as Rem<T>>::Output

Performs the % operation.

impl<T> RemAssign<T> for I256

where T: Into<I256>,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl Serialize for I256

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Shl<i16> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> <I256 as Shl<i16>>::Output

Performs the << operation.

impl Shl<i32> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> <I256 as Shl<i32>>::Output

Performs the << operation.

impl Shl<i64> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> <I256 as Shl<i64>>::Output

Performs the << operation.

impl Shl<i8> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> <I256 as Shl<i8>>::Output

Performs the << operation.

impl Shl<isize> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> <I256 as Shl<isize>>::Output

Performs the << operation.

impl Shl<u16> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> <I256 as Shl<u16>>::Output

Performs the << operation.

impl Shl<u32> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> <I256 as Shl<u32>>::Output

Performs the << operation.

impl Shl<u64> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> <I256 as Shl<u64>>::Output

Performs the << operation.

impl Shl<u8> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> <I256 as Shl<u8>>::Output

Performs the << operation.

impl Shl<usize> for I256

type Output = I256

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> <I256 as Shl<usize>>::Output

Performs the << operation.

impl ShlAssign<i16> for I256

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl ShlAssign<i32> for I256

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl ShlAssign<i64> for I256

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl ShlAssign<i8> for I256

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl ShlAssign<isize> for I256

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl ShlAssign<u16> for I256

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl ShlAssign<u32> for I256

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl ShlAssign<u64> for I256

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl ShlAssign<u8> for I256

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl ShlAssign<usize> for I256

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<i16> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> <I256 as Shr<i16>>::Output

Performs the >> operation.

impl Shr<i32> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> <I256 as Shr<i32>>::Output

Performs the >> operation.

impl Shr<i64> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> <I256 as Shr<i64>>::Output

Performs the >> operation.

impl Shr<i8> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> <I256 as Shr<i8>>::Output

Performs the >> operation.

impl Shr<isize> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> <I256 as Shr<isize>>::Output

Performs the >> operation.

impl Shr<u16> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> <I256 as Shr<u16>>::Output

Performs the >> operation.

impl Shr<u32> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> <I256 as Shr<u32>>::Output

Performs the >> operation.

impl Shr<u64> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> <I256 as Shr<u64>>::Output

Performs the >> operation.

impl Shr<u8> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> <I256 as Shr<u8>>::Output

Performs the >> operation.

impl Shr<usize> for I256

type Output = I256

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> <I256 as Shr<usize>>::Output

Performs the >> operation.

impl ShrAssign<i16> for I256

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl ShrAssign<i32> for I256

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl ShrAssign<i64> for I256

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl ShrAssign<i8> for I256

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl ShrAssign<isize> for I256

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl ShrAssign<u16> for I256

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl ShrAssign<u32> for I256

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl ShrAssign<u64> for I256

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl ShrAssign<u8> for I256

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl ShrAssign<usize> for I256

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<T> Sub<T> for I256

where T: Into<I256>,

type Output = I256

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <I256 as Sub<T>>::Output

Performs the - operation.

impl<T> SubAssign<T> for I256

where T: Into<I256>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T> Sum<T> for I256

where T: Into<I256>,

fn sum<I>(iter: I) -> I256

where I: Iterator<Item = T>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Tokenizable for I256

fn from_token(token: Token) -> Result<I256, InvalidOutputType>

Converts a Token into expected type.

fn into_token(self) -> Token

Converts a specified type back into token.

impl TryFrom<&String> for I256

type Error = <I256 as FromStr>::Err

The type returned in the event of a conversion error.

fn try_from(value: &String) -> Result<I256, <I256 as TryFrom<&String>>::Error>

Performs the conversion.

impl TryFrom<&str> for I256

type Error = <I256 as FromStr>::Err

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<I256, <I256 as TryFrom<&str>>::Error>

Performs the conversion.

impl TryFrom<I256> for U256

type Error = TryFromBigIntError

The type returned in the event of a conversion error.

fn try_from(value: I256) -> Result<U256, <U256 as TryFrom<I256>>::Error>

Performs the conversion.

impl TryFrom<String> for I256

type Error = <I256 as FromStr>::Err

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<I256, <I256 as TryFrom<String>>::Error>

Performs the conversion.

impl TryFrom<U256> for I256

type Error = TryFromBigIntError

The type returned in the event of a conversion error.

fn try_from(from: U256) -> Result<I256, <I256 as TryFrom<U256>>::Error>

Performs the conversion.

impl UpperHex for I256

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl AbiArrayType for I256

impl Copy for I256

impl Eq for I256

impl StructuralPartialEq for I256

impl TokenizableItem for I256