Struct AllocationRef 

pub struct AllocationRef {
    pub name: String,
    pub namespace: String,
}

Light reference to an EphemeralAllocation.

Fields

name: String

namespace: String

Implementations

impl AllocationRef

pub fn new(name: impl Into<String>, namespace: impl Into<String>) -> Self

Substrate constructor for AllocationRef: composes the (name, namespace) pair through ONE impl Into<String>-gated entry point — the ONE-liner collapse of the paired AllocationRef { name: n.into(), namespace: ns.into() } struct-literal incantation every downstream consumer restated by hand pre-lift.

Pre-lift the AllocationRef { name, namespace } struct-literal was hand-authored at FOUR production sites past the ★★ PRIME- DIRECTIVE ≥ 2 duplication threshold across the workspace, all composing an owned (name: String, namespace: String) pair under one of two roles:

• tatara-pool-reconciler::controller_allocation::reconcile_inner Bind path — the assignedProcess status slot’s ref, pairing the just-bound member Process name with the allocation’s containing namespace.
• tatara-pool-reconciler::controller_allocation::reconcile_inner Release path — the same assignedProcess slot shape, stamped at the release-side status patch alongside the (unchanged) boundPool ref.
• tatara-pool-reconciler::allocation_decide::AllocationConvergenceCtx::observe pool-matched handle — the matched_pool slot’s ref, pairing EphemeralPool::owned_name_or_empty with the pool’s containing namespace.
• tatara-github-watcher::allocation_factory::allocation_from_pr — the pool_ref slot on the AllocationSpec emitted from a PullRequestEvent, pairing the operator-configured pool name with the watcher’s target namespace.

All FOUR sites walked the SAME two-field struct-literal shape — an owned name half, an owned namespace half — differing only in provenance. Post-lift each callsite reads AllocationRef::new(name, ns) and the produced value feeds the same downstream slot (assignedProcess / bound_pool / matched_pool / spec.pool_ref) unchanged. The impl Into<String> signature accepts every provenance the pre-lift sites carried — owned String (the reconciler’s owned-form projections), &str (the factory’s n.to_string() / namespace.to_string() borrow-to-owned promotions), Cow<str>, and every other Into<String> implementor — so no callsite has to change its upstream provenance to route through the primitive.

Return-form axis: owned AllocationRef — the wire-format shape crate::pool::AllocationRef’s serde rename_all = "camelCase" produces on both spec (poolRef) and status (boundPool / assignedProcess) slots. The primitive owns the axis-order (name, namespace) — the same order the four consumers spelled — so a slot swap surfaces at the allocation_ref_new_positional_axis_order pin below rather than as silent <namespace>/<name> inversion downstream.

Peer to the sibling substrate primitives already opened on the pool-side (name, namespace) axis pair: EphemeralPool::name_or_empty (borrow-form name), EphemeralPool::owned_name_or_empty (owned-form name); this constructor is the composer that folds the owned-form projections into the wire-format ref shape.

A future refactor of AllocationRef’s field set (a resource_kind: String field for cross-CRD refs, an api_version: String field for FQN references, a canonicalization pass over the namespace half, a non-empty-name gate) lands at ONE substrate constructor site here and every downstream consumer inherits the upgrade mechanically — no per- callsite hand-edit at the FOUR reconciler + factory sites.

Theory anchor: THEORY.md §VI.1 (generation over composition — the AllocationRef { name, namespace } struct-literal shape recurred at four 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 positional axis-order + the Into<String> provenance closure + byte-identical parity with the pre-lift struct-literal + PartialEq coherence with the hand-authored form, so a regression that reshaped any surface at tests::allocation_ref_new_* rather than as silent operator-facing skew between the assignedProcess / bound_pool / matched_pool / spec.pool_ref slots on the SAME allocation).

Trait Implementations

impl Clone for AllocationRef

fn clone(&self) -> AllocationRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AllocationRef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AllocationRef

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AllocationRef

impl JsonSchema for AllocationRef

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 PartialEq for AllocationRef

fn eq(&self, other: &AllocationRef) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for AllocationRef

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AllocationRef