Struct ManagedDecimalSigned 

pub struct ManagedDecimalSigned<M: ManagedTypeApi, D: Decimals> { /* private fields */ }

Fixed-point decimal numbers that accept either a constant or variable number of decimals.

Unlike for ManagedDecimal, ngative numbers are also allowed.

Implementations

impl<M: ManagedTypeApi, D1: Decimals> ManagedDecimalSigned<M, D1>

pub fn mul_half_up_signed<D2: Decimals, DResult: Decimals>( &self, other: &ManagedDecimalSigned<M, D2>, precision: DResult, ) -> ManagedDecimalSigned<M, DResult>

Multiplies two signed decimals with half-up (away-from-zero) rounding to a target precision.

The algorithm mirrors ManagedDecimal::mul_half_up, but uses BigInt arithmetic and adjusts the pre-bias direction based on the sign of the intermediate product:

if product < 0:  rounded = (product - scale / 2) / scale
else:            rounded = (product + scale / 2) / scale

The VM’s integer division truncates toward zero. Subtracting the bias for a negative product pushes it further from zero before truncation, so the final result rounds away from zero in both directions — matching the conventional financial definition of “round half up” for signed numbers.

Credits

Original implementation by @mihaieremia.

pub fn div_half_up_signed<D2: Decimals, DResult: Decimals>( &self, other: &ManagedDecimalSigned<M, D2>, precision: DResult, ) -> ManagedDecimalSigned<M, DResult>

Divides two signed decimals with half-up (away-from-zero) rounding to a target precision.

The numerator is scaled up by scale (as in ManagedDecimal::div_half_up) and then pre-biased before T-division (truncates toward zero). The bias direction depends solely on the sign of the numerator — not on the sign of the denominator:

half = |denominator| / 2
if numerator < 0:  rounded = (numerator - half) / denominator
else:              rounded = (numerator + half) / denominator

This is correct because half is always non-negative. When numerator > 0, adding half increases the numerator’s magnitude; when the denominator is negative, dividing a larger positive numerator yields a more-negative result — farther from zero. The rule therefore rounds away from zero for all four sign combinations of (numerator, denominator).

Using sign(denominator) as the branch condition instead would produce wrong results whenever the denominator is negative.

Credits

Original implementation by @mihaieremia.

impl<M: ManagedTypeApi, D: Decimals> ManagedDecimalSigned<M, D>

pub fn ln(&self) -> Option<ManagedDecimalSigned<M, LnDecimals>>

Natural logarithm of a number.

Returns None for 0.

Even though 9 decimals are returned, only around 6 decimals are actually useful.

pub fn log2(&self) -> Option<ManagedDecimalSigned<M, LnDecimals>>

Base 2 logarithm of a number.

Returns None for 0.

Even though 9 decimals are returned, only around 6 decimals are actually useful.

impl<M: ManagedTypeApi, D1: Decimals> ManagedDecimalSigned<M, D1>

pub fn mul_with_precision<D2: Decimals, T: Decimals>( self, other: ManagedDecimalSigned<M, D2>, precision: T, ) -> ManagedDecimalSigned<M, T>

impl<M: ManagedTypeApi, D: Decimals> ManagedDecimalSigned<M, D>

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

Returns the integer part (truncated toward zero) of the signed decimal value.

Divides the raw fixed-point integer by the scaling factor, discarding the fractional part. For example, -1.75 with 2 decimals returns -1.

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

Returns a reference to the underlying raw fixed-point integer.

The value is stored as real_value * 10^decimals. For example, a ManagedDecimalSigned representing -1.5 with 2 decimals has a raw value of -150.

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

👎Deprecated since 0.66.0:

Use as_raw_units to get a reference to the raw value, or into_raw_parts to consume the decimal and get the raw value.

Was incorrectly named into_raw_units in versions prior to 0.66.0; renamed to as_raw_units to clarify that it returns a reference and does not consume the decimal.

pub fn into_raw_parts(self) -> (BigInt<M>, D)

Consumes the decimal and returns the underlying raw fixed-point integer together with the decimals specification.

The value is stored as real_value * 10^decimals. For example, a ManagedDecimalSigned representing -1.5 with 2 decimals has a raw value of -150.

This is the destructuring counterpart of from_raw_units.

pub fn from_raw_units(data: BigInt<M>, decimals: D) -> Self

Creates a ManagedDecimalSigned from a raw fixed-point integer and a decimals specification.

The caller is responsible for ensuring data is already scaled by 10^decimals.

pub fn scale(&self) -> usize

Returns the number of decimal places.

pub fn scaling_factor(&self) -> ManagedRef<'static, M, BigUint<M>>

Returns the scaling factor 10^decimals as a static reference.

pub fn rescale<T: Decimals>(&self, scale_to: T) -> ManagedDecimalSigned<M, T>

Converts this decimal to a new scale, adjusting the raw value accordingly.

Upscaling adds precision (appends trailing zeros to the raw integer); downscaling truncates the least-significant digits.

pub fn into_unsigned_or_fail(self) -> ManagedDecimal<M, D>

Converts this signed decimal into an unsigned ManagedDecimal, panicking if the value is negative.

pub fn sign(&self) -> Sign

Returns the sign of the decimal value (Positive, Negative, or NoSign for zero).

impl<M: ManagedTypeApi, DECIMALS: Unsigned> ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

pub fn const_decimals_from_raw(data: BigInt<M>) -> Self

Creates a ManagedDecimalSigned with a compile-time fixed number of decimals from a raw integer.

The caller is responsible for ensuring data is already scaled by 10^DECIMALS.

pub fn into_var_decimals(self) -> ManagedDecimalSigned<M, NumDecimals>

Converts from constant (compile-time) number of decimals to a variable number of decimals.

impl<M: ManagedTypeApi, D: Decimals> ManagedDecimalSigned<M, D>

pub fn to_big_float(&self) -> BigFloat<M>

Converts this fixed-point decimal to a BigFloat for floating-point arithmetic.

Divides the raw integer by the scaling factor to produce the real-valued float.

pub fn from_big_float<T: Decimals>( big_float: &BigFloat<M>, num_decimals: T, ) -> ManagedDecimalSigned<M, T>

Constructs a ManagedDecimalSigned from a BigFloat at the given decimal precision.

Multiplies the float by the scaling factor and truncates to an integer. This is an approximation; precision is limited by the float representation.

Trait Implementations

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Add<ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>> for ManagedDecimalSigned<M, NumDecimals>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the + operator.

fn add( self, rhs: ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>, ) -> Self::Output

Performs the + operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Add<ManagedDecimalSigned<M, usize>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the + operator.

fn add(self, rhs: ManagedDecimalSigned<M, NumDecimals>) -> Self::Output

Performs the + operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> Add for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

The resulting type after applying the + operator.

fn add( self, rhs: ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>, ) -> Self::Output

Performs the + operation.

impl<M: ManagedTypeApi> Add for ManagedDecimalSigned<M, NumDecimals>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the + operator.

fn add(self, rhs: ManagedDecimalSigned<M, NumDecimals>) -> Self::Output

Performs the + operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> AddAssign<&ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn add_assign(&mut self, rhs: &ManagedDecimalSigned<M, D2>)

Performs the += operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> AddAssign<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn add_assign(&mut self, rhs: ManagedDecimalSigned<M, D2>)

Performs the += operation.

impl<M: Clone + ManagedTypeApi, D: Clone + Decimals> Clone for ManagedDecimalSigned<M, D>

fn clone(&self) -> ManagedDecimalSigned<M, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: ManagedTypeApi, D: Decimals> Debug for ManagedDecimalSigned<M, D>

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

Formats the value using the given formatter.

impl<M: ManagedTypeApi, D: Decimals> Display for ManagedDecimalSigned<M, D>

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

Formats the value using the given formatter.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Div<ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>> for ManagedDecimalSigned<M, NumDecimals>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the / operator.

fn div( self, rhs: ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>, ) -> Self::Output

Performs the / operation.

impl<M: ManagedTypeApi, D1, D2: Decimals> Div<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

where D1: Sub<D2> + Decimals, <D1 as Sub<D2>>::Output: Decimals,

type Output = ManagedDecimalSigned<M, <D1 as Sub<D2>>::Output>

The resulting type after applying the / operator.

fn div(self, other: ManagedDecimalSigned<M, D2>) -> Self::Output

Performs the / operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Div<ManagedDecimalSigned<M, usize>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the / operator.

fn div(self, rhs: ManagedDecimalSigned<M, NumDecimals>) -> Self::Output

Performs the / operation.

impl<M: ManagedTypeApi, D: Decimals> Div<usize> for ManagedDecimalSigned<M, D>

type Output = ManagedDecimalSigned<M, D>

The resulting type after applying the / operator.

fn div(self, other: NumDecimals) -> Self::Output

Performs the / operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> DivAssign<&ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn div_assign(&mut self, rhs: &ManagedDecimalSigned<M, D2>)

Performs the /= operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> DivAssign<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn div_assign(&mut self, rhs: ManagedDecimalSigned<M, D2>)

Performs the /= operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<&BigFloat<M>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn from(value: &BigFloat<M>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<BigFloat<M>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn from(value: BigFloat<M>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<BigInt<M>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn from(value: BigInt<M>) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<f32> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn from(x: f32) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<f64> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn from(x: f64) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> From<i64> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> ManagedVecItem for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

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<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>

Type managing the underlying binary representation in a ManagedVec..

type Ref<'a> = Ref<'a, ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>>

Reference representation of the ManagedVec item.

unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self

Parses given bytes as a an owned object.

unsafe fn borrow_from_payload<'a>(payload: &Self::PAYLOAD) -> Self::Ref<'a>

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

fn save_to_payload(self, payload: &mut Self::PAYLOAD)

Converts the object into bytes.

fn requires_drop() -> bool

Signals that vec should drop all items one by one when being itself dropped.

fn payload_size() -> usize

fn temp_decode<F, R>(payload: &Self::PAYLOAD, f: F) -> R

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

impl<M: ManagedTypeApi> ManagedVecItem for ManagedDecimalSigned<M, NumDecimals>

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<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>

Type managing the underlying binary representation in a ManagedVec..

type Ref<'a> = Ref<'a, ManagedDecimalSigned<M, usize>>

Reference representation of the ManagedVec item.

unsafe fn read_from_payload(payload: &Self::PAYLOAD) -> Self

Parses given bytes as a an owned object.

unsafe fn borrow_from_payload<'a>(payload: &Self::PAYLOAD) -> Self::Ref<'a>

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

fn save_to_payload(self, payload: &mut Self::PAYLOAD)

Converts the object into bytes.

fn requires_drop() -> bool

Signals that vec should drop all items one by one when being itself dropped.

fn payload_size() -> usize

fn temp_decode<F, R>(payload: &Self::PAYLOAD, f: F) -> R

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

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Mul<ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>> for ManagedDecimalSigned<M, NumDecimals>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the * operator.

fn mul( self, rhs: ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>, ) -> Self::Output

Performs the * operation.

impl<M: ManagedTypeApi, D1, D2: Decimals> Mul<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

where D1: Add<D2> + Decimals, <D1 as Add<D2>>::Output: Decimals,

type Output = ManagedDecimalSigned<M, <D1 as Add<D2>>::Output>

The resulting type after applying the * operator.

fn mul(self, other: ManagedDecimalSigned<M, D2>) -> Self::Output

Performs the * operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Mul<ManagedDecimalSigned<M, usize>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the * operator.

fn mul(self, rhs: ManagedDecimalSigned<M, NumDecimals>) -> Self::Output

Performs the * operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> MulAssign<&ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn mul_assign(&mut self, rhs: &ManagedDecimalSigned<M, D2>)

Performs the *= operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> MulAssign<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn mul_assign(&mut self, rhs: ManagedDecimalSigned<M, D2>)

Performs the *= operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> NestedDecode for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<Self, H::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: ManagedTypeApi> NestedDecode for ManagedDecimalSigned<M, NumDecimals>

fn dep_decode_or_handle_err<I, H>( input: &mut I, h: H, ) -> Result<Self, H::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: ManagedTypeApi, DECIMALS: Unsigned> NestedEncode for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn dep_encode_or_handle_err<O, H>( &self, dest: &mut O, h: H, ) -> Result<(), H::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: ManagedTypeApi> NestedEncode for ManagedDecimalSigned<M, NumDecimals>

fn dep_encode_or_handle_err<O, H>( &self, dest: &mut O, h: H, ) -> Result<(), H::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: ManagedTypeApi, D1: Decimals, D2: Decimals> PartialEq<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn eq(&self, other: &ManagedDecimalSigned<M, D2>) -> 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: ManagedTypeApi, D1: Decimals, D2: Decimals> PartialOrd<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn partial_cmp(&self, other: &ManagedDecimalSigned<M, D2>) -> 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: ManagedTypeApi, D: Decimals> SCDisplay for ManagedDecimalSigned<M, D>

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

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Sub<ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>> for ManagedDecimalSigned<M, NumDecimals>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the - operator.

fn sub( self, rhs: ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>, ) -> Self::Output

Performs the - operation.

impl<DECIMALS: Unsigned, M: ManagedTypeApi> Sub<ManagedDecimalSigned<M, usize>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the - operator.

fn sub(self, rhs: ManagedDecimalSigned<M, NumDecimals>) -> Self::Output

Performs the - operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> Sub for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

type Output = ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

The resulting type after applying the - operator.

fn sub( self, rhs: ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>, ) -> Self::Output

Performs the - operation.

impl<M: ManagedTypeApi> Sub for ManagedDecimalSigned<M, NumDecimals>

type Output = ManagedDecimalSigned<M, usize>

The resulting type after applying the - operator.

fn sub(self, rhs: ManagedDecimalSigned<M, NumDecimals>) -> Self::Output

Performs the - operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> SubAssign<&ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn sub_assign(&mut self, rhs: &ManagedDecimalSigned<M, D2>)

Performs the -= operation.

impl<M: ManagedTypeApi, D1: Decimals, D2: Decimals> SubAssign<ManagedDecimalSigned<M, D2>> for ManagedDecimalSigned<M, D1>

fn sub_assign(&mut self, rhs: ManagedDecimalSigned<M, D2>)

Performs the -= operation.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> TopDecode for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn top_decode_or_handle_err<I, H>(input: I, h: H) -> Result<Self, H::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: ManagedTypeApi> TopDecode for ManagedDecimalSigned<M, NumDecimals>

fn top_decode_or_handle_err<I, H>( top_input: I, h: H, ) -> Result<Self, H::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: ManagedTypeApi, DECIMALS: Unsigned> TopEncode for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn top_encode_or_handle_err<O, H>( &self, output: O, h: H, ) -> Result<(), H::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 output.

impl<M: ManagedTypeApi> TopEncode for ManagedDecimalSigned<M, NumDecimals>

fn top_encode_or_handle_err<O, H>( &self, output: O, h: H, ) -> Result<(), H::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 output.

impl<M: ManagedTypeApi, DECIMALS: Unsigned> TypeAbi for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

type Unmanaged = ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

fn type_name() -> TypeName

The type name, as it shows up in the ABI.

fn type_name_rust() -> TypeName

The type name as it shows up in Rust code. Used for proxies.

fn type_names() -> TypeNames

fn type_name_specific() -> Option<TypeName>

Specific name to be optionally added to the ABI.

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

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: ManagedTypeApi> TypeAbi for ManagedDecimalSigned<M, NumDecimals>

type Unmanaged = ManagedDecimalSigned<M, usize>

fn type_name() -> TypeName

The type name, as it shows up in the ABI.

fn type_names() -> TypeNames

fn type_name_rust() -> TypeName

The type name as it shows up in Rust code. Used for proxies.

fn type_name_specific() -> Option<TypeName>

Specific name to be optionally added to the ABI.

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

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: ManagedTypeApi, DECIMALS: Unsigned> TypeAbiFrom<ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>> for ManagedDecimalSigned<M, ConstDecimals<DECIMALS>>

impl<M: ManagedTypeApi> TypeAbiFrom<ManagedDecimalSigned<M, usize>> for ManagedDecimalSigned<M, NumDecimals>