unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
        if id == TypeId::of::<Self>() {
            Some(self as *const Self as *const ())
        } else {
            None
        }
    }
/// If `self` is the same type as the provided `TypeId`, returns an untyped
/// `*const` pointer to that type. Otherwise, returns `None`.
///
/// If you wish to downcast a `Subscriber`, it is strongly advised to use
/// the safe API provided by [`downcast_ref`] instead.
///
/// This API is required for `downcast_raw` to be a trait method; a method
/// signature like [`downcast_ref`] (with a generic type parameter) is not
/// object-safe, and thus cannot be a trait method for `Subscriber`. This
/// means that if we only exposed `downcast_ref`, `Subscriber`
/// implementations could not override the downcasting behavior
///
/// This method may be overridden by "fan out" or "chained" subscriber
/// implementations which consist of multiple composed types. Such
/// subscribers might allow `downcast_raw` by returning references to those
/// component if they contain components with the given `TypeId`.
///
/// # Safety
///
/// The [`downcast_ref`] method expects that the pointer returned by
/// `downcast_raw` is non-null and points to a valid instance of the type
/// with the provided `TypeId`. Failure to ensure this will result in
/// undefined behaviour, so implementing `downcast_raw` is unsafe.
///
/// [`downcast_ref`]: #method.downcast_ref


If you wish to downcast a `Subscriber`, it is strongly advised to use
the safe API provided by [`downcast_ref`] instead.



This method may be overridden by "fan out" or "chained" subscriber
implementations which consist of multiple composed types. Such
subscribers might allow `downcast_raw` by returning references to those
component if they contain components with the given `TypeId`.
If you wish to downcast a ` Subscriber ` it is strongly advised to use the safe API provided by [ ` downcast_ref ` ] instead . This method may be overridden by " fan out " or " chained " subscriber implementations which consist of multiple composed types . Such subscribers might allow ` downcast_raw ` by returning references to those component if they contain components with the given ` TypeId ` .
unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
        if id == TypeId::of::<Self>() {
            Some(self as *const Self as *const ())
        } else {
            None
        }
    }
unsafe fn downcast_raw ( & self , id : TypeId ) -> Option < * const ( ) > { if id == TypeId :: of :: < Self > ( ) { Some ( self as * const Self as * const ( ) ) } else { None } }
If `self` is the same type as the provided `TypeId`, returns an untyped
`*const` pointer to that type.
If ` self ` is the same type as the provided ` TypeId ` returns an untyped ` * const ` pointer to that type .
&self
id
TypeId
safety
The [`downcast_ref`] method expects that the pointer returned by
`downcast_raw` is non-null and points to a valid instance of the type
with the provided `TypeId`. Failure to ensure this will result in
undefined behaviour, so implementing `downcast_raw` is unsafe.

[`downcast_ref`]: #method.downcast_ref
The [ ` downcast_ref ` ] method expects that the pointer returned by ` downcast_raw ` is non - null and points to a valid instance of the type with the provided ` TypeId ` . Failure to ensure this will result in undefined behaviour so implementing ` downcast_raw ` is unsafe . [ ` downcast_ref ` ] : #method . downcast_ref