Enum Arch 

pub enum Arch<I = DefaultInterner>
where
    I: Interner,
{
    Known(KnownArch),
    Exotic(ExoticKey<I>),
}

A Gentoo architecture keyword.

Represents either a well-known Gentoo architecture or an overlay-specific keyword string. This type is used when parsing ebuild KEYWORDS or other architecture references that may include non-standard values.

Variants

• Known(KnownArch): A recognized Gentoo architecture. Zero-cost and Copy.
• Exotic(ExoticKey<I>): An overlay-defined keyword stored via interning.

Memory Efficiency

With the default interner feature, Arch<GlobalInterner> is Copy (4 bytes) and identical exotic strings share a single allocation. This is useful when processing large numbers of ebuilds.

Examples

use gentoo_core::Arch;

// Known architectures are recognized automatically
let known = Arch::intern("amd64");
assert_eq!(known.as_str(), "amd64");

// Unknown strings become exotic keys
let exotic = Arch::intern("my-custom-board");
assert_eq!(exotic.as_str(), "my-custom-board");

Variants

Known(KnownArch)

A well-known Gentoo architecture keyword.

Exotic(ExoticKey<I>)

An overlay-defined keyword string interned via I.

Implementations

impl<I: Interner> Arch<I>

pub fn intern(keyword: &str) -> Self

Intern keyword using the interner I.

pub fn current() -> Self

Current system architecture from std::env::consts::ARCH.

Returns Known for recognized architectures, Exotic otherwise.

pub fn from_chost(chost: &str) -> Option<Self>

Extract the CPU arch from a GNU CHOST triple using the interner I.

Returns None only when chost is empty.

pub fn as_str(&self) -> &str

Resolve to the Gentoo keyword string using the interner I.

pub fn as_keyword(&self) -> &str

The Gentoo keyword for this architecture.

For known architectures, returns the canonical keyword (e.g., "amd64"). For exotic architectures, returns the interned string directly.

Trait Implementations

impl<I: Interner> Clone for Arch<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 Arch<I>

where I: Interner + Debug,

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

type Err = Infallible

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> Hash for Arch<I>

where I: Interner + Hash,

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<I: Interner> PartialEq<&str> for Arch<I>

fn eq(&self, other: &&str) -> 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> PartialEq<String> for Arch<I>

fn eq(&self, other: &String) -> 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> PartialEq<str> for Arch<I>

fn eq(&self, other: &str) -> 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> PartialEq for Arch<I>

where I: Interner + PartialEq,

fn eq(&self, other: &Arch<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 Arch<I>

where Interned<I>: Copy,

impl<I> Eq for Arch<I>

where I: Interner + Eq,

impl<I> StructuralPartialEq for Arch<I>

where I: Interner,