Struct PoolMember 

pub struct PoolMember {
    pub process_name: String,
    pub state: MemberState,
    pub entered_state_at: DateTime<Utc>,
    pub allocation_ref: Option<AllocationRef>,
}

One pool slot’s state.

Fields

process_name: String

metadata.name of the backing Process.

state: MemberState

Pool member’s current slot state.

entered_state_at: DateTime<Utc>

When the member entered the current state.

allocation_ref: Option<AllocationRef>

If allocated: the AllocationRef holding this slot.

Implementations

impl PoolMember

pub fn state_count_fanout(members: &[Self]) -> (u32, u32, u32, u32)

Substrate primitive: single-pass closed-set fold over a [PoolMember] slice producing the (ready, allocated, spawning, returning) 4-tuple every PoolStatus seed stamps at its four counter slots. The Failed arm is a no-op (no PoolStatus counter tracks failed members — they surface via PoolPhase::Degraded instead), pinned by the closed-set match so a future variant that SHOULD count toward one of the four buckets triggers the compiler’s exhaustiveness check here rather than silently falling through.

Consumed by PoolStatus::observed. A caller that needs a single per-variant count outside the status-seed fanout should keep spelling members.iter().filter(...).count() rather than walking this 4-tuple — the fanout is shaped for the PoolStatus fill, not for arbitrary per-variant queries.

pub fn process_names_set(members: &[Self]) -> HashSet<String>

Substrate primitive: single-pass closed-set collection of the process_name axis over a [PoolMember] slice into an owned HashSet<String> — the O(1)-lookup shape every spawn-arm on the workspace builds pre-collision-check against a candidate crate::pool::PoolMember::process_name produced by [tatara-pool-reconciler::naming::member_process_name].

Pre-lift the 2-line members.iter().map(|m| m.process_name.clone()).collect() chain was hand-authored at TWO sites past the ★★ PRIME- DIRECTIVE ≥ 2 duplication threshold in tatara-pool-reconciler::controller_pool, both restating the SAME process_name projection through the SAME iter → map → collect shape and both feeding a .contains (&candidate) probe:

• reconcile_inner’s legacy allocation-driven PoolDecision::Spawn arm (desired == 0 path) — collision-set for member_process_name(&pool_name, &pool_uid, slot) per spawn slot.
• apply_convergence_actions — collision-set for the SAME composer inside the R11 desired-count ConvergenceAction::CreateMember loop.

Post-lift both consumers share ONE substrate owner; the composed HashSet<String> still feeds the same HashSet::<String>::contains(&candidate) probe at each callsite unchanged. A future normalization step on the occupied-name axis (case-fold before insertion, a per-cluster prefix strip, deduplication against a sibling stale-name registry, exclusion of Returning/Failed members that no longer own their slot) lands at ONE substrate method rather than being restated at each callsite.

Sibling to Self::state_count_fanout on the (collection shape × slice-owned fold) axis: both primitives fold a [PoolMember] slice into one caller-shaped aggregate in a single pass, both are #[must_use], both take the slice by reference so no caller has to reshape its Vec<PoolMember> or Vec<PoolMember> slice upstream.

Theory anchor: THEORY.md §VI.1 (generation over composition — the HashSet<String> collision-set shape recurred at TWO hand-authored sites past the ★★ PRIME-DIRECTIVE ≥ 2 duplication trigger, and is lifted to ONE owner here). THEORY.md §II.1 invariant 5 (composition preserves proofs — the pins bind the axis (process_name), the aggregate shape (HashSet<String>), the empty-slice corner, and the duplicate-name deduplication semantics HashSet provides implicitly, so a regression at any of those surfaces at tests::process_names_set_* rather than as silent occupied- slot skew at either spawn arm).

Trait Implementations

impl Clone for PoolMember

fn clone(&self) -> PoolMember

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PoolMember

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PoolMember

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for PoolMember

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Serialize for PoolMember

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.