Encode

Trait Encode 

Source
pub unsafe trait Encode {
    const ENCODING: Encoding;
}
Expand description

Types that have an Objective-C type-encoding.

Usually you will want to implement RefEncode as well.

If your type is an opaque type you should not need to implement this; there you will only need RefEncode.

§Safety

The type must be FFI-safe, meaning a C-compatible repr (repr(C), repr(u8), repr(transparent) where the inner types are C-compatible, and so on). See the nomicon on other reprs.

Objective-C will make assumptions about the type (like its size, alignment and ABI) from its encoding, so the implementer must verify that the encoding is accurate.

Concretely, Self::ENCODING must match the result of running @encode in Objective-C with the type in question.

You should also beware of having Drop types implement this, since when passed to Objective-C via objc2::msg_send! their destructor will not be called!

§Examples

Implementing for a struct:

#[repr(C)]
struct MyType {
    a: i32,
    b: f64,
    c: *const c_void,
}

unsafe impl Encode for MyType {
    const ENCODING: Encoding = Encoding::Struct(
        // The name of the type that Objective-C sees.
        "MyType",
        &[
            // Delegate to field's implementations.
            // The order is the same as in the definition.
            i32::ENCODING,
            f64::ENCODING,
            <*const c_void>::ENCODING,
        ],
    );
}

// Note: You would also implement `RefEncode` for this type.

Required Associated Constants§

Source

const ENCODING: Encoding

The Objective-C type-encoding for this type.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl Encode for f32

Source§

const ENCODING: Encoding = Encoding::Float

Source§

impl Encode for f64

Source§

const ENCODING: Encoding = Encoding::Double

Source§

impl Encode for i8

Source§

const ENCODING: Encoding = Encoding::Char

Source§

impl Encode for i16

Source§

const ENCODING: Encoding = Encoding::Short

Source§

impl Encode for i32

Source§

const ENCODING: Encoding = Encoding::Int

Source§

impl Encode for i64

Source§

const ENCODING: Encoding = Encoding::LongLong

Source§

impl Encode for isize

The encoding of isize varies based on the target pointer width.

Source§

const ENCODING: Encoding = i32::ENCODING

Source§

impl Encode for u8

Source§

const ENCODING: Encoding = Encoding::UChar

Source§

impl Encode for u16

Source§

const ENCODING: Encoding = Encoding::UShort

Source§

impl Encode for u32

Source§

const ENCODING: Encoding = Encoding::UInt

Source§

impl Encode for u64

Source§

const ENCODING: Encoding = Encoding::ULongLong

Source§

impl Encode for usize

The encoding of usize varies based on the target pointer width.

Source§

const ENCODING: Encoding = u32::ENCODING

Source§

impl Encode for AtomicI8

Available on target_has_atomic=8 only.
Source§

impl Encode for AtomicI16

Available on target_has_atomic=16 only.
Source§

impl Encode for AtomicI32

Available on target_has_atomic=32 only.
Source§

impl Encode for AtomicI64

Available on target_has_atomic=64 only.
Source§

impl Encode for AtomicIsize

Available on target_has_atomic=ptr only.
Source§

impl Encode for AtomicU8

Available on target_has_atomic=8 only.
Source§

impl Encode for AtomicU16

Available on target_has_atomic=16 only.
Source§

impl Encode for AtomicU32

Available on target_has_atomic=32 only.
Source§

impl Encode for AtomicU64

Available on target_has_atomic=64 only.
Source§

impl Encode for AtomicUsize

Available on target_has_atomic=ptr only.
Source§

impl Encode for NonZeroI8

Source§

const ENCODING: Encoding = i8::ENCODING

Source§

impl Encode for NonZeroI16

Source§

const ENCODING: Encoding = i16::ENCODING

Source§

impl Encode for NonZeroI32

Source§

const ENCODING: Encoding = i32::ENCODING

Source§

impl Encode for NonZeroI64

Source§

const ENCODING: Encoding = i64::ENCODING

Source§

impl Encode for NonZeroIsize

Source§

const ENCODING: Encoding = isize::ENCODING

Source§

impl Encode for NonZeroU8

Source§

const ENCODING: Encoding = u8::ENCODING

Source§

impl Encode for NonZeroU16

Source§

const ENCODING: Encoding = u16::ENCODING

Source§

impl Encode for NonZeroU32

Source§

const ENCODING: Encoding = u32::ENCODING

Source§

impl Encode for NonZeroU64

Source§

const ENCODING: Encoding = u64::ENCODING

Source§

impl Encode for NonZeroUsize

Source§

const ENCODING: Encoding = usize::ENCODING

Source§

impl<'a, T: RefEncode + ?Sized> Encode for &'a T

Source§

const ENCODING: Encoding = T::ENCODING_REF

Source§

impl<'a, T: RefEncode + ?Sized> Encode for &'a mut T

Source§

const ENCODING: Encoding = T::ENCODING_REF

Source§

impl<Ret: EncodeReturn> Encode for extern "C" fn() -> Ret

Source§

impl<Ret: EncodeReturn> Encode for extern "C-unwind" fn() -> Ret

Source§

impl<Ret: EncodeReturn> Encode for unsafe extern "C" fn() -> Ret

Source§

impl<Ret: EncodeReturn> Encode for unsafe extern "C-unwind" fn() -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for extern "C" fn(A) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for extern "C" fn(A, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for extern "C-unwind" fn(A) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for extern "C-unwind" fn(A, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for unsafe extern "C" fn(A) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for unsafe extern "C" fn(A, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for extern "C" fn(A, B) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for extern "C" fn(A, B, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for extern "C-unwind" fn(A, B) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for extern "C-unwind" fn(A, B, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for unsafe extern "C" fn(A, B) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for unsafe extern "C" fn(A, B, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for extern "C" fn(A, B, C) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for extern "C" fn(A, B, C, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for extern "C" fn(A, B, C, D) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for extern "C" fn(A, B, C, D, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ...) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) -> Ret

Source§

impl<Ret: EncodeReturn, A: EncodeArgument, B: EncodeArgument, C: EncodeArgument, D: EncodeArgument, E: EncodeArgument, F: EncodeArgument, G: EncodeArgument, H: EncodeArgument, I: EncodeArgument, J: EncodeArgument, K: EncodeArgument, L: EncodeArgument, M: EncodeArgument, N: EncodeArgument, O: EncodeArgument, P: EncodeArgument> Encode for unsafe extern "C-unwind" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, ...) -> Ret

Source§

impl<T: Encode + OptionEncode> Encode for Option<T>

Source§

impl<T: Encode + ?Sized> Encode for Cell<T>

Source§

const ENCODING: Encoding = T::ENCODING

Source§

impl<T: Encode + ?Sized> Encode for UnsafeCell<T>

Source§

const ENCODING: Encoding = T::ENCODING

Source§

impl<T: Encode + ?Sized> Encode for ManuallyDrop<T>

Source§

const ENCODING: Encoding = T::ENCODING

Source§

impl<T: Encode> Encode for Wrapping<T>

Source§

const ENCODING: Encoding = T::ENCODING

Source§

impl<T: Encode> Encode for MaybeUninit<T>

Source§

const ENCODING: Encoding = T::ENCODING

Source§

impl<T: Encode, const LENGTH: usize> Encode for [T; LENGTH]

Source§

impl<T: RefEncode + ?Sized> Encode for *const T

Source§

const ENCODING: Encoding = T::ENCODING_REF

Source§

impl<T: RefEncode + ?Sized> Encode for *mut T

Source§

const ENCODING: Encoding = T::ENCODING_REF

Source§

impl<T: RefEncode + ?Sized> Encode for NonNull<T>

Source§

const ENCODING: Encoding = T::ENCODING_REF

Source§

impl<T: RefEncode> Encode for AtomicPtr<T>

Available on target_has_atomic=ptr only.

Implementors§

Source§

impl Encode for Bool

Source§

const ENCODING: Encoding = inner::BOOL::__ENCODING

Source§

impl Encode for Sel

Source§

const ENCODING: Encoding = Encoding::Sel