portability/libportability-gfx/src/handle.rs

use VK_NULL_HANDLE;
use std::{borrow, fmt, ops};

static ICD_LOADER_MAGIC: u32 = 0x01CDC0DE;

#[repr(C)]
pub struct Handle<T>(*mut T);

impl<T> Handle<T> {
    pub fn new(value: T) -> Self {
        let ptr = Box::into_raw(Box::new(value));
        Handle(ptr)
    }

    pub fn unwrap(self) -> Box<T> {
        unsafe { Box::from_raw(self.0) }
    }

    pub fn is_null(&self) -> bool {
        self.0 == VK_NULL_HANDLE as *mut T
    }
}

impl<T> Clone for Handle<T> {
    fn clone(&self) -> Self {
        Handle(self.0)
    }
}

impl<T> Copy for Handle<T> {}

impl<T> ops::Deref for Handle<T> {
    type Target = T;
    fn deref(&self) -> &T {
        unsafe { &*self.0 }
    }
}

impl<T> ops::DerefMut for Handle<T> {
    fn deref_mut(&mut self) -> &mut T {
        unsafe { &mut *self.0 }
    }
}

impl<T> borrow::Borrow<T> for Handle<T> {
    fn borrow(&self) -> &T {
        unsafe { &*self.0 }
    }
}

impl<T> fmt::Debug for Handle<T> {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(formatter, "Handle({:p})", self.0)
    }
}

#[repr(C)]
pub struct DispatchHandle<T>(u32, Handle<T>);

impl<T> DispatchHandle<T> {
    pub fn new(value: T) -> Self {
        DispatchHandle(ICD_LOADER_MAGIC, Handle::new(value))
    }

    pub fn unwrap(self) -> Box<T> {
        self.1.unwrap()
    }

    pub fn is_null(&self) -> bool {
        self.1.is_null()
    }
}

impl<T> Clone for DispatchHandle<T> {
    fn clone(&self) -> Self {
        DispatchHandle(self.0, self.1)
    }
}

impl<T> Copy for DispatchHandle<T> {}

impl<T> ops::Deref for DispatchHandle<T> {
    type Target = T;
    fn deref(&self) -> &T {
        self.1.deref()
    }
}

impl<T> ops::DerefMut for DispatchHandle<T> {
    fn deref_mut(&mut self) -> &mut T {
        self.1.deref_mut()
    }
}

impl<T> borrow::Borrow<T> for DispatchHandle<T> {
    fn borrow(&self) -> &T {
        self.1.borrow()
    }
}

impl<T> fmt::Debug for DispatchHandle<T> {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(formatter, "DispatchHandle({:p})", (self.1).0)
    }
}