[][src]Struct sp_runtime_interface::pass_by::Inner

pub struct Inner<T: PassByInner<Inner = I>, I: RIType>(_);

The implementation of the pass by inner type strategy. The type that uses this strategy will be passed between wasm and the host by using the wrapped inner type. So, this strategy is only usable by newtype structs.

Use this type as associated type for PassBy to implement this strategy for a type. Besides that the PassByInner trait need to be implemented as well.

This type expects the type that wants to use this strategy as generic parameter T and the inner type as generic parameter I.

PassByInner is a derive macro to implement this strategy.

Example

struct Test([u8; 32]);

impl PassBy for Test {
    type PassBy = Inner<Self, [u8; 32]>;
}

impl PassByInner for Test {
    type Inner = [u8; 32];

    fn into_inner(self) -> [u8; 32] {
        self.0
    }
    fn inner(&self) -> &[u8; 32] {
        &self.0
    }
    fn from_inner(inner: [u8; 32]) -> Self {
        Self(inner)
    }
}

Trait Implementations

impl<T: PassByInner<Inner = I>, I: RIType> PassByImpl<T> for Inner<T, I> where
    I: IntoFFIValue + FromFFIValue<SelfInstance = I>, 
[src]

impl<T: PassByInner<Inner = I>, I: RIType> RIType for Inner<T, I>[src]

The type is passed as the inner type.

type FFIType = I::FFIType

The ffi type that is used to represent Self.

Auto Trait Implementations

impl<T, I> RefUnwindSafe for Inner<T, I> where
    I: RefUnwindSafe,
    T: RefUnwindSafe
[src]

impl<T, I> Send for Inner<T, I> where
    I: Send,
    T: Send
[src]

impl<T, I> Sync for Inner<T, I> where
    I: Sync,
    T: Sync
[src]

impl<T, I> Unpin for Inner<T, I> where
    I: Unpin,
    T: Unpin
[src]

impl<T, I> UnwindSafe for Inner<T, I> where
    I: UnwindSafe,
    T: UnwindSafe
[src]

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> MaybeRefUnwindSafe for T where
    T: RefUnwindSafe
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.