Template Struct Constructor

Defined in File object-construction.hpp

Nested Relationships

Nested Types

Class Constructor::Context

Struct Documentation

template<typename T> struct Constructor

Tracks raw/live slots independently of singleton teardown.

Distinct slots may be constructed/destroyed concurrently; overlapping operations on a busy slot are rejected. Callers retain storage until their operation ends. User code runs outside the tracking mutex, including reentrant operations on other slots. Public static operations use the shared T context; final owners capture that context and never consult static storage during release.

Public Static Functions

static inline std::shared_ptr<Context> release_context()

Declaration: [[nodiscard]]

Returns:: Retained shared tracking context for this exact T specialization. Capture it before static/facade teardown for final-owner operations; it does not retain the underlying object storage.

template<typename ...Args> static inline void construct(T *pointer, std::size_t count, Args... args)

Forward batch construction/replacement to the shared per-T context.

Parameters:

pointer – Caller-owned aligned contiguous storage.
count – Number of slots.
args – Arguments copied/moved into this call and repeatedly forwarded to slot construction. The Context per-slot synchronization, partial-effects and user-exception rules apply. This does not allocate backing or return it to a pool.

static inline void destroy(T *pointer, std::size_t count = 1)

Destroy tracked live slots through the shared T context without releasing backing storage.

Parameters:

pointer – Stable contiguous storage.
count – Slot count, one by default. Raw/untracked slots are skipped; busy conflicts and user exceptions propagate under Context rules.

static inline void erase(T *first, T *last)

Forget a raw half-open tracking range through the shared T context.