Trait detour::Function

pub unsafe trait Function: Sized + Copy + Sync + 'static {
    type Arguments;
    type Output;
    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.

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.

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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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 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 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 "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 "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 "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 "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 "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 "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 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 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 "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 "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 "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 "thiscall" 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 "thiscall" 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