Struct Flex 

pub struct Flex<T: ?Sized, B: Buffer> { /* private fields */ }

Inline storage with heap fallback for ?Sized types.

Stores a trait object (or slice) inline when it fits, otherwise heap-allocates. Use is_inline to query which path was taken.

The total struct size equals size_of::<B>().

Layout

The heap pointer slot doubles as the inline/heap discriminant (null = inline, non-null = heap address).

• ?Sized T: [metadata(ptr)][heap_ptr(ptr)][value(B − 2*ptr)]
• Sized T: [heap_ptr(ptr)][value(B − ptr)]

Use the flex! macro for ?Sized construction, or Flex::new for Sized types.

Compile-time safety

Buffers too small for the overhead produce a compile error:

nexus_smartptr::define_buffer!(B8, 8);
trait Foo { fn foo(&self); }
struct Bar;
impl Foo for Bar { fn foo(&self) {} }
// B8 can't fit ?Sized overhead (metadata + heap pointer = 16 bytes).
let _: nexus_smartptr::Flex<dyn Foo, B8> = nexus_smartptr::flex!(Bar);

Implementations

impl<T: ?Sized, B: Buffer> Flex<T, B>

pub const fn capacity() -> usize

Returns the usable inline value capacity in bytes.

For Sized types: B::CAPACITY - 8 (heap pointer slot). For ?Sized types: B::CAPACITY - 16 (metadata + heap pointer).

pub fn is_inline(&self) -> bool

Returns true if the value is stored inline (no heap allocation).

impl<T, B: Buffer> Flex<T, B>

pub fn new(val: T) -> Self

Constructs a Flex from a Sized value.

Stores inline if the value fits, otherwise heap-allocates.

Examples

use nexus_smartptr::{Flex, B32};

let f: Flex<u64, B32> = Flex::new(42);
assert!(f.is_inline());
assert_eq!(*f, 42);

Trait Implementations

impl<T: ?Sized, B: Buffer> Deref for Flex<T, B>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: ?Sized, B: Buffer> DerefMut for Flex<T, B>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: ?Sized, B: Buffer> Drop for Flex<T, B>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized + Send, B: Buffer> Send for Flex<T, B>

impl<T: ?Sized + Sync, B: Buffer> Sync for Flex<T, B>