Konstruieren eines expliziten RawWakers und einer VTable für Low-Level-Executors

use std::sync::Arc;
use std::task::{RawWaker, RawWakerVTable, Waker};
 
pub struct Signal;
impl Signal {
    pub fn wake(self: Arc<Self>) {
        // Implementation of notification logic goes here
    }
}
 
const VTABLE: RawWakerVTable = RawWakerVTable::new(
    clone_raw,
    wake_raw,
    wake_by_ref_raw,
    drop_raw,
);
 
fn clone_raw(data: *const ()) -> RawWaker {
    unsafe { Arc::increment_strong_count(data as *const Signal); }
    RawWaker::new(data, &VTABLE)
}
 
fn wake_raw(data: *const ()) {
    let arc = unsafe { Arc::from_raw(data as *const Signal) };
    arc.wake();
}
 
fn wake_by_ref_raw(data: *const ()) {
    let arc = unsafe { Arc::from_raw(data as *const Signal) };
    let cloned = arc.clone();
    let _ = Arc::into_raw(arc);
    cloned.wake();
}
 
fn drop_raw(data: *const ()) {
    unsafe { Arc::from_raw(data as *const Signal); }
}
 
pub fn create_waker(signal: Arc<Signal>) -> Waker {
    let raw = RawWaker::new(Arc::into_raw(signal) as *const (), &VTABLE);
    unsafe { Waker::from_raw(raw) }
}