//! Strongly typed safe opaque pointers to GHOST handles.
//!
//! We define opaque ZST structures for each handle type, these then implement the [`GhostHandle`] trait, which allows them to be used for type arguments to [`Handle<T>`](Handle).
use super ::* ;
pub use types ::{ Handle , GhostHandle } ;
pub ( crate ) trait AsHandle < T : GhostHandle >
{
fn as_handle ( & mut self ) -> & mut Handle < T > ;
#[ inline ] fn as_raw ( & mut self ) -> * mut Handle < T >
{
self . as_handle ( ) as * mut Handle < T >
}
}
impl < T : GhostHandle > AsHandle < T > for Handle < T >
{
#[ inline ] fn as_handle ( & mut self ) -> & mut Handle < T >
{
self
}
}
#[ cfg(not(nightly)) ] enum HandleInner { }
macro_rules! handle {
( $name :ident , $inner_name :ident ) = > {
#[ cfg(nightly) ] pub struct $inner_name ( ! ) ;
#[ cfg(not(nightly)) ] pub struct $inner_name ( HandleInner ) ;
impl private ::Sealed for $inner_name { }
impl GhostHandle for $inner_name { }
pub type $name = * mut Handle < $inner_name > ;
} ;
}
handle ! ( GHOST_SystemHandle , System ) ;
handle ! ( GHOST_TimerTaskHandle , TimerTask ) ;
handle ! ( GHOST_WindowHandle , Window ) ;
handle ! ( GHOST_EventHandle , Event ) ;
handle ! ( GHOST_RectangleHandle , Rectangle ) ;
handle ! ( GHOST_EventConsumerHandle , EventConsumer ) ;
handle ! ( GHOST_ContextHandle , Context ) ;
handle ! ( GHOST_XrContextHandle , XrContextHandle ) ;
// This is very unsafe.
/* #[inline] pub(crate) unsafe fn coerce<'a, T>(from: * mut Handle<T>) -> &'a mut Handle<T>
where T : GhostHandle
{
std ::mem ::transmute ::< * mut _ , & ' a mut _ > ( from ) //this is needed because we can't safely dereference `Handle<T>`.
} * /