Trait UnsafeHrTimerPointer

pub unsafe trait UnsafeHrTimerPointer: Sync + Sized {
    type TimerMode: HrTimerMode;
    type TimerHandle: HrTimerHandle;

    // Required method
    unsafe fn start(
        self,
        expires: <Self::TimerMode as HrTimerMode>::Expires,
    ) -> Self::TimerHandle;
}

Unsafe version of HrTimerPointer for situations where leaking the HrTimerHandle returned by start would be unsound. This is the case for stack allocated timers.

Typical implementers are pinned references such as Pin<&T>.

Safety

Implementers of this trait must ensure that instances of types implementing UnsafeHrTimerPointer outlives any associated HrTimerPointer::TimerHandle instances.

Required Associated Types

type TimerMode: HrTimerMode

The operational mode associated with this timer.

This defines how the expiration value is interpreted.

type TimerHandle: HrTimerHandle

A handle representing a running timer.

Safety

If the timer is running, or if the timer callback is executing when the handle is dropped, the drop method of Self::TimerHandle must not return until the timer is stopped and the callback has completed.

Required Methods

unsafe fn start( self, expires: <Self::TimerMode as HrTimerMode>::Expires, ) -> Self::TimerHandle

Start the timer after expires time units. If the timer was already running, it is restarted at the new expiry time.

Safety

Caller promises keep the timer structure alive until the timer is dead. Caller can ensure this by not leaking the returned Self::TimerHandle.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, T> UnsafeHrTimerPointer for Pin<&'a T>

where T: Send + Sync + HasHrTimer<T> + HrTimerCallback<Pointer<'a> = Self>,

type TimerMode = <T as HasHrTimer<T>>::TimerMode

type TimerHandle = PinHrTimerHandle<'a, T>

unsafe fn start( self, expires: <<T as HasHrTimer<T>>::TimerMode as HrTimerMode>::Expires, ) -> Self::TimerHandle

impl<'a, T> UnsafeHrTimerPointer for Pin<&'a mut T>

where T: Send + Sync + HasHrTimer<T> + HrTimerCallback<Pointer<'a> = Self>,

type TimerMode = <T as HasHrTimer<T>>::TimerMode

type TimerHandle = PinMutHrTimerHandle<'a, T>

unsafe fn start( self, expires: <<T as HasHrTimer<T>>::TimerMode as HrTimerMode>::Expires, ) -> Self::TimerHandle

Implementors