dungeon_cell/marker_traits/

bound.rs

use core::fmt::Debug;
use core::panic::{RefUnwindSafe, UnwindSafe};

use super::sealed::Sealed;
use crate::bound::bounds;

/// Marker only implemented for [`Bound`][crate::bound::Bound].
///
/// This trait is [sealed](https://rust-lang.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed)
/// and cannot be implemented by external types.
pub trait IsBound:
    Sealed
    + Sized
    + Copy
    + Clone
    + Sync
    + Send
    + Unpin
    + RefUnwindSafe
    + UnwindSafe
    + 'static
{
    /// Flag that is `true` when the bound includes [`Send`][std::marker::Send].
    const BOUND_BY_SEND: bool = false;

    /// Flag that is `true` when the bound includes [`Sync`][std::marker::Sync].
    const BOUND_BY_SYNC: bool = false;

    /// Flag that is `true` when the bound includes [`Copy`][std::marker::Copy].
    const BOUND_BY_COPY: bool = false;

    /// Flag that is `true` when the bound includes [`Unpin`][std::marker::Unpin].
    const BOUND_BY_UNPIN: bool = false;

    /// Flag that is `true` when the bound includes [`Clone`][std::clone::Clone].
    const BOUND_BY_CLONE: bool = false;

    /// Flag that is `true` when the bound includes [`Debug`][std::fmt::Debug].
    const BOUND_BY_DEBUG: bool = false;

    /// Marker type that will implement [`Send`][std::marker::Send] if the bound includes it.
    ///
    /// Because `Send` is an auto trait, storing this marker will automatically disable
    /// implementing `Send` when the bound doesn't have it.
    type SendMarker: Sized
        + Sync
        + Copy
        + Clone
        + Debug
        + Unpin
        + RefUnwindSafe
        + UnwindSafe
        + 'static;

    /// Marker type that will implement [`Sync`][std::marker::Sync] if the bound includes it.
    ///
    /// Because `Sync` is an auto trait, storing this marker will automatically disable
    /// implementing `sync` when the bound doesn't have it.
    type SyncMarker: Sized
        + Send
        + Copy
        + Clone
        + Debug
        + Unpin
        + RefUnwindSafe
        + UnwindSafe
        + 'static;

    /// Marker type that will implement [`Copy`][std::marker::Copy] if the bound includes it.
    type CopyMarker: Sized
        + Send
        + Sync
        + Clone
        + Debug
        + Unpin
        + RefUnwindSafe
        + UnwindSafe
        + 'static;

    /// Marker type that will implement [`Clone`][std::clone::Clone] if the bound includes it.
    type CloneMarker: Sized
        + Send
        + Sync
        + Debug
        + Unpin
        + RefUnwindSafe
        + UnwindSafe
        + 'static;

    /// Marker type that will implement [`Unpin`][std::marker::Unpin] if the bound includes it.
    ///
    /// Because `Unpin` is an auto trait, storing this marker will automatically disable
    /// implementing `Unpin` when the bound doesn't have it.
    type UnpinMarker: Sized
        + Send
        + Sync
        + Copy
        + Clone
        + Debug
        + RefUnwindSafe
        + UnwindSafe
        + 'static;

    /// Marker type that will implement [`Debug`][std::fmt::Debug] if the bound includes it.
    type DebugMarker: Sized
        + Send
        + Sync
        + Copy
        + Clone
        + Unpin
        + RefUnwindSafe
        + UnwindSafe
        + 'static;
}

mod sealed {
    use super::*;
    use crate::bound::{traits, Bound};
    use core::marker::{PhantomData, PhantomPinned};

    #[derive(Copy, Clone, Debug)]
    pub struct SendMarker;

    #[derive(Copy, Clone, Debug)]
    pub struct NotSendMarker(PhantomData<*const ()>);

    // SAFETY: This is safe because this type is only used as a marker.
    // There are no issues accessing it in a Sync manner.
    unsafe impl Sync for NotSendMarker {}

    #[derive(Copy, Clone, Debug)]
    pub struct SyncMarker;

    #[derive(Copy, Clone, Debug)]
    pub struct NotSyncMarker(PhantomData<*const ()>);

    // SAFETY: This is safe because this type is only used as a marker.
    // There are no issues accessing it in a Send manner.
    unsafe impl Send for NotSyncMarker {}

    #[derive(Copy, Clone, Debug)]
    pub struct CopyMarker;

    #[derive(Debug, Clone)]
    pub struct NotCopyMarker;

    #[derive(Copy, Clone, Debug)]
    pub struct UnpinMarker;

    #[derive(Copy, Clone, Debug)]
    pub struct NotUnpinMarker(PhantomPinned);

    #[derive(Clone, Debug)]
    pub struct CloneMarker;

    #[derive(Debug)]
    pub struct NotCloneMarker;

    #[derive(Clone, Copy, Debug)]
    pub struct DebugMarker;

    #[derive(Clone, Copy)]
    pub struct NotDebugMarker;

    impl Sealed for bounds::Empty {}
    impl IsBound for bounds::Empty {
        type SendMarker = NotSendMarker;

        type SyncMarker = NotSyncMarker;

        type CopyMarker = NotCopyMarker;

        type UnpinMarker = NotUnpinMarker;

        type CloneMarker = NotCloneMarker;

        type DebugMarker = NotDebugMarker;
    }

    macro_rules! bound_impl {
        (@send, __) => {
            type SendMarker = NotSendMarker;
        };
        (@sync, __) => {
            type SyncMarker = NotSyncMarker;
        };
        (@copy, __) => {
            type CopyMarker = NotCopyMarker;
        };
        (@clone, __) => {
            type CloneMarker = NotCloneMarker;
        };
        (@unpin, __) => {
            type UnpinMarker = NotUnpinMarker;
        };
        (@debug, __) => {
            type DebugMarker = NotDebugMarker;
        };
        (@send, Send) => {
            const BOUND_BY_SEND: bool = true;
            type SendMarker = SendMarker;
        };
        (@sync, Sync) => {
            const BOUND_BY_SYNC: bool = true;
            type SyncMarker = SyncMarker;
        };
        (@copy, Copy) => {
            const BOUND_BY_COPY: bool = true;
            type CopyMarker = CopyMarker;
        };
        (@clone, Clone) => {
            const BOUND_BY_CLONE: bool = true;
            type CloneMarker = CloneMarker;
        };
        (@unpin, Unpin) => {
            const BOUND_BY_UNPIN: bool = true;
            type UnpinMarker = UnpinMarker;
        };
        (@debug, Debug) => {
            const BOUND_BY_DEBUG: bool = true;
            type DebugMarker = DebugMarker;
        };
    }

    macro_rules! powerset {
        (
            @helper
            $empty:ident
            []
            [$($bounds:ident),*]
        ) => {
        };
        (
            @helper
            $empty:ident
            [$trait:ident $(, $traits:ident)*]
            [$send:ident, $sync:ident, $copy:ident, $clone:ident, $unpin:ident, $debug:ident]
        ) => {
            impl Sealed for Bound<
              traits::$send, traits::$sync, traits::$copy, traits::$clone, traits::$unpin, traits::$debug
            > {}

            impl IsBound for Bound<
              traits::$send, traits::$sync, traits::$copy, traits::$clone, traits::$unpin, traits::$debug
            > {
                bound_impl!(@clone, $clone);
                bound_impl!(@debug, $debug);
                bound_impl!(@send, $send);
                bound_impl!(@sync, $sync);
                bound_impl!(@copy, $copy);
                bound_impl!(@unpin, $unpin);
            }
        };
        // @helper [traitB, traitD] [(boundA, false), (boundB, true), (boundC, false), (boundD, true)] bound => trait, ...
        (
            @helper
            $empty:ident
            [$($trait:ident),*]
            [$($bound:ident),*]
            $next_trait:ident
            $(, $traits:ident)*
        ) => {
            powerset!(@helper $empty [$($trait),*] [$($bound,)* $empty] $($traits),*);
            powerset!(@helper $empty [$($trait,)* $next_trait] [$($bound,)* $next_trait] $($traits),*);
        };
        ($empty:ident, $($trait:ident),*) => {
            powerset!(@helper $empty [] [] $($trait),*);
        };
    }

    powerset![__, Send, Sync, Copy, Clone, Unpin, Debug];
}