Struct Variant 

pub struct Variant<I = DefaultInterner>
where
    I: Interner,
{
    pub arch: Arch<I>,
    /* private fields */
}

A Gentoo release media variant.

Represents the {arch}-{tag} format used for stage3 tarballs, ISO images, and profile selections. The tag encodes the init system and profile variant (e.g., "openrc", "systemd", "musl-hardened-openrc").

Memory Efficiency

With the default interner feature, Variant<GlobalInterner> is Copy (8 bytes) and identical strings share a single allocation. This is useful when processing many variant references.

Examples

use gentoo_core::{Variant, Arch, KnownArch};

let variant: Variant = "arm64-openrc".parse().unwrap();
assert!(matches!(variant.arch, Arch::Known(KnownArch::AArch64)));
assert_eq!(variant.flavor(), "openrc");

Fields

arch: Arch<I>

Variant architecture.

Implementations

impl<I: Interner> Variant<I>

pub fn parse(arch: &str, flavor: &str) -> Result<Self, Error>

Parse arch + flavor strings using the interner I.

pub fn flavor(&self) -> &str

Resolve the flavor string using the interner I.

pub fn keyword(&self) -> &str

The Gentoo keyword for this variant’s architecture.

Trait Implementations

impl<I: Interner> Clone for Variant<I>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Debug for Variant<I>

where I: Interner + Debug,

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

Formats the value using the given formatter.

impl<I: Interner> Display for Variant<I>

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

Formats the value using the given formatter.

impl<I: Interner> FromStr for Variant<I>

type Err = Error

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<I> PartialEq for Variant<I>

where I: Interner + PartialEq,

fn eq(&self, other: &Variant<I>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: Interner> Copy for Variant<I>

where Interned<I>: Copy,

impl<I> Eq for Variant<I>

where I: Interner + Eq,

impl<I> StructuralPartialEq for Variant<I>

where I: Interner,