Struct ProtectPool 

pub struct ProtectPool {
    backing: SEXP,
    capacity: usize,
    generations: Vec<u32>,
    free_slots: Vec<usize>,
    next_slot: usize,
    len: usize,
    _nosend: PhantomData<Rc<()>>,
}

A VECSXP-backed pool for GC protection with generational keys.

Example

let mut pool = unsafe { ProtectPool::new(16) };

let key = unsafe { pool.insert(some_sexp) };
// SEXP is now protected from GC

let sexp = pool.get(key).unwrap();
// Use the SEXP...

unsafe { pool.release(key) };
// SEXP is no longer protected (eligible for GC)

Fields

backing: SEXP

The VECSXP that holds protected SEXPs. Anchored by R_PreserveObject.

capacity: usize

Current capacity of the backing VECSXP.

generations: Vec<u32>

Generation counter per VECSXP slot. Incremented on each release. A key is valid iff generations[key.slot] == key.generation.

free_slots: Vec<usize>

Free VECSXP slot indices for reuse.

next_slot: usize

Next fresh VECSXP slot index (for when free_slots is empty).

len: usize

Number of currently protected objects.

_nosend: PhantomData<Rc<()>>

Implementations

impl ProtectPool

pub const DEFAULT_CAPACITY: usize = 16

Initial default capacity.

pub unsafe fn new(capacity: usize) -> Self

Create a new pool with the given initial capacity.

Safety

Must be called from the R main thread.

pub unsafe fn with_capacity(capacity: usize) -> Self

Create a new pool with a specific initial capacity.

Safety

Must be called from the R main thread.

Panics

Panics if capacity exceeds R_xlen_t::MAX or u32::MAX.

pub unsafe fn insert(&mut self, sexp: SEXP) -> ProtectKey

Protect a SEXP, returning a generational key.

The SEXP will be protected from GC until release is called with the returned key. If the key is dropped without calling release, the SEXP remains protected (leak, not crash).

Safety

Must be called from the R main thread. sexp must be a valid SEXP.

Panics

Panics if the pool has grown beyond u32::MAX slots.

pub unsafe fn release(&mut self, key: ProtectKey)

Release a previously protected SEXP.

If the key is stale (already released, or from a different pool), this is a no-op.

Safety

Must be called from the R main thread.

pub fn get(&self, key: ProtectKey) -> Option<SEXP>

Get the SEXP for a key, or None if the key is stale.

pub unsafe fn replace(&mut self, key: ProtectKey, sexp: SEXP) -> bool

Overwrite the SEXP at an existing key without releasing/reinserting.

Returns true if the key was valid and the value was replaced. Returns false if the key was stale (no-op).

This is the pool equivalent of R_Reprotect — O(1), no allocation.

Safety

Must be called from the R main thread. sexp must be a valid SEXP.

pub fn contains_key(&self, key: ProtectKey) -> bool

Check if a key is currently valid (not stale).

pub fn len(&self) -> usize

Number of currently protected objects.

pub fn is_empty(&self) -> bool

Whether the pool is empty.

pub fn capacity(&self) -> usize

Current capacity of the backing VECSXP.

fn alloc_slot(&mut self) -> usize

unsafe fn grow(&mut self)

Trait Implementations

impl Drop for ProtectPool

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Protector for ProtectPool

unsafe fn protect(&mut self, sexp: SEXP) -> SEXP

Protect a SEXP from garbage collection.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 80 bytes