Skip to main content

FunctionPtr

dll_syringe::function

Trait FunctionPtr

pub unsafe trait FunctionPtr:
    Sized
    + Copy
    + Send
    + Sync
    + 'static {
    type Args;
    type RefArgs<'a>;
    type Output;
    type NonExtern: FunctionPtr;

    const ARITY: usize;
    const ABI: Abi;

    // Required methods
    unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self;
    fn as_ptr(&self) -> RawFunctionPtr;
}

Available on Windows only.

Expand description

Trait representing a function.

§Safety

This trait should only be implemented for function pointers and the associated types and constants have to match the function pointer type.

Required Associated Constants§

const ARITY: usize

The function’s arity (number of arguments).

const ABI: Abi

The ABI of this function.

Required Associated Types§

type Args

The argument types as a tuple.

type RefArgs<'a>

The argument types as a tuple of references.

type Output

The return type.

type NonExtern: FunctionPtr

The non-extern version of the function pointer.

Required Methods§

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

Constructs a FunctionPtr from an untyped function pointer.

§Safety

This function is unsafe because it can not check if the argument points to a function of the correct type.

fn as_ptr(&self) -> RawFunctionPtr

Returns a untyped function pointer for this function.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types§

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> FunctionPtr for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for extern "system" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe extern "system" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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> FunctionPtr for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I, J) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H, I) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G, H) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F, G) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F)

type Output = Ret

type NonExtern = fn(A, B, C, D, E, F) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D, &'a E)

type Output = Ret

type NonExtern = fn(A, B, C, D, E) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

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

type RefArgs<'a> = (&'a A, &'a B, &'a C, &'a D)

type Output = Ret

type NonExtern = fn(A, B, C, D) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B, C)

type RefArgs<'a> = (&'a A, &'a B, &'a C)

type Output = Ret

type NonExtern = fn(A, B, C) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A, B)

type RefArgs<'a> = (&'a A, &'a B)

type Output = Ret

type NonExtern = fn(A, B) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize

const ABI: Abi

type Args = (A,)

type RefArgs<'a> = (&'a A,)

type Output = Ret

type NonExtern = fn(A) -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

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

const ARITY: usize = 0

const ABI: Abi

type Args = ()

type RefArgs<'a> = ()

type Output = Ret

type NonExtern = fn() -> Ret

unsafe fn from_ptr(ptr: RawFunctionPtr) -> Self

fn as_ptr(&self) -> RawFunctionPtr

Implementors§