Trait novax_data::ManagedConvertible

source ·

pub trait ManagedConvertible<M: TopEncodeMulti> {
    // Required method
    fn to_managed(&self) -> M;
}

Expand description

Provides a bridge from common Rust types to complex smart contract types managed by the MultiversX virtual machine.

This trait facilitates the conversion from native Rust types to managed types. Unlike NativeConvertible, this bridge establishes a many-to-many relationship, allowing multiple Rust types to be converted to multiple managed types.

Implementing this trait requires specifying the managed type parameter M and providing an implementation for the to_managed method, which will carry out the actual conversion.

Type Parameters

M: The managed type to which the native Rust type will be converted, constrained by the TopEncodeMulti trait.

Methods

to_managed: Performs the conversion from the native Rust type to the specified managed type.

Examples

String can be converted to ManagedBuffer, TokenIdentifier, or ManagedAddress.
Vec can be converted to ManagedVec.


struct YourStruct(String);

impl ManagedConvertible<ManagedBuffer<StaticApi>> for YourStruct {
    fn to_managed(&self) -> ManagedBuffer<StaticApi> {
        ManagedBuffer::from(&*self.0)
    }
}

Required Methods§

source

fn to_managed(&self) -> M

Converts the native Rust type to the specified managed type.

Trait novax_data::ManagedConvertible

Required Methods§

fn to_managed(&self) -> M

Implementations on Foreign Types§

impl ManagedConvertible<bool> for bool

fn to_managed(&self) -> bool

impl ManagedConvertible<i8> for i8

fn to_managed(&self) -> i8

impl ManagedConvertible<i16> for i16

fn to_managed(&self) -> i16

impl ManagedConvertible<i32> for i32

fn to_managed(&self) -> i32

impl ManagedConvertible<i64> for i64

fn to_managed(&self) -> i64

impl ManagedConvertible<u8> for u8

fn to_managed(&self) -> u8

impl ManagedConvertible<u16> for u16

fn to_managed(&self) -> u16

impl ManagedConvertible<u32> for u32

fn to_managed(&self) -> u32

impl ManagedConvertible<u64> for u64

fn to_managed(&self) -> u64

impl ManagedConvertible<String> for String

fn to_managed(&self) -> String

impl ManagedConvertible<IgnoreValue> for ()

fn to_managed(&self) -> IgnoreValue

impl ManagedConvertible<CodeMetadata> for u16

fn to_managed(&self) -> CodeMetadata

impl ManagedConvertible<BigInt<VMHooksApi<StaticApiBackend>>> for BigInt

fn to_managed(&self) -> BigInt<StaticApi>

impl ManagedConvertible<BigUint<VMHooksApi<StaticApiBackend>>> for BigUint

fn to_managed(&self) -> BigUint<StaticApi>

impl ManagedConvertible<ManagedBuffer<VMHooksApi<StaticApiBackend>>> for String

fn to_managed(&self) -> ManagedBuffer<StaticApi>

impl ManagedConvertible<EgldOrEsdtTokenIdentifier<VMHooksApi<StaticApiBackend>>> for String

fn to_managed(&self) -> EgldOrEsdtTokenIdentifier<StaticApi>

impl ManagedConvertible<TokenIdentifier<VMHooksApi<StaticApiBackend>>> for String

fn to_managed(&self) -> TokenIdentifier<StaticApi>

impl ManagedConvertible<BigInt> for BigInt

fn to_managed(&self) -> BigInt

impl ManagedConvertible<BigUint> for BigUint

fn to_managed(&self) -> BigUint

impl<C, T> ManagedConvertible<MultiValueEncoded<VMHooksApi<StaticApiBackend>, T>> for Vec<C>where C: ManagedConvertible<T>, T: TopEncodeMulti,

fn to_managed(&self) -> MultiValueEncoded<StaticApi, T>

impl<C, T> ManagedConvertible<ManagedVec<VMHooksApi<StaticApiBackend>, T>> for Vec<C>where C: ManagedConvertible<T>, T: TopEncodeMulti + NestedEncode + ManagedVecItem,

fn to_managed(&self) -> ManagedVec<StaticApi, T>

impl<N, T> ManagedConvertible<Option<T>> for Option<N>where N: ManagedConvertible<T>, T: TopEncode + TopDecode + NestedEncode + NestedDecode,

fn to_managed(&self) -> Option<T>

impl<N, T> ManagedConvertible<OptionalValue<T>> for Option<N>where N: ManagedConvertible<T>, T: TopEncodeMulti,

fn to_managed(&self) -> OptionalValue<T>

impl<T0, N0> ManagedConvertible<(T0,)> for (N0,)where T0: TopEncode + NestedEncode + NativeConvertible<Native = N0>, N0: ManagedConvertible<T0>,

fn to_managed(&self) -> (T0,)

impl<T0, N0, T1, N1> ManagedConvertible<(T0, T1)> for (N0, N1)where T0: TopEncode + NestedEncode + NativeConvertible<Native = N0>, T1: TopEncode + NestedEncode + NativeConvertible<Native = N1>, N0: ManagedConvertible<T0>, N1: ManagedConvertible<T1>,

fn to_managed(&self) -> (T0, T1)

fn to_managed(&self) -> (T0, T1, T2)

fn to_managed(&self) -> (T0, T1, T2, T3)

fn to_managed(&self) -> (T0, T1, T2, T3, T4)

fn to_managed(&self) -> (T0, T1, T2, T3, T4, T5)

fn to_managed(&self) -> (T0, T1, T2, T3, T4, T5, T6)

fn to_managed(&self) -> (T0, T1, T2, T3, T4, T5, T6, T7)

fn to_managed(&self) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8)

fn to_managed(&self) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

fn to_managed(&self) -> (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

impl<T0: TopEncodeMulti, C0: ManagedConvertible<T0>, T1: TopEncodeMulti, C1: ManagedConvertible<T1>> ManagedConvertible<MultiValue2<T0, T1>> for (C0, C1)

fn to_managed(&self) -> MultiValue2<T0, T1>

impl<T0: TopEncodeMulti, C0: ManagedConvertible<T0>, T1: TopEncodeMulti, C1: ManagedConvertible<T1>, T2: TopEncodeMulti, C2: ManagedConvertible<T2>> ManagedConvertible<MultiValue3<T0, T1, T2>> for (C0, C1, C2)

fn to_managed(&self) -> MultiValue3<T0, T1, T2>

impl<T0: TopEncodeMulti, C0: ManagedConvertible<T0>, T1: TopEncodeMulti, C1: ManagedConvertible<T1>, T2: TopEncodeMulti, C2: ManagedConvertible<T2>, T3: TopEncodeMulti, C3: ManagedConvertible<T3>> ManagedConvertible<MultiValue4<T0, T1, T2, T3>> for (C0, C1, C2, C3)

fn to_managed(&self) -> MultiValue4<T0, T1, T2, T3>

fn to_managed(&self) -> MultiValue5<T0, T1, T2, T3, T4>

fn to_managed(&self) -> MultiValue6<T0, T1, T2, T3, T4, T5>

fn to_managed(&self) -> MultiValue7<T0, T1, T2, T3, T4, T5, T6>

fn to_managed(&self) -> MultiValue8<T0, T1, T2, T3, T4, T5, T6, T7>

fn to_managed(&self) -> MultiValue9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

fn to_managed(&self) -> MultiValue10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>

fn to_managed( &self ) -> MultiValue11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>

impl<T, N> ManagedConvertible<MultiValueVec<T>> for Vec<N>where N: ManagedConvertible<T> + Clone, T: TopEncodeMulti,

fn to_managed(&self) -> MultiValueVec<T>

impl<const N: usize> ManagedConvertible<[u8; N]> for [u8; N]

fn to_managed(&self) -> [u8; N]