-//! Copyright © 2014–2022 Chris Morgan

-//! https://github.com/chris-morgan/anymap/blob/master/COPYING

-//! impl some traits for dyn Any

-use core::any::{Any, TypeId};

-use core::fmt;

-

-#[doc(hidden)]

-pub trait CloneToAny {

- /// Clone `self` into a new `Box<dyn CloneAny>` object.

- fn clone_to_any(&self) -> Box<dyn CloneAny>;

-}

-

-impl<T: Any + Clone> CloneToAny for T {

- #[inline]

- fn clone_to_any(&self) -> Box<dyn CloneAny> {

- Box::new(self.clone())

- }

-}

-

-macro_rules! impl_clone {

- ($t:ty) => {

- impl Clone for Box<$t> {

- #[inline]

- fn clone(&self) -> Box<$t> {

- // SAFETY: this dance is to reapply any Send/Sync marker. I’m not happy about this

- // approach, given that I used to do it in safe code, but then came a dodgy

- // future-compatibility warning where_clauses_object_safety, which is spurious for

- // auto traits but still super annoying (future-compatibility lints seem to mean

- // your bin crate needs a corresponding allow!). Although I explained my plight¹

- // and it was all explained and agreed upon, no action has been taken. So I finally

- // caved and worked around it by doing it this way, which matches what’s done for

- // core::any², so it’s probably not *too* bad.

- //

- // ¹ https://github.com/rust-lang/rust/issues/51443#issuecomment-421988013

- // ² https://github.com/rust-lang/rust/blob/e7825f2b690c9a0d21b6f6d84c404bb53b151b38/library/alloc/src/boxed.rs#L1613-L1616

- let clone: Box<dyn CloneAny> = (**self).clone_to_any();

- let raw: *mut dyn CloneAny = Box::into_raw(clone);

- unsafe { Box::from_raw(raw as *mut $t) }

- }

- }

-

- impl fmt::Debug for $t {

- #[inline]

- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

- f.pad(stringify!($t))

- }

- }

- };

-}

-

-/// Methods for downcasting from an `Any`-like trait object.

-///

-/// This should only be implemented on trait objects for subtraits of `Any`, though you can

-/// implement it for other types and it’ll work fine, so long as your implementation is correct.

-pub trait Downcast {

- /// Gets the `TypeId` of `self`.

- fn type_id(&self) -> TypeId;

-

- // Note the bound through these downcast methods is 'static, rather than the inexpressible

- // concept of Self-but-as-a-trait (where Self is `dyn Trait`). This is sufficient, exceeding

- // TypeId’s requirements. Sure, you *can* do CloneAny.downcast_unchecked::<NotClone>() and the

- // type system won’t protect you, but that doesn’t introduce any unsafety: the method is

- // already unsafe because you can specify the wrong type, and if this were exposing safe

- // downcasting, CloneAny.downcast::<NotClone>() would just return an error, which is just as

- // correct.

- //

- // Now in theory we could also add T: ?Sized, but that doesn’t play nicely with the common

- // implementation, so I’m doing without it.

-

- /// Downcast from `&Any` to `&T`, without checking the type matches.

- ///

- /// # Safety

- ///

- /// The caller must ensure that `T` matches the trait object, on pain of *undefined behaviour*.

- unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T;

-

- /// Downcast from `&mut Any` to `&mut T`, without checking the type matches.

- ///

- /// # Safety

- ///

- /// The caller must ensure that `T` matches the trait object, on pain of *undefined behaviour*.

- unsafe fn downcast_mut_unchecked<T: 'static>(&mut self) -> &mut T;

-}

-

-/// A trait for the conversion of an object into a boxed trait object.

-pub trait IntoBox<A: ?Sized + Downcast>: Any {

- /// Convert self into the appropriate boxed form.

- fn into_box(self) -> Box<A>;

-}

-

-macro_rules! implement {

- ($any_trait:ident $(+ $auto_traits:ident)*) => {

- impl Downcast for dyn $any_trait $(+ $auto_traits)* {

- #[inline]

- fn type_id(&self) -> TypeId {

- self.type_id()

- }

-

- #[inline]

- unsafe fn downcast_ref_unchecked<T: 'static>(&self) -> &T {

- &*(self as *const Self as *const T)

- }

-

- #[inline]

- unsafe fn downcast_mut_unchecked<T: 'static>(&mut self) -> &mut T {

- &mut *(self as *mut Self as *mut T)

- }

- }

-

- impl<T: $any_trait $(+ $auto_traits)*> IntoBox<dyn $any_trait $(+ $auto_traits)*> for T {

- #[inline]

- fn into_box(self) -> Box<dyn $any_trait $(+ $auto_traits)*> {

- Box::new(self)

- }

- }

- }

-}

-

-implement!(Any);

-implement!(Any + Send);

-implement!(Any + Send + Sync);

-

-/// [`Any`], but with cloning.

-///

-/// Every type with no non-`'static` references that implements `Clone` implements `CloneAny`.

-/// See [`core::any`] for more details on `Any` in general.

-pub trait CloneAny: Any + CloneToAny {}

-impl<T: Any + Clone> CloneAny for T {}

-implement!(CloneAny);

-implement!(CloneAny + Send);

-implement!(CloneAny + Send + Sync);

-impl_clone!(dyn CloneAny);

-impl_clone!(dyn CloneAny + Send);

-impl_clone!(dyn CloneAny + Send + Sync);