Trait detour::HookableWith[−][src]

pub unsafe trait HookableWith<D: Function>: Function { }

Trait indicating that Self can be detoured by the given function D.

Implementations on Foreign Types

impl<Ret: 'static> HookableWith<fn() -> Ret> for unsafe fn() -> Ret[src]

impl<Ret: 'static> HookableWith<extern "cdecl" fn() -> Ret> for unsafe extern "cdecl" fn() -> Ret[src]

impl<Ret: 'static> HookableWith<extern "stdcall" fn() -> Ret> for unsafe extern "stdcall" fn() -> Ret[src]

impl<Ret: 'static> HookableWith<extern "fastcall" fn() -> Ret> for unsafe extern "fastcall" fn() -> Ret[src]

impl<Ret: 'static> HookableWith<extern "win64" fn() -> Ret> for unsafe extern "win64" fn() -> Ret[src]

impl<Ret: 'static> HookableWith<extern "C" fn() -> Ret> for unsafe extern "C" fn() -> Ret[src]

impl<Ret: 'static> HookableWith<extern "system" fn() -> Ret> for unsafe extern "system" fn() -> Ret[src]

impl<Ret: 'static> HookableWith<extern "thiscall" fn() -> Ret> for unsafe extern "thiscall" fn() -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<fn(A) -> Ret> for unsafe fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<extern "cdecl" fn(A) -> Ret> for unsafe extern "cdecl" fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<extern "stdcall" fn(A) -> Ret> for unsafe extern "stdcall" fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<extern "fastcall" fn(A) -> Ret> for unsafe extern "fastcall" fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<extern "win64" fn(A) -> Ret> for unsafe extern "win64" fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<extern "C" fn(A) -> Ret> for unsafe extern "C" fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<extern "system" fn(A) -> Ret> for unsafe extern "system" fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static> HookableWith<extern "thiscall" fn(A) -> Ret> for unsafe extern "thiscall" fn(_: A) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<fn(A, B) -> Ret> for unsafe fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<extern "cdecl" fn(A, B) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<extern "stdcall" fn(A, B) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<extern "fastcall" fn(A, B) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<extern "win64" fn(A, B) -> Ret> for unsafe extern "win64" fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<extern "C" fn(A, B) -> Ret> for unsafe extern "C" fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<extern "system" fn(A, B) -> Ret> for unsafe extern "system" fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static> HookableWith<extern "thiscall" fn(A, B) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<fn(A, B, C) -> Ret> for unsafe fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<extern "cdecl" fn(A, B, C) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<extern "stdcall" fn(A, B, C) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<extern "fastcall" fn(A, B, C) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<extern "win64" fn(A, B, C) -> Ret> for unsafe extern "win64" fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<extern "C" fn(A, B, C) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<extern "system" fn(A, B, C) -> Ret> for unsafe extern "system" fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static> HookableWith<extern "thiscall" fn(A, B, C) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<fn(A, B, C, D) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<extern "cdecl" fn(A, B, C, D) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<extern "stdcall" fn(A, B, C, D) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<extern "fastcall" fn(A, B, C, D) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<extern "win64" fn(A, B, C, D) -> Ret> for unsafe extern "win64" fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<extern "C" fn(A, B, C, D) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<extern "system" fn(A, B, C, D) -> Ret> for unsafe extern "system" fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static> HookableWith<extern "thiscall" fn(A, B, C, D) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<fn(A, B, C, D, E) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<extern "cdecl" fn(A, B, C, D, E) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<extern "stdcall" fn(A, B, C, D, E) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<extern "fastcall" fn(A, B, C, D, E) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<extern "win64" fn(A, B, C, D, E) -> Ret> for unsafe extern "win64" fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<extern "C" fn(A, B, C, D, E) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<extern "system" fn(A, B, C, D, E) -> Ret> for unsafe extern "system" fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> HookableWith<extern "thiscall" fn(A, B, C, D, E) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<fn(A, B, C, D, E, F) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<extern "cdecl" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<extern "stdcall" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<extern "fastcall" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<extern "win64" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "win64" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<extern "C" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<extern "system" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "system" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> HookableWith<extern "thiscall" fn(A, B, C, D, E, F) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> HookableWith<fn(A, B, C, D, E, F, G) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret[src]

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

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

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

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> HookableWith<extern "C" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret[src]

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> HookableWith<fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret[src]

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

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

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

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

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

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G, H) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret[src]

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> HookableWith<fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret[src]

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

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

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

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

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

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G, H, I) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret[src]

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

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

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

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

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

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

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

impl<Ret: 'static, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G, H, I, J) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret[src]

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> HookableWith<fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret[src]

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> HookableWith<extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret[src]

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> HookableWith<extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret[src]

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> HookableWith<extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret[src]

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

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

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

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> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret[src]

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> HookableWith<fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret[src]

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> HookableWith<extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret[src]

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> HookableWith<extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret[src]

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> HookableWith<extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret[src]

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

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

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

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> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret[src]

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> HookableWith<fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe extern "win64" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe extern "system" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M) -> Ret[src]

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> HookableWith<fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

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> HookableWith<extern "cdecl" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe extern "cdecl" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

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> HookableWith<extern "stdcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe extern "stdcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

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> HookableWith<extern "fastcall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe extern "fastcall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

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> HookableWith<extern "win64" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe extern "win64" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

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> HookableWith<extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

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> HookableWith<extern "system" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe extern "system" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

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> HookableWith<extern "thiscall" fn(A, B, C, D, E, F, G, H, I, J, K, L, M, N) -> Ret> for unsafe extern "thiscall" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, _: M, _: N) -> Ret[src]

Loading content...

Implementors

impl<T: Function> HookableWith<T> for T[src]

Loading content...