Trait tracers_core::argtypes::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<bool> for bool

type WrapperType = bool

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

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

type WrapperType = &'a CStr

fn wrap(arg: &'a CStr) -> Self::WrapperType

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

type WrapperType = &'a CString

fn wrap(arg: &'a CString) -> Self::WrapperType

impl ProbeArgType<usize> for usize

type WrapperType = usize

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

impl ProbeArgType<isize> for isize

type WrapperType = isize

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

impl ProbeArgType<u64> for u64

type WrapperType = u64

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

impl ProbeArgType<i64> for i64

type WrapperType = i64

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

impl ProbeArgType<u32> for u32

type WrapperType = u32

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

impl ProbeArgType<i32> for i32

type WrapperType = i32

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

impl ProbeArgType<u16> for u16

type WrapperType = u16

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

impl ProbeArgType<i16> for i16

type WrapperType = i16

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

impl ProbeArgType<u8> for u8

type WrapperType = u8

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

impl ProbeArgType<i8> for i8

type WrapperType = i8

fn wrap(arg: i8) -> Self::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>) -> Self::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>) -> Self::WrapperType

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

type WrapperType = *const T

fn wrap(arg: *const T) -> Self::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) -> Self::WrapperType

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

type WrapperType = Option<CString>

fn wrap(arg: &str) -> Self::WrapperType

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

type WrapperType = Option<CString>

fn wrap(arg: &String) -> Self::WrapperType

Loading content...

Implementors

Loading content...