Struct LTAny 

pub struct LTAny { /* private fields */ }

dyn Any with fixed-size inlined storage. Types that fit in the storage are stored without allocation. Types that are too large are boxed. Stored types may not implement Send and Sync. For thread-safe version see TAny.

Implementations

impl LTAny

pub const fn fits<T>() -> bool

Returns true if the type T fits and can be stored without allocation. If true, then LTAny::new::<T> is guaranteed to not allocate.

Example

if LTAny::fits::<u32>() {
  // Guaranteed to not allocate.
  LTAny::new(42u32);
}

pub fn new<T>(value: T) -> Self

where T: 'static,

Construct new LTAny with the given value.

If the type T fits in the storage, it is stored without allocation. Otherwise, it will be boxed.

Type of value may not implement Send or Sync. But LTAny itself does not implement Send and Sync. For Send and Sync container see TAny.

Example

let mut a: LTAny = LTAny::new(42u32);
 
assert_eq!(a.downcast_ref::<u32>().unwrap(), &42);

pub fn from_box<T: 'static>(boxed: Box<T>) -> Self

Construct new LTAny from the given boxed value.

If type fits in the storage, value will be unboxed. Otherwise it will be stored as boxed, but no allocation will be performed.

Type of value may not implement Send or Sync. But LTAny itself does not implement Send and Sync. For Send and Sync container see TAny.

Example

let boxed = Box::new([1u32; 42]);
 
// No additional allocation is performed.
let a: LTAny = LTAny::from_box(boxed);
 
assert_eq!(a.downcast_ref::<[u32; 42]>().unwrap(), &[1u32; 42]);

pub fn from_any(boxed: Box<dyn Any>) -> Self

Construct new LTAny with the given boxed any. Since type is unknown, it will be stored as boxed.

Allows Any without Send or Sync. But LTAny itself does not implement Send and Sync. For Send and Sync container see TAny.

Example

use core::any::Any;
 
let any: Box<dyn Any> = Box::new(42u32);
 
let a: LTAny = LTAny::from_any(any);
 
assert_eq!(a.downcast_ref::<u32>().unwrap(), &42);

pub fn type_id(&self) -> TypeId

Returns the type id of the stored value.

Example

use core::any::TypeId;
 
let a: LTAny = LTAny::new(42u32);
 
assert_eq!(a.type_id(), TypeId::of::<u32>());

pub fn is<T>(&self) -> bool

where T: 'static,

Returns true if the stored value is of type T.

Example

let a: LTAny = LTAny::new(42u32);
assert!(a.is::<u32>());

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: 'static,

Returns some reference to the stored value if it is of type T. Otherwise returns none.

Example

let a: LTAny = LTAny::new(42u32);
 
assert_eq!(a.downcast_ref::<u32>().unwrap(), &42);

pub fn downcast_mut<T>(&mut self) -> Option<&mut T>

where T: 'static,

Returns some mutable reference to the stored value if it is of type T. Otherwise returns none.

Example

let mut a: LTAny = LTAny::new(42u32);
 
assert_eq!(a.downcast_mut::<u32>().unwrap(), &mut 42);

pub fn downcast<T>(self) -> Result<T, LTAny>

where T: 'static,

Returns the stored value if it is of type T. Otherwise return self back.

This will unbox the value if it was stored as boxed.

Example

let a: LTAny = LTAny::new(42u32);
 
let Ok(a) = a.downcast::<u32>() else {
   panic!();
};

pub unsafe fn downcast_ref_unchecked<T>(&self) -> &T

where T: 'static,

Returns reference to the stored value without type checking.

Safety

The caller must ensure that the type is correct.

Example

let a: LTAny = LTAny::new(42u32);
 
unsafe {
   assert_eq!(a.downcast_ref_unchecked::<u32>(), &42);
}

pub unsafe fn downcast_mut_unchecked<T>(&mut self) -> &mut T

where T: 'static,

Returns mutable reference to the stored value without type checking.

Safety

The caller must ensure that the type is correct.

Example

let mut a: LTAny = LTAny::new(42u32);
 
unsafe {
  assert_eq!(a.downcast_mut_unchecked::<u32>(), &mut 42);
}

pub unsafe fn downcast_unchecked<T>(self) -> T

where T: 'static,

Returns the stored value without type checking.

This will unbox the value if it was stored as boxed.

Safety

The caller must ensure that the type is correct.

Example

let a: LTAny = LTAny::new(42u32);
 
unsafe {
 assert_eq!(a.downcast_unchecked::<u32>(), 42);
}

Trait Implementations

impl Drop for LTAny

fn drop(&mut self)

Executes the destructor for this type.

impl From<Box<dyn Any>> for LTAny

fn from(boxed: Box<dyn Any>) -> Self

Converts to this type from the input type.

impl From<TAny> for LTAny

fn from(value: TAny) -> Self

Converts to this type from the input type.