Trait tracers::runtime::ProbeArgType

pub trait ProbeArgType<T> {
    type WrapperType: ProbeArgWrapper;
    fn wrap(arg: T) -> Self::WrapperType;
}

This trait is defined on any type which is supported as an argument to a probe.

In general only scalar integer types are supported directly, though pointers can be passed as u64 values and the tracing code is then responsible for knowing what to do with the pointer (for example, treat it as a null-terminated UTF-8 string, or a pointer to a certain structure, etc).

Associated Types

type WrapperType: ProbeArgWrapper

Loading content...

Required methods

fn wrap(arg: T) -> Self::WrapperType

Loading content...

Implementations on Foreign Types

impl ProbeArgType<i64> for i64

type WrapperType = i64

fn wrap(arg: i64) -> <i64 as ProbeArgType<i64>>::WrapperType

impl ProbeArgType<u16> for u16

type WrapperType = u16

fn wrap(arg: u16) -> <u16 as ProbeArgType<u16>>::WrapperType

impl<'a, T> ProbeArgType<&'a T> for &'a T where
    T: ProbeArgType<T> + Copy, 

type WrapperType = <T as ProbeArgType<T>>::WrapperType

fn wrap(arg: &'a T) -> <&'a T as ProbeArgType<&'a T>>::WrapperType

impl ProbeArgType<i8> for i8

type WrapperType = i8

fn wrap(arg: i8) -> <i8 as ProbeArgType<i8>>::WrapperType

impl<T> ProbeArgType<*const T> for *const T

type WrapperType = *const T

fn wrap(arg: *const T) -> <*const T as ProbeArgType<*const T>>::WrapperType

impl ProbeArgType<u32> for u32

type WrapperType = u32

fn wrap(arg: u32) -> <u32 as ProbeArgType<u32>>::WrapperType

impl<'_, '_> ProbeArgType<&'_ Option<String>> for &'_ Option<String>

The general implementation for Option<T> won't work for Option<String> because we don't support the String type, only references like &String or &str. But an Option<String> is quite often used and it should be supported, so we'll implement it directly here.

The result is the same as the outcome of the conversion in the string module.

type WrapperType = Option<CString>

fn wrap(
    arg: &Option<String>
) -> <&'_ Option<String> as ProbeArgType<&'_ Option<String>>>::WrapperType

impl<'_, '_> ProbeArgType<&'_ str> for &'_ str

type WrapperType = Option<CString>

fn wrap(arg: &str) -> <&'_ str as ProbeArgType<&'_ str>>::WrapperType

impl<'_, '_> ProbeArgType<&'_ OsStr> for &'_ OsStr

type WrapperType = Option<CString>

fn wrap(arg: &OsStr) -> <&'_ OsStr as ProbeArgType<&'_ OsStr>>::WrapperType

impl ProbeArgType<usize> for usize

type WrapperType = usize

fn wrap(arg: usize) -> <usize as ProbeArgType<usize>>::WrapperType

impl ProbeArgType<u8> for u8

type WrapperType = u8

fn wrap(arg: u8) -> <u8 as ProbeArgType<u8>>::WrapperType

impl<'_, '_> ProbeArgType<&'_ OsString> for &'_ OsString

type WrapperType = Option<CString>

fn wrap(
    arg: &OsString
) -> <&'_ OsString as ProbeArgType<&'_ OsString>>::WrapperType

impl<'a> ProbeArgType<&'a CString> for &'a CString

type WrapperType = &'a CString

fn wrap(
    arg: &'a CString
) -> <&'a CString as ProbeArgType<&'a CString>>::WrapperType

impl ProbeArgType<i16> for i16

type WrapperType = i16

fn wrap(arg: i16) -> <i16 as ProbeArgType<i16>>::WrapperType

impl<'a> ProbeArgType<&'a CStr> for &'a CStr

type WrapperType = &'a CStr

fn wrap(arg: &'a CStr) -> <&'a CStr as ProbeArgType<&'a CStr>>::WrapperType

impl ProbeArgType<i32> for i32

type WrapperType = i32

fn wrap(arg: i32) -> <i32 as ProbeArgType<i32>>::WrapperType

impl ProbeArgType<u64> for u64

type WrapperType = u64

fn wrap(arg: u64) -> <u64 as ProbeArgType<u64>>::WrapperType

impl ProbeArgType<bool> for bool

type WrapperType = bool

fn wrap(arg: bool) -> <bool as ProbeArgType<bool>>::WrapperType

impl ProbeArgType<isize> for isize

type WrapperType = isize

fn wrap(arg: isize) -> <isize as ProbeArgType<isize>>::WrapperType

impl<'_, '_, T> ProbeArgType<&'_ Option<T>> for &'_ Option<T> where
    T: ProbeArgType<T> + Copy, 

type WrapperType = Option<<T as ProbeArgType<T>>::WrapperType>

fn wrap(
    arg: &Option<T>
) -> <&'_ Option<T> as ProbeArgType<&'_ Option<T>>>::WrapperType

impl<'_, '_> ProbeArgType<&'_ String> for &'_ String

type WrapperType = Option<CString>

fn wrap(arg: &String) -> <&'_ String as ProbeArgType<&'_ String>>::WrapperType

Loading content...

Implementors

Loading content...