Struct BigUint

pub struct BigUint<M>
where
    M: ManagedTypeApi,
{ /* private fields */ }

Implementations

impl<M> BigUint<M>

where M: ManagedTypeApi,

pub unsafe fn new_uninit() -> BigUint<M>

Creates a new object, without initializing it.

Safety

The value needs to be initialized after creation, otherwise the VM will halt the first time the value is attempted to be read.

pub fn as_big_int(&self) -> &BigInt<M>

pub fn into_big_int(self) -> BigInt<M>

impl<M> BigUint<M>

where M: ManagedTypeApi,

pub fn to_alloc(&self) -> BigUint

impl<M> BigUint<M>

where M: ManagedTypeApi,

More conversions here.

pub fn zero() -> BigUint<M>

pub fn zero_ref() -> ManagedRef<'static, M, BigUint<M>>

pub fn to_u64(&self) -> Option<u64>

pub fn overwrite_u64(&mut self, value: u64)

pub fn from_bytes_be(bytes: &[u8]) -> BigUint<M>

pub fn to_bytes_be(&self) -> BoxedBytes

pub fn from_bytes_be_buffer(managed_buffer: &ManagedBuffer<M>) -> BigUint<M>

pub fn to_bytes_be_buffer(&self) -> ManagedBuffer<M>

impl<M> BigUint<M>

where M: ManagedTypeApi,

pub fn sqrt(&self) -> BigUint<M>

pub fn pow(&self, exp: u32) -> BigUint<M>

pub fn log2_floor(&self) -> Option<u32>

The whole part of the base-2 logarithm.

Obtained by counting the significant bits. More specifically, the log2 floor is the position of the most significant bit minus one.

Will return None for the number zero (the logarithm in this case would approach -inf).

pub fn ln(&self) -> Option<ManagedDecimal<M, ConstDecimals<9>>>

Natural logarithm of a number.

Returns None for 0.

impl<M> BigUint<M>

where M: ManagedTypeApi,

pub fn to_display(&self) -> ManagedBuffer<M>

Creates to a managed buffer containing the textual representation of the number.

Trait Implementations

impl<'a, 'b, M> Add<&'b BigInt<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the + operator.

fn add(self, other: &BigInt<M>) -> BigInt<M>

Performs the + operation.

impl<'a, 'b, M> Add<&'b BigUint<M>> for &'a BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the + operator.

fn add(self, other: &BigUint<M>) -> BigInt<M>

Performs the + operation.

impl<'a, 'b, M> Add<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: &BigUint<M>) -> BigUint<M>

Performs the + operation.

impl<'b, M> Add<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: &BigUint<M>) -> BigUint<M>

Performs the + operation.

impl<M> Add<BigInt<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the + operator.

fn add(self, other: BigInt<M>) -> BigInt<M>

Performs the + operation.

impl<M> Add<BigUint<M>> for BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the + operator.

fn add(self, other: BigUint<M>) -> BigInt<M>

Performs the + operation.

impl<'a, M> Add<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u32) -> BigUint<M>

Performs the + operation.

impl<M> Add<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u32) -> BigUint<M>

Performs the + operation.

impl<'a, M> Add<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u64) -> BigUint<M>

Performs the + operation.

impl<M> Add<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: u64) -> BigUint<M>

Performs the + operation.

impl<M> Add for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the + operator.

fn add(self, other: BigUint<M>) -> BigUint<M>

Performs the + operation.

impl<M> AddAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn add_assign(&mut self, other: &BigUint<M>)

Performs the += operation.

impl<M> AddAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn add_assign(&mut self, other: u32)

Performs the += operation.

impl<M> AddAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn add_assign(&mut self, other: u64)

Performs the += operation.

impl<M> AddAssign for BigUint<M>

where M: ManagedTypeApi,

fn add_assign(&mut self, other: BigUint<M>)

Performs the += operation.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for &BigUint<<Env as TxEnv>::Api>

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, _env: &Env, f: F) -> R

where F: FnOnce(&BigUint<<Env as TxEnv>::Api>) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for ()

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

where F: FnOnce(&T) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for BigUint<<Env as TxEnv>::Api>

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, _env: &Env, f: F) -> R

where F: FnOnce(&BigUint<<Env as TxEnv>::Api>) -> R,

Can be used when working with references only.

impl<Env, EgldValue> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for Egld<EgldValue>

where Env: TxEnv, EgldValue: TxEgldValue<Env>,

fn annotation(&self, env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> BigUint<<Env as TxEnv>::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

where F: FnOnce(&BigUint<<Env as TxEnv>::Api>) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for ManagedRef<'_, <Env as TxEnv>::Api, BigUint<<Env as TxEnv>::Api>>

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, _env: &Env, f: F) -> R

where F: FnOnce(&BigUint<<Env as TxEnv>::Api>) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for NotPayable

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

where F: FnOnce(&T) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for NumExpr<'_>

where Env: ScenarioTxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<Env::Api>

fn to_value(&self, _env: &Env) -> BigUint<Env::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

where F: FnOnce(&T) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for i32

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

where F: FnOnce(&T) -> R,

Can be used when working with references only.

impl<Env> AnnotatedValue<Env, BigUint<<Env as TxEnv>::Api>> for u64

where Env: TxEnv,

fn annotation(&self, _env: &Env) -> ManagedBuffer<<Env as TxEnv>::Api>

fn to_value(&self, _env: &Env) -> BigUint<<Env as TxEnv>::Api>

Produces the value from a reference of the annotated type. Might involve a .clone() in some cases.

fn into_value(self, env: &Env) -> T

Consumes annotated value to produce actual value.

fn with_value_ref<F, R>(&self, env: &Env, f: F) -> R

where F: FnOnce(&T) -> R,

Can be used when working with references only.

impl<'a, 'b, M> BitAnd<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: &BigUint<M>) -> BigUint<M>

Performs the & operation.

impl<'b, M> BitAnd<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: &BigUint<M>) -> BigUint<M>

Performs the & operation.

impl<'a, M> BitAnd<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u32) -> BigUint<M>

Performs the & operation.

impl<M> BitAnd<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u32) -> BigUint<M>

Performs the & operation.

impl<'a, M> BitAnd<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u64) -> BigUint<M>

Performs the & operation.

impl<M> BitAnd<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: u64) -> BigUint<M>

Performs the & operation.

impl<M> BitAnd for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the & operator.

fn bitand(self, other: BigUint<M>) -> BigUint<M>

Performs the & operation.

impl<M> BitAndAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn bitand_assign(&mut self, other: &BigUint<M>)

Performs the &= operation.

impl<M> BitAndAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn bitand_assign(&mut self, other: u32)

Performs the &= operation.

impl<M> BitAndAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn bitand_assign(&mut self, other: u64)

Performs the &= operation.

impl<M> BitAndAssign for BigUint<M>

where M: ManagedTypeApi,

fn bitand_assign(&mut self, other: BigUint<M>)

Performs the &= operation.

impl<'a, 'b, M> BitOr<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: &BigUint<M>) -> BigUint<M>

Performs the | operation.

impl<'b, M> BitOr<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: &BigUint<M>) -> BigUint<M>

Performs the | operation.

impl<'a, M> BitOr<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u32) -> BigUint<M>

Performs the | operation.

impl<M> BitOr<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u32) -> BigUint<M>

Performs the | operation.

impl<'a, M> BitOr<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u64) -> BigUint<M>

Performs the | operation.

impl<M> BitOr<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: u64) -> BigUint<M>

Performs the | operation.

impl<M> BitOr for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the | operator.

fn bitor(self, other: BigUint<M>) -> BigUint<M>

Performs the | operation.

impl<M> BitOrAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn bitor_assign(&mut self, other: &BigUint<M>)

Performs the |= operation.

impl<M> BitOrAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn bitor_assign(&mut self, other: u32)

Performs the |= operation.

impl<M> BitOrAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn bitor_assign(&mut self, other: u64)

Performs the |= operation.

impl<M> BitOrAssign for BigUint<M>

where M: ManagedTypeApi,

fn bitor_assign(&mut self, other: BigUint<M>)

Performs the |= operation.

impl<'a, 'b, M> BitXor<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &BigUint<M>) -> BigUint<M>

Performs the ^ operation.

impl<'b, M> BitXor<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &BigUint<M>) -> BigUint<M>

Performs the ^ operation.

impl<'a, M> BitXor<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u32) -> BigUint<M>

Performs the ^ operation.

impl<M> BitXor<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u32) -> BigUint<M>

Performs the ^ operation.

impl<'a, M> BitXor<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u64) -> BigUint<M>

Performs the ^ operation.

impl<M> BitXor<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u64) -> BigUint<M>

Performs the ^ operation.

impl<M> BitXor for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the ^ operator.

fn bitxor(self, other: BigUint<M>) -> BigUint<M>

Performs the ^ operation.

impl<M> BitXorAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn bitxor_assign(&mut self, other: &BigUint<M>)

Performs the ^= operation.

impl<M> BitXorAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn bitxor_assign(&mut self, other: u32)

Performs the ^= operation.

impl<M> BitXorAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn bitxor_assign(&mut self, other: u64)

Performs the ^= operation.

impl<M> BitXorAssign for BigUint<M>

where M: ManagedTypeApi,

fn bitxor_assign(&mut self, other: BigUint<M>)

Performs the ^= operation.

impl<M> Clone for BigUint<M>

where M: ManagedTypeApi,

fn clone(&self) -> BigUint<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M> Debug for BigUint<M>

where M: ManagedTypeApi,

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

Formats the value using the given formatter.

impl<M> Default for BigUint<M>

where M: ManagedTypeApi,

fn default() -> BigUint<M>

Returns the “default value” for a type.

impl<'a, 'b, M> Div<&'b BigInt<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the / operator.

fn div(self, other: &BigInt<M>) -> BigInt<M>

Performs the / operation.

impl<'a, 'b, M> Div<&'b BigUint<M>> for &'a BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the / operator.

fn div(self, other: &BigUint<M>) -> BigInt<M>

Performs the / operation.

impl<'a, 'b, M> Div<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: &BigUint<M>) -> BigUint<M>

Performs the / operation.

impl<'b, M> Div<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: &BigUint<M>) -> BigUint<M>

Performs the / operation.

impl<M> Div<BigInt<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the / operator.

fn div(self, other: BigInt<M>) -> BigInt<M>

Performs the / operation.

impl<M> Div<BigUint<M>> for BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the / operator.

fn div(self, other: BigUint<M>) -> BigInt<M>

Performs the / operation.

impl<'a, M> Div<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u32) -> BigUint<M>

Performs the / operation.

impl<M> Div<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u32) -> BigUint<M>

Performs the / operation.

impl<'a, M> Div<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u64) -> BigUint<M>

Performs the / operation.

impl<M> Div<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: u64) -> BigUint<M>

Performs the / operation.

impl<M> Div for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the / operator.

fn div(self, other: BigUint<M>) -> BigUint<M>

Performs the / operation.

impl<M> DivAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn div_assign(&mut self, other: &BigUint<M>)

Performs the /= operation.

impl<M> DivAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn div_assign(&mut self, other: u32)

Performs the /= operation.

impl<M> DivAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn div_assign(&mut self, other: u64)

Performs the /= operation.

impl<M> DivAssign for BigUint<M>

where M: ManagedTypeApi,

fn div_assign(&mut self, other: BigUint<M>)

Performs the /= operation.

impl<M> From<&BigUint<M>> for BigFloat<M>

where M: ManagedTypeApi,

fn from(item: &BigUint<M>) -> BigFloat<M>

Converts to this type from the input type.

impl<M> From<&BigUint> for BigUint<M>

where M: ManagedTypeApi,

fn from(alloc_big_uint: &BigUint) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<&ManagedBuffer<M>> for BigUint<M>

where M: ManagedTypeApi,

fn from(item: &ManagedBuffer<M>) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<BigUint<M>> for BigFloat<M>

where M: ManagedTypeApi,

fn from(item: BigUint<M>) -> BigFloat<M>

Converts to this type from the input type.

impl<M> From<BigUint<M>> for BigInt<M>

where M: ManagedTypeApi,

fn from(item: BigUint<M>) -> BigInt<M>

Converts to this type from the input type.

impl<M: ManagedTypeApi> From<BigUint<M>> for BigUintValue

fn from(from: BigUint<M>) -> Self

Converts to this type from the input type.

impl<M, const DECIMALS: usize> From<BigUint<M>> for ManagedDecimal<M, ConstDecimals<DECIMALS>>

where M: ManagedTypeApi,

fn from(value: BigUint<M>) -> ManagedDecimal<M, ConstDecimals<DECIMALS>>

Converts to this type from the input type.

impl<M> From<BigUint> for BigUint<M>

where M: ManagedTypeApi,

fn from(alloc_big_uint: BigUint) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<ManagedBuffer<M>> for BigUint<M>

where M: ManagedTypeApi,

fn from(item: ManagedBuffer<M>) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<u128> for BigUint<M>

where M: ManagedTypeApi,

fn from(value: u128) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<u16> for BigUint<M>

where M: ManagedTypeApi,

fn from(value: u16) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<u32> for BigUint<M>

where M: ManagedTypeApi,

fn from(value: u32) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<u64> for BigUint<M>

where M: ManagedTypeApi,

fn from(value: u64) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<u8> for BigUint<M>

where M: ManagedTypeApi,

fn from(value: u8) -> BigUint<M>

Converts to this type from the input type.

impl<M> From<usize> for BigUint<M>

where M: ManagedTypeApi,

fn from(value: usize) -> BigUint<M>

Converts to this type from the input type.

impl<M> ManagedType<M> for BigUint<M>

where M: ManagedTypeApi,

type OwnHandle = <M as HandleTypeInfo>::BigIntHandle

fn get_handle(&self) -> <M as HandleTypeInfo>::BigIntHandle

unsafe fn forget_into_handle(self) -> <BigUint<M> as ManagedType<M>>::OwnHandle

Forgets current object (does not run destructor), but extracts the handle.

fn transmute_from_handle_ref( handle_ref: &<M as HandleTypeInfo>::BigIntHandle, ) -> &BigUint<M>

Implement carefully, since the underlying transmutation is an unsafe operation. For types that wrap a handle to some VM-managed data, make sure the type only contains the handle (plus ZSTs if necessary). For types that just wrap another managed type it is easier, call for the wrapped object.

fn transmute_from_handle_ref_mut( handle_ref: &mut <M as HandleTypeInfo>::BigIntHandle, ) -> &mut BigUint<M>

fn get_raw_handle(&self) -> i32

fn as_ref(&self) -> ManagedRef<'_, M, Self>

impl<M> ManagedVecItem for BigUint<M>

where M: ManagedTypeApi,

const SKIPS_RESERIALIZATION: bool = false

If true, then the encoding of the item is identical to the payload, and no further conversion is necessary (the underlying buffer can be used as-is during serialization). False for all managed types, but true for basic types (like u32).

type PAYLOAD = ManagedVecItemPayloadBuffer<4>

Type managing the underlying binary representation in a ManagedVec..

type Ref<'a> = ManagedRef<'a, M, BigUint<M>>

Reference representation of the ManagedVec item.

fn read_from_payload( payload: &<BigUint<M> as ManagedVecItem>::PAYLOAD, ) -> BigUint<M>

Parses given bytes as a an owned object.

unsafe fn borrow_from_payload<'a>( payload: &<BigUint<M> as ManagedVecItem>::PAYLOAD, ) -> <BigUint<M> as ManagedVecItem>::Ref<'a>

Parses given bytes as a representation of the object, either owned, or a reference.

fn save_to_payload(self, payload: &mut <BigUint<M> as ManagedVecItem>::PAYLOAD)

Converts the object into bytes.

fn payload_size() -> usize

impl<'a, 'b, M> Mul<&'b BigInt<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the * operator.

fn mul(self, other: &BigInt<M>) -> BigInt<M>

Performs the * operation.

impl<'a, 'b, M> Mul<&'b BigUint<M>> for &'a BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the * operator.

fn mul(self, other: &BigUint<M>) -> BigInt<M>

Performs the * operation.

impl<'a, 'b, M> Mul<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: &BigUint<M>) -> BigUint<M>

Performs the * operation.

impl<'b, M> Mul<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: &BigUint<M>) -> BigUint<M>

Performs the * operation.

impl<M> Mul<BigInt<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the * operator.

fn mul(self, other: BigInt<M>) -> BigInt<M>

Performs the * operation.

impl<M> Mul<BigUint<M>> for BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the * operator.

fn mul(self, other: BigUint<M>) -> BigInt<M>

Performs the * operation.

impl<'a, M> Mul<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> BigUint<M>

Performs the * operation.

impl<M> Mul<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> BigUint<M>

Performs the * operation.

impl<'a, M> Mul<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> BigUint<M>

Performs the * operation.

impl<M> Mul<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> BigUint<M>

Performs the * operation.

impl<M> Mul for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the * operator.

fn mul(self, other: BigUint<M>) -> BigUint<M>

Performs the * operation.

impl<M> MulAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn mul_assign(&mut self, other: &BigUint<M>)

Performs the *= operation.

impl<M> MulAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

impl<M> MulAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

impl<M> MulAssign for BigUint<M>

where M: ManagedTypeApi,

fn mul_assign(&mut self, other: BigUint<M>)

Performs the *= operation.

impl<M> NestedDecode for BigUint<M>

where M: ManagedTypeApi,

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<BigUint<M>, <H as DecodeErrorHandler>::HandledErr>

where I: NestedDecodeInput, H: DecodeErrorHandler,

Version of dep_decode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn dep_decode<I>(input: &mut I) -> Result<Self, DecodeError>

where I: NestedDecodeInput,

Attempt to deserialise the value from input, using the format of an object nested inside another structure. In case of success returns the deserialized value and the number of bytes consumed during the operation.

impl<M> NestedEncode for BigUint<M>

where M: ManagedTypeApi,

fn dep_encode_or_handle_err<O, H>( &self, dest: &mut O, h: H, ) -> Result<(), <H as EncodeErrorHandler>::HandledErr>

where O: NestedEncodeOutput, H: EncodeErrorHandler,

Version of dep_encode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn dep_encode<O>(&self, dest: &mut O) -> Result<(), EncodeError>

where O: NestedEncodeOutput,

NestedEncode to output, using the format of an object nested inside another structure. Does not provide compact version.

impl<M> Ord for BigUint<M>

where M: ManagedTypeApi,

fn cmp(&self, other: &BigUint<M>) -> 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,

Restrict a value to a certain interval.

impl<M> PartialEq<i32> for BigUint<M>

where M: ManagedTypeApi,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<M> PartialEq<i64> for BigUint<M>

where M: ManagedTypeApi,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<M> PartialEq<u32> for BigUint<M>

where M: ManagedTypeApi,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<M> PartialEq<u64> for BigUint<M>

where M: ManagedTypeApi,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<M> PartialEq for BigUint<M>

where M: ManagedTypeApi,

fn eq(&self, other: &BigUint<M>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<M> PartialOrd<i32> for BigUint<M>

where M: ManagedTypeApi,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<M> PartialOrd<i64> for BigUint<M>

where M: ManagedTypeApi,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<M> PartialOrd<u32> for BigUint<M>

where M: ManagedTypeApi,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<M> PartialOrd<u64> for BigUint<M>

where M: ManagedTypeApi,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<M> PartialOrd for BigUint<M>

where M: ManagedTypeApi,

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a, 'b, M> Rem<&'b BigInt<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the % operator.

fn rem(self, other: &BigInt<M>) -> BigInt<M>

Performs the % operation.

impl<'a, 'b, M> Rem<&'b BigUint<M>> for &'a BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the % operator.

fn rem(self, other: &BigUint<M>) -> BigInt<M>

Performs the % operation.

impl<'a, 'b, M> Rem<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: &BigUint<M>) -> BigUint<M>

Performs the % operation.

impl<'b, M> Rem<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: &BigUint<M>) -> BigUint<M>

Performs the % operation.

impl<M> Rem<BigInt<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the % operator.

fn rem(self, other: BigInt<M>) -> BigInt<M>

Performs the % operation.

impl<M> Rem<BigUint<M>> for BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the % operator.

fn rem(self, other: BigUint<M>) -> BigInt<M>

Performs the % operation.

impl<'a, M> Rem<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> BigUint<M>

Performs the % operation.

impl<M> Rem<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> BigUint<M>

Performs the % operation.

impl<'a, M> Rem<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> BigUint<M>

Performs the % operation.

impl<M> Rem<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> BigUint<M>

Performs the % operation.

impl<M> Rem for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the % operator.

fn rem(self, other: BigUint<M>) -> BigUint<M>

Performs the % operation.

impl<M> RemAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn rem_assign(&mut self, other: &BigUint<M>)

Performs the %= operation.

impl<M> RemAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

impl<M> RemAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

impl<M> RemAssign for BigUint<M>

where M: ManagedTypeApi,

fn rem_assign(&mut self, other: BigUint<M>)

Performs the %= operation.

impl<M> SCDisplay for BigUint<M>

where M: ManagedTypeApi,

fn fmt<F>(&self, f: &mut F)

where F: FormatByteReceiver,

impl<'a, M> Shl<usize> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> BigUint<M>

Performs the << operation.

impl<M> Shl<usize> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> BigUint<M>

Performs the << operation.

impl<M> ShlAssign<usize> for BigUint<M>

where M: ManagedTypeApi,

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<'a, M> Shr<usize> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> BigUint<M>

Performs the >> operation.

impl<M> Shr<usize> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> BigUint<M>

Performs the >> operation.

impl<M> ShrAssign<usize> for BigUint<M>

where M: ManagedTypeApi,

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<'a, 'b, M> Sub<&'b BigInt<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the - operator.

fn sub(self, other: &BigInt<M>) -> BigInt<M>

Performs the - operation.

impl<'a, 'b, M> Sub<&'b BigUint<M>> for &'a BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the - operator.

fn sub(self, other: &BigUint<M>) -> BigInt<M>

Performs the - operation.

impl<'a, 'b, M> Sub<&'b BigUint<M>> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: &BigUint<M>) -> BigUint<M>

Performs the - operation.

impl<'b, M> Sub<&'b BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: &BigUint<M>) -> BigUint<M>

Performs the - operation.

impl<M> Sub<BigInt<M>> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the - operator.

fn sub(self, other: BigInt<M>) -> BigInt<M>

Performs the - operation.

impl<M> Sub<BigUint<M>> for BigInt<M>

where M: ManagedTypeApi,

type Output = BigInt<M>

The resulting type after applying the - operator.

fn sub(self, other: BigUint<M>) -> BigInt<M>

Performs the - operation.

impl<'a, M> Sub<u32> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u32) -> BigUint<M>

Performs the - operation.

impl<M> Sub<u32> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u32) -> BigUint<M>

Performs the - operation.

impl<'a, M> Sub<u64> for &'a BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u64) -> BigUint<M>

Performs the - operation.

impl<M> Sub<u64> for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: u64) -> BigUint<M>

Performs the - operation.

impl<M> Sub for BigUint<M>

where M: ManagedTypeApi,

type Output = BigUint<M>

The resulting type after applying the - operator.

fn sub(self, other: BigUint<M>) -> BigUint<M>

Performs the - operation.

impl<M> SubAssign<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

fn sub_assign(&mut self, other: &BigUint<M>)

Performs the -= operation.

impl<M> SubAssign<u32> for BigUint<M>

where M: ManagedTypeApi,

fn sub_assign(&mut self, other: u32)

Performs the -= operation.

impl<M> SubAssign<u64> for BigUint<M>

where M: ManagedTypeApi,

fn sub_assign(&mut self, other: u64)

Performs the -= operation.

impl<M> SubAssign for BigUint<M>

where M: ManagedTypeApi,

fn sub_assign(&mut self, other: BigUint<M>)

Performs the -= operation.

impl<M> TopDecode for BigUint<M>

where M: ManagedTypeApi,

fn top_decode_or_handle_err<I, H>( input: I, h: H, ) -> Result<BigUint<M>, <H as DecodeErrorHandler>::HandledErr>

where I: TopDecodeInput, H: DecodeErrorHandler,

Version of top_decode that can handle errors as soon as they occur. For instance it can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn top_decode<I>(input: I) -> Result<Self, DecodeError>

where I: TopDecodeInput,

Attempt to deserialize the value from input.

impl<M> TopEncode for BigUint<M>

where M: ManagedTypeApi,

fn top_encode_or_handle_err<O, H>( &self, output: O, h: H, ) -> Result<(), <H as EncodeErrorHandler>::HandledErr>

where O: TopEncodeOutput, H: EncodeErrorHandler,

Version of top_encode that can handle errors as soon as they occur. For instance in can exit immediately and make sure that if it returns, it is a success. By not deferring error handling, this can lead to somewhat smaller bytecode.

fn top_encode<O>(&self, output: O) -> Result<(), EncodeError>

where O: TopEncodeOutput,

Attempt to serialize the value to ouput.

impl<M> TryStaticCast for BigUint<M>

where M: ManagedTypeApi,

fn type_eq<U>() -> bool

where U: TryStaticCast,

fn try_cast<U>(self) -> Option<U>

where U: TryStaticCast,

fn try_cast_ref<U>(&self) -> Option<&U>

where U: TryStaticCast,

impl<M> TypeAbi for BigUint<M>

where M: ManagedTypeApi,

type Unmanaged = BigUint

fn type_name() -> String

fn type_name_rust() -> String

fn type_names() -> TypeNames

fn provide_type_descriptions<TDC>(accumulator: &mut TDC)

where TDC: TypeDescriptionContainer,

A type can provide more than its own name. For instance, a struct can also provide the descriptions of the type of its fields. TypeAbi doesn’t care for the exact accumulator type, which is abstracted by the TypeDescriptionContainer trait.

impl<M> Eq for BigUint<M>

where M: ManagedTypeApi,

impl<Env> TxEgldValue<Env> for &BigUint<<Env as TxEnv>::Api>

where Env: TxEnv,

impl<Env> TxEgldValue<Env> for BigUint<<Env as TxEnv>::Api>

where Env: TxEnv,

impl<M> TypeAbiFrom<&BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<BigUint<M>> for BigUint

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<BigUint<M>> for BigUint<M>

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<BigUint> for BigUint<M>

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<u16> for BigUint<M>

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<u32> for BigUint<M>

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<u64> for BigUint<M>

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<u8> for BigUint<M>

where M: ManagedTypeApi,

impl<M> TypeAbiFrom<usize> for BigUint<M>

where M: ManagedTypeApi,