Enum RestartStrategy 

pub enum RestartStrategy {
    OneForOne,
    OneForAll,
    RestForOne,
    SimpleOneForOne,
}

One of the four canonical Erlang/OTP restart strategies.

The strategy decides what happens to sibling children when one child dies. Per-child behaviour is governed by RestartPolicy.

Variants

OneForOne

On child failure, restart only that child. Default; matches most “tree of independent workers” use cases.

OneForAll

On child failure, restart every child. Used when children share state and must be in sync.

RestForOne

On child failure, restart the failed child and every child started after it (preserving startup order). Used when later children depend on earlier ones.

SimpleOneForOne

Dynamic children of the same shape, started on demand. The supervisor doesn’t know its children at boot; they’re added as they’re needed (e.g. one child per session).

Implementations

impl RestartStrategy

pub const fn discriminant(&self) -> &'static str

Stable variant discriminant — auto-generated by #[derive(Discriminant)]. The string IS the wire identifier for metrics labels / audit-log tags / rate-limit keys; renaming an existing variant is a breaking change.

impl RestartStrategy

pub const fn is_one_for_one(&self) -> bool

pub const fn is_one_for_all(&self) -> bool

pub const fn is_rest_for_one(&self) -> bool

pub const fn is_simple_one_for_one(&self) -> bool

impl RestartStrategy

pub const ALL: &'static [Self]

Exhaustive iteration surface for every consumer that walks the closed four-arm RestartStrategy discriminator set (the future M4 mesh.pleme.io/v1alpha1/Supervisor CR materializer’s admission-webhook rejection body naming the accepted-:estrategia list, a future feira supervisor --estrategia … CLI arg-parse’s “did you mean” hint via a Self::from_wire-scan over the slice, the future feira app graph per-supervisor :estrategia column, any future round-trip fuzz harness that sweeps every arm). A future arm addition (an OTP-rest_for_all arm the theory ABSORPTION-ROADMAP might reach for once the four canonical OTP strategies stop covering the substrate’s discovered load-shape) extends this slice as one edit and every consumer picks up the new entry by construction; the compiler-checked exhaustiveness on the sibling method match arms (Self::as_str / Self::from_wire) is the build-time guarantee that no arm forgets to grow.

Peer of the sibling closed-set typed enums’ crate::CaixaKind::ALL (6b1f4fb) / crate::aplicacao::PlacementStrategy::ALL (18c7342) / crate::aplicacao::RateLimitUnit::ALL (6bce03d) / crate::dep::DepList::ALL (45ee563) exhaustive-iteration surfaces — the fifth (and the first M2 OTP-shape) closed-set typed enum on the caixa surface to converge onto the same one-canonical-arm-list-per-enum discipline.

pub const fn as_str(self) -> &'static str

Canonical PascalCase discriminator scalar this variant serializes as under crate::render::SUPERVISOR_KEY_ESTRATEGIA. The four arms return the paired crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ALL / crate::render::SUPERVISOR_ESTRATEGIA_REST_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_SIMPLE_ONE_FOR_ONE lifted constants so every substrate consumer that dispatches on the per-supervisor sibling-restart strategy (the future wasm-operator’s per-supervisor sibling-restart branch, the future M4 mesh.pleme.io/v1alpha1/Supervisor CR materializer’s admission-time enum-arm bind, the caixa-operator’s hierarchical reconciliation scheduler’s per-strategy fan-out) reads the same byte-string the Serialize derive emits — the pin test in [tests::restart_strategy_variants_serialize_to_lifted_scalar_values] asserts the two paths agree, peer of the M3 PlacementStrategy::as_str (cc8f749) on the sibling per-Aplicacao distribution-strategy axis.

pub fn from_wire(s: &str) -> Option<Self>

Substrate-canonical reverse projection on the :supervisor :estrategia closed-set axis — parses the PascalCase discriminator scalar back to the typed variant, or None when s is outside the closed-set arm-string set Self::as_str emits. Dispatches on the same lifted crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ALL / crate::render::SUPERVISOR_ESTRATEGIA_REST_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_SIMPLE_ONE_FOR_ONE constants the Self::as_str emitter walks, so the parse and emit halves of the round-trip migrate through one caixa-core edit on any future arm addition.

Prior to this lift the substrate carried only the forward Self → &str projection on the OTP sibling-restart axis (the Self::as_str emitter, the std::fmt::Display impl routed through it, the Serialize derive that emits the same byte-string under crate::render::SUPERVISOR_KEY_ESTRATEGIA) plus the kebab-case dispatcher-catalog identity via Self::discriminant — every non-serde consumer that wanted to parse a wire-form PascalCase strategy scalar had to re-inline a four-arm match s { "OneForOne" => …, "OneForAll" => …, "RestForOne" => …, "SimpleOneForOne" => …, _ => … } cascade that expressed no compile-time link back to the typed variant’s canonical lifted constant. A future variant rename or per-arm serde-attribute drift would silently split the wire byte-string one non-serde consumer parsed from the one the emitter wrote, with the failure surfacing at parse time far from the rebrand commit.

Distinct axis from the std::str::FromStr impl the gen_platform::FromStrKind derive already installs on this enum by design, not by drift: FromStr parses the kebab-case dispatcher-catalog identity ("one-for-one" / "one-for-all" / "rest-for-one" / "simple-one-for-one" — the inverse of Self::discriminant), while this method inverts the PascalCase wire byte-string Self::as_str emits. The two-axis split lets the dispatcher-catalog identity live in kebab-case (where every peer catalog identifier already lives) without forcing a wire-format rename on the tatara-lisp author surface (:estrategia OneForOne, PascalCase) — the same two-axis distinction the sibling crate::CaixaKind::from_wire (2aa6d23) / crate::aplicacao::PlacementStrategy::from_wire (18c7342) carry on their peer closed-set typed-enum wire round-trips.

Same closed-set-reverse-projection discipline the sibling crate::CaixaKind::from_wire (2aa6d23) / crate::aplicacao::PlacementStrategy::from_wire (18c7342) / crate::aplicacao::RateLimitUnit::from_suffix typed enums carry on the peer wire-side str → Self axes — extended onto the M2 OTP-shape sibling-restart-strategy closed-set axis, the fifth substrate-side closed-set typed enum to converge on the two-way str ↔ Self round-trip. Method-named from_wire (not from_str) to match the peer crate::CaixaKind::from_wire shape verbatim and side-step the std::str::FromStr impl the derive already installs on the sibling kebab-case axis. Returns Option<Self> (rather than Result<Self, _>) to match the peer shapes: the caller picks the diagnostic form appropriate for its use site.

Trait Implementations

impl AsRef<str> for RestartStrategy

Substrate-canonical AsRef<str> projection on the M2 per-supervisor sibling-restart RestartStrategy closed-set typed enum — routes through the same RestartStrategy::as_str pub const fn scalar accessor the paired std::fmt::Display impl and the un-renamed serde::Serialize derive already key off, so any future consumer that binds a RestartStrategy through the standard-library impl AsRef<str> bound (a future [caixa-feira] feira supervisor --estrategia <arm> verb that composes the emitted PascalCase wire scalar into a std::process::Command::arg shell-out of the future wasm-operator’s admission gate, a per-supervisor structured-log recorder on the future caixa-operator’s hierarchical reconciliation surface that accepts impl AsRef<str> at the tracing::field::Value Str-arm, a std::collections::HashMap lookup keyed on the estrategia wire byte through map.get::<str>(strategy.as_ref()) on a future per-strategy dispatch table) reaches the paired crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ALL / crate::render::SUPERVISOR_ESTRATEGIA_REST_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_SIMPLE_ONE_FOR_ONE lifted-const through one substrate-primitive dispatch rather than an open-coded .as_str() projection at every wire-up.

Peer of the sibling std::fmt::Display impl on the same primitive — both delegate to the shared RestartStrategy::as_str pub const fn accessor, so [format!("{s}")], s.as_str(), and <RestartStrategy as AsRef<str>>::as_ref(&s) resolve to the same byte-string per instance by construction. A future variant rename or #[serde(rename_all = "kebab-case")] attribute-drift on the enum reaches every one of the three paths (plus the wire-format Serialize derive that already routes through the same lifted const) through exactly one caixa-core edit.

Same “route the trait impl through the substrate-primitive accessor” discipline the sibling crate::CaixaVersion AsRef<str> impl (16d5c7e) carries on the paired top-level :versao typed newtype — extends it onto the second AsRef<str> axis on the caixa typed surface (the first M2 OTP-shape closed-set typed enum to converge onto the standard-library AsRef<str> projection). Rust-side newtype/typed-enum convention pairs AsRef<str> and [fmt::Display] on the same primitive so a caller who has one has both; before this lift, RestartStrategy carried [fmt::Display] but not the paired AsRef<str> impl the convention names.

Pinned load-bearing by [tests::restart_strategy_as_ref_str_routes_through_as_str_accessor] (byte-parity pin against RestartStrategy::as_str across the four-arm closed set) — any future silent detour that routes the impl through a divergent projection (a per-arm inline match self { … } re-inlining that opens a compile-time link to the un-lifted arm-literal, a swap onto the kebab-case gen_platform::Discriminant catalog identity that would collide the wire axis with the dispatcher-catalog axis) trips at caixa-core test time under assert_eq! rather than at a downstream impl AsRef<str>-bound consumer’s silent split.

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for RestartStrategy

fn clone(&self) -> RestartStrategy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RestartStrategy

impl Debug for RestartStrategy

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

Formats the value using the given formatter.

impl Default for RestartStrategy

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RestartStrategy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RestartStrategy

std::fmt::Display routed through RestartStrategy::as_str, so the pretty-printed byte-string every consumer that formats the strategy as user-facing text lands on (the future wasm-operator’s per-supervisor sibling-restart-strategy diagnostic line, the future feira app graph per-supervisor strategy line, the future M4 mesh.pleme.io/v1alpha1/Supervisor CR materializer’s admission-webhook rejection body) reaches for the same lifted crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ALL / crate::render::SUPERVISOR_ESTRATEGIA_REST_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_SIMPLE_ONE_FOR_ONE const the wire-format Serialize derive already emits under crate::render::SUPERVISOR_KEY_ESTRATEGIA and the RestartStrategy::as_str helper already returns.

Pre-convergence the two paths structurally disagreed — the #[derive(gen_platform::Discriminant)] + #[discriminant(also_display)] route (now retired here) sent std::fmt::Display through the gen-platform discriminant catalog string, which arrives kebab-case as "one-for-one" / "one-for-all" / "rest-for-one" / "simple-one-for-one", while the wire format ran as PascalCase "OneForOne" / "OneForAll" / "RestForOne" / "SimpleOneForOne" through the un-renamed serde derive. Every consumer that formatted the strategy for a diagnostic line, a graph, or a rejection body under format!("{v}") therefore landed under a different byte-string than the wire format the operator’s per-strategy dispatch keyed off — a silent split whose apply-time symptom (a format!("{v}")-carrying diagnostic quoting "one-for-one" while the wire scalar the operator probed was "OneForOne") surfaced as a confused correlate at operator-log time far from the two-declaration site.

Routing Display through RestartStrategy::as_str closes the third path: every format!("{v}") call reaches the same lifted [crate::render::SUPERVISOR_ESTRATEGIA_*] const the wire format and the RestartStrategy::as_str helper route through — Debug (the compiler-derived variant name), Display (via as_str), and Serialize (via the un-renamed derive) all resolve to the same PascalCase byte-string per variant. A future variant rename or #[serde(rename_all = "kebab-case")] attribute reaches every path at exactly one place, structurally.

The dispatcher-catalog identity remains kebab-case — Self::discriminant (from #[derive(gen_platform::Discriminant)]) still returns "one-for-one" / etc., and the fleet-wide [gen_platform::register_dispatcher!("caixa.restart-strategy", …)] registration keys the catalog off the same kebab identity. The two naming worlds now live on separate typed methods (Display / as_str for the wire byte-string, discriminant for the catalog identity) rather than sharing one Display route that structurally disagrees with the wire format.

Pin tests [tests::restart_strategy_display_routes_through_as_str_helper] and [tests::restart_strategy_display_matches_serialized_wire_byte_string] assert the three paths agree byte-for-byte on every variant, so a future variant rename or per-arm serde attribute drift is a build error visible at caixa-core test time, not a silent per-consumer dispatch miss at apply / reconcile time.

Mirrors the M3 crate::aplicacao::PlacementStrategy Display impl (aplicacao.rs:2306) on the sibling per-Aplicacao distribution-strategy axis — same three-path-convergence discipline, extended to close the second of three OTP-shaped closed-enum discriminator axes on the caixa typed surface.

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

Formats the value using the given formatter.

impl Eq for RestartStrategy

impl From<&RestartStrategy> for &'static str

Trait-idiomatic forward projection on RestartStrategy from a borrowed input onto the &'static str axis — the borrowed-input companion to the paired owned-input [From<RestartStrategy> for &'static str] impl immediately above. Routes byte-for-byte through the same substrate-primitive RestartStrategy::as_str pub const fn accessor so every consumer that binds a &RestartStrategy through the standard-library .into() / [From<&Self> for &'static str] axis (a RestartStrategy::ALL.iter().map(<&'static str>::from).collect::<Vec<_>>() per-arm accept-set materializer — whose iterator over &'static [RestartStrategy] yields &RestartStrategy, not RestartStrategy, so the owned-input From<RestartStrategy> axis alone forces every call site through an explicit .copied() / dereference / Copy-bound restatement rather than the direct trait-idiomatic projection; a future generic <T: Copy + for<'a> Into<&'static str>>-bound diagnostic column that walks the iter().map(Into::into) shape verbatim across every substrate-wide closed-set typed enum; the future wasm-operator’s per-supervisor sibling-restart-strategy diagnostic line that composes the accepted-set enumeration from an iterated RestartStrategy::ALL.iter().map(|s| s.into()) pipe rather than a per-arm match s { … } cascade; a future HashMap::<&'static str, RestartStrategy>::from_iter( RestartStrategy::ALL.iter().map(|s| (s.into(), *s)))-style per-strategy reverse-lookup table the sibling TryFrom<&str> impl cannot compose without this borrowed-input axis in place) reaches the same four-arm lifted crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ALL / crate::render::SUPERVISOR_ESTRATEGIA_REST_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_SIMPLE_ONE_FOR_ONE const the paired owned-input [From<RestartStrategy> for &'static str], the sibling std::fmt::Display, AsRef<str>, and RestartStrategy::as_str surfaces already return.

Fourth peer on the substrate-wide trait-idiomatic borrowed-input forward-projection family opened on crate::dep::DepList (64aa742) and extended onto crate::CaixaKind (5ab993a) and crate::CaixaDialeto (807b0b5). Rust’s From trait does not auto-derive the From<&Self> sibling from a From<Self> impl (the blanket impl<T, U> From<&T> for U where T: Copy, U: From<T> does not exist in core), so every closed-set typed enum that carries the owned-input axis but not the borrowed-input axis forces every borrowed-input call site through a .copied() / <&'static str>::from(*strategy) / strategy.as_str() detour whose type bounds have no compile-time link to the substrate primitive. RestartStrategy is the first M2 OTP-shape peer to converge onto this campaign (mirroring the first-mover role it played on the owned-input axis in 523157d); the remaining eleven substrate-wide closed-set fieldless typed enum peers (RestartPolicy, WitShape, RateLimitUnit, PlacementStrategy, PathShapeViolation, InvariantKind, ArchVerdict, Severity, FixSafety, Semantic, FerriteRuntime) are the future targets of this campaign.

Unlike the peer crate::CaixaKind axis pair (whose forward [From<Self> for &'static str] emits the lowercase Portuguese [Self::as_str] diagnostic vocabulary while the reverse TryFrom<&str> parses the PascalCase [Self::wire_name] author-surface vocabulary, forcing the round-trip through an intermediate wire-vocab hop), RestartStrategy’s [Self::as_str] emit and [Self::from_wire] parse share the same PascalCase vocabulary by construction, so the borrowed-input forward axis and the reverse axis compose directly — the round-trip witness pin below locks this direct composition without the intermediate hop the peer axis requires.

Pinned load-bearing by [tests::restart_strategy_from_borrowed_into_static_str_routes_through_as_str_accessor] (byte-parity pin against RestartStrategy::as_str across the four-arm emit-set via a borrowed input, plus a const-context materialization witness for the &'static str lifetime promise, plus a blanket .into() shape) and [tests::restart_strategy_from_owned_and_borrowed_into_static_str_agree_on_every_arm] (cross-axis partition pin against the paired owned-input [From<RestartStrategy> for &'static str] impl, plus a .iter().map(Into::into) pipe witness over RestartStrategy::ALL, plus a direct round-trip witness through TryFrom<&str> that closes the two-way &Self → &'static str → Self round-trip without the wire-vocab intermediate the peer crate::CaixaKind axis pair requires).

fn from(strategy: &RestartStrategy) -> &'static str

Converts to this type from the input type.

impl From<RestartStrategy> for &'static str

Trait-idiomatic forward projection on the M2-OTP-shape sibling-restart RestartStrategy closed-set typed enum onto the &'static str axis — routes byte-for-byte through the paired substrate-primitive RestartStrategy::as_str pub const fn accessor so every future consumer that binds a RestartStrategy through the standard-library .into() / [From<Self> for &'static str] (equivalently Into<&'static str>) axis (a future tracing::field::valuable::Value::Str(strategy.into()) structured-log recorder where the Str arm typing demands &'static str and the sibling AsRef<str> impl’s borrowed &str return-type does not satisfy the bound, a future Cow::Borrowed::<'static, str>(strategy.into()) composer on the future M4 admission-webhook rejection body where the Cow<'static, str> typing rules out the sibling AsRef<str> borrowed return, a generic <T: Into<&'static str>>-bound serializer on a per-strategy diagnostic column) reaches the same lifted crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_ONE_FOR_ALL / crate::render::SUPERVISOR_ESTRATEGIA_REST_FOR_ONE / crate::render::SUPERVISOR_ESTRATEGIA_SIMPLE_ONE_FOR_ONE const the paired std::fmt::Display, AsRef<str>, and RestartStrategy::as_str surfaces already return, rather than an open-coded per-arm match s { OneForOne => "OneForOne", … } cascade whose arm-set has no compile-time link back to the substrate primitive.

Complements the pre-existing quadruple (std::fmt::Display, AsRef<str>, RestartStrategy::as_str, TryFrom<&str> via 5b828ed) with the paired trait-idiomatic forward-projection axis: Rust-side newtype/typed-enum convention pairs TryFrom<&str> (trait-idiomatic reverse) with [From<Self> for &'static str] (trait-idiomatic forward) on the same primitive so a caller who can project in from a &str via the trait axis can also project out to one — mirroring the strum::IntoStaticStr / serde::Serialize-shape idiom where both projection halves share one trait-driven vocabulary. Before this lift the substrate carried a &str-returning AsRef<str> but not the paired &'static str- returning [From<Self> for &'static str] axis every downstream generic that specifically needs 'static byte-string bytes reaches for.

The paired RestartStrategy::as_str returns &'static str by construction (each match arm resolves to a [crate::render::SUPERVISOR_ESTRATEGIA_*] pub const &str with static lifetime), so the trait’s return-type promise is upheld structurally. Any future silent detour that routes the impl through a non-static projection (a per-arm inline String::from("OneForOne")-shaped re-inlining that would .leak()-cast for the 'static bound, a hypothetical rebrand of one arm’s [crate::render::SUPERVISOR_ESTRATEGIA_*] const to a non-const &str) is a caixa-core-build-time failure through the pub const fn as_str signature the trait routes through.

The paired impl reaches the same four-arm emit-set the RestartStrategy::as_str accessor dispatches through, so any future arm addition (an OTP-rest_for_all fifth arm the theory ABSORPTION-ROADMAP might reach for once the four canonical OTP strategies stop covering the substrate’s discovered load-shape) grows the trait-idiomatic forward axis by construction — one caixa-core edit on RestartStrategy::as_str extends every one of the five sibling forward-projection paths (std::fmt::Display, AsRef<str>, RestartStrategy::as_str itself, this [From<Self> for &'static str], and the un-renamed serde::Serialize derive that also emits [Self::as_str]’s bytes) without a coordinated rewrite across every future Into<&'static str>-bound consumer’s arm-set.

Opens the substrate-wide trait-idiomatic forward-projection family on closed-set fieldless typed enums — the mirror of the recently-closed trait-idiomatic reverse-projection family (crate::CaixaKind via 3c83606, crate::CaixaDialeto via bf33136, crate::aplicacao::PlacementStrategy via 6fd00cd, this enum via 5b828ed, crate::supervisor::RestartPolicy via 6fdd0d9, crate::aplicacao::WitShape via 5472902, crate::aplicacao::RateLimitUnit via bf78400, crate::render::PathShapeViolation via e67e48a, and the four downstream-crate peers — [caixa_arch::InvariantKind] via e21a857, [caixa_arch::ArchVerdict] via 0a4cc45, [caixa_lint::Severity] via a7bf74c, [caixa_lint::FixSafety] via df86c94, [caixa_theme::Semantic] via bd7da69, and [caixa_provedor::ferrite::FerriteRuntime] via 42ab951). This lift picks RestartStrategy as the first-mover on the forward-projection family because its wire byte-string (PascalCase) and diagnostic byte-string ([as_str] return) coincide by construction — the sibling crate::CaixaKind two-axis split (lowercase Portuguese diagnostic vs PascalCase wire) would leave a first-mover peer arbitrarily picking one axis; on RestartStrategy the choice is unambiguous.

Pinned load-bearing by [tests::restart_strategy_from_into_static_str_routes_through_as_str_accessor] (byte-parity pin against RestartStrategy::as_str across the four-arm emit-set, plus a const-context materialization witness for the &'static str lifetime promise) and [tests::restart_strategy_from_into_static_str_and_as_str_partition_the_emit_set] (partition pin asserting <&'static str as From<RestartStrategy>>::from and RestartStrategy::as_str agree on every arm, so no future silent bifurcation of the two forward-projection paths can land silently).

fn from(strategy: RestartStrategy) -> &'static str

Converts to this type from the input type.

impl FromStr for RestartStrategy

type Err = RestartStrategyParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for RestartStrategy

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RestartStrategy

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RestartStrategy

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 RestartStrategy

impl TryFrom<&str> for RestartStrategy

Trait-idiomatic reverse projection on the M2-OTP-shape sibling-restart RestartStrategy closed-set typed enum — routes byte-for-byte through the paired substrate-primitive RestartStrategy::from_wire Option<Self> accessor so every future consumer that binds a PascalCase :supervisor :estrategia wire byte-string through the standard-library .try_into() / TryFrom axis (a future [caixa-feira] feira supervisor --estrategia <OneForOne|OneForAll| RestForOne|SimpleOneForOne> CLI arg-parse that composes into let estrategia: RestartStrategy = s.try_into()?, a future mesh.pleme.io/v1alpha1/Supervisor CR admission-webhook that folds a spec.estrategia: String field through RestartStrategy::try_from(&s)?, a generic <T: TryFrom<&str>>-bound loader over any of the substrate’s closed- set typed enums) reaches the same four-arm accept-set the sibling RestartStrategy::from_wire resolver parses through and the sibling RestartStrategy::as_str emits, rather than an open-coded per-arm match s { "OneForOne" => …, "OneForAll" => …, "RestForOne" => …, "SimpleOneForOne" => …, _ => … } cascade whose arm-set has no compile-time link back to the substrate primitive.

Complements the pre-existing forward-projection triple (std::fmt::Display, AsRef<str>, RestartStrategy::as_str) with the paired trait-idiomatic reverse-projection axis: Rust-side newtype/typed-enum convention pairs AsRef<str> with either std::str::FromStr or TryFrom<&str> on the same primitive so a caller who can project out to a &str can also project in from one. The TryFrom<&str> axis is deliberately chosen over std::str::FromStr to sidestep the clippy::should_implement_trait lint the sibling method-named RestartStrategy::from_wire would trigger under a FromStr impl and to avoid colliding with the std::str::FromStr impl the gen_platform::FromStrKind derive already installs on the paired kebab-case dispatcher-catalog axis (which parses "one-for-one" / "one-for-all" / "rest-for-one" / "simple-one-for-one", the inverse of Self::discriminant) — this impl closes the trait-idiomatic reverse axis on the PascalCase wire half without disturbing either the method-named from_wire shape every sibling closed-set typed enum on the substrate already carries or the pre-existing FromStr on the dispatcher-catalog half, keeping the two-axis split the sibling Self::from_wire doc block motivates.

type Error = () matches the sibling RestartStrategy::from_wire’s Option<Self> return-shape’s deliberate deferral of error typing: the caller picks the diagnostic form appropriate for its use site (a future feira supervisor --estrategia arg-parse composes its own per-verb “unknown strategy: — accepted: {…}” message enumerating RestartStrategy::ALL, a future M4 admission-webhook rejection body wraps the Err(()) outcome with the accepted-set enumeration for operator diagnostics, a Result::map_err at the call site lifts the unit-error to a per-verb error type). Same shape the peer crate::CaixaKind (3c83606), crate::CaixaDialeto (bf33136), crate::aplicacao::PlacementStrategy (6fd00cd), and [crate::provedor::ferrite::FerriteRuntime::from_wire] blocks motivate on their peer closed-set typed enums’ reverse projections.

The paired TryFrom<&str> impl reaches the same four-arm accept-set the RestartStrategy::from_wire resolver dispatches through, so any future arm addition (an OTP-rest_for_all fifth arm the theory ABSORPTION-ROADMAP might reach for once the four canonical OTP strategies stop covering the substrate’s discovered load-shape) grows the trait-idiomatic axis by construction — one caixa-core edit on RestartStrategy::from_wire extends both the method-named reverse projection every existing consumer keys off and the trait-idiomatic reverse projection this impl exposes, without a coordinated rewrite across every future TryFrom<&str>-bound consumer’s arm-set.

Extends the substrate-wide closed-set-enum reverse-projection family (crate::CaixaKind via 3c83606, crate::CaixaDialeto via bf33136, crate::aplicacao::PlacementStrategy via 6fd00cd) onto the first M2-OTP-shape closed-set typed enum on the caixa surface — the :supervisor :estrategia closed set the future wasm-operator’s hierarchical reconciliation scheduler keys off end-to-end.

Pinned load-bearing by [tests::restart_strategy_try_from_str_routes_through_from_wire_accessor] (byte-parity pin against RestartStrategy::from_wire across the four-arm accept-set) and [tests::restart_strategy_try_from_str_rejects_unknown_byte_strings] (rejection witness against silent accept-set widening).

type Error = ()

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TypedDispatcher for RestartStrategy

fn variant_kinds() -> Vec<&'static str>

Kebab-case serde tags of every variant in declaration order. Used by substrate emitters (Nix helpers skeleton, Lisp catalog, coverage tests) to enumerate the variant universe.

fn variant_fields() -> Vec<(&'static str, Vec<&'static str>)>

Field names per variant, paired with the variant’s kebab-case tag. Used by substrate emitters to produce the matching inherit (variant) <fields> Nix patterns.

fn variant_count() -> usize

Total variant count. Convenience for coverage assertions.