Trait Function

pub unsafe trait Function:
    Sized
    + Copy
    + Sync
    + 'static {
    type Arguments;
    type Output;

    // Required methods
    unsafe fn from_ptr(ptr: *const ()) -> Self;
    fn to_ptr(&self) -> *const ();
}

Trait representing a function that can be used as a target or detour for detouring.

Required Associated Types

type Arguments

The argument types as a tuple.

type Output

The return type.

Required Methods

unsafe fn from_ptr(ptr: *const ()) -> Self

Constructs a Function from an untyped pointer.

fn to_ptr(&self) -> *const ()

Returns an untyped pointer for this function.

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

impl<Ret: 'static> Function for fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for extern "C" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for extern "cdecl" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for extern "fastcall" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for extern "stdcall" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for extern "system" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for extern "win64" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for unsafe fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for unsafe extern "C" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for unsafe extern "cdecl" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for unsafe extern "fastcall" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for unsafe extern "stdcall" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for unsafe extern "system" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static> Function for unsafe extern "win64" fn() -> Ret

type Arguments = ()

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for extern "C" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for extern "cdecl" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for extern "fastcall" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for extern "stdcall" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for extern "system" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for extern "win64" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for unsafe fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for unsafe extern "C" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for unsafe extern "cdecl" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for unsafe extern "fastcall" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for unsafe extern "stdcall" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for unsafe extern "system" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static> Function for unsafe extern "win64" fn(A) -> Ret

type Arguments = (A,)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for extern "C" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for extern "cdecl" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for extern "fastcall" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for extern "stdcall" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for extern "system" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for extern "win64" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for unsafe fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for unsafe extern "C" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for unsafe extern "cdecl" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for unsafe extern "fastcall" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for unsafe extern "stdcall" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for unsafe extern "system" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static> Function for unsafe extern "win64" fn(A, B) -> Ret

type Arguments = (A, B)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for extern "C" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for extern "cdecl" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for extern "fastcall" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for extern "stdcall" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for extern "system" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for extern "win64" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for unsafe fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for unsafe extern "C" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for unsafe extern "cdecl" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for unsafe extern "fastcall" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for unsafe extern "stdcall" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for unsafe extern "system" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> Function for unsafe extern "win64" fn(A, B, C) -> Ret

type Arguments = (A, B, C)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for extern "C" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for extern "cdecl" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for extern "fastcall" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for extern "stdcall" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for extern "system" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for extern "win64" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for unsafe fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for unsafe extern "C" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for unsafe extern "system" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> Function for unsafe extern "win64" fn(A, B, C, D) -> Ret

type Arguments = (A, B, C, D)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for extern "C" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for extern "cdecl" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for extern "fastcall" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for extern "stdcall" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for extern "system" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for extern "win64" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for unsafe fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for unsafe extern "C" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for unsafe extern "system" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E) -> Ret

type Arguments = (A, B, C, D, E)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for extern "C" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for extern "system" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for extern "win64" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for unsafe fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F) -> Ret

type Arguments = (A, B, C, D, E, F)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for extern "C" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for extern "system" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for unsafe fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F, G) -> Ret

type Arguments = (A, B, C, D, E, F, G)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for extern "system" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F, G, H) -> Ret

type Arguments = (A, B, C, D, E, F, G, H)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for extern "system" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F, G, H, I) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for extern "system" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for unsafe extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for unsafe extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for unsafe extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> Function for unsafe extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> Function for fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> Function for extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> Function for extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> Function for extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> Function for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> Function for extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> Function for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

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

type Arguments = (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

type Output = Ret

unsafe fn from_ptr(ptr: *const ()) -> Self

fn to_ptr(&self) -> *const ()

Implementors