Enum Os

#[non_exhaustive]
pub enum Os<'a> {
    Aix,
    Amdhsa,
    Android,
    Cuda,
    Cygwin,
    Dragonfly,
    Emscripten,
    Espidf,
    FreeBSD,
    Fuchsia,
    Haiku,
    Hermit,
    Horizon,
    Hurd,
    IllumOS,
    iOS,
    L4re,
    Linux,
    Lynxos178,
    MacOS,
    NetBSD,
    None,
    Nto,
    Nuttx,
    OpenBSD,
    Psp,
    Psx,
    Redox,
    Rtems,
    Solaris,
    SolidAsp3,
    TeeOS,
    Trusty,
    TvOS,
    Uefi,
    Unknown,
    VisionOS,
    Vita,
    VxWorks,
    Wasi,
    WatchOS,
    Windows,
    Xous,
    Zkvm,
    Other(Cow<'a, str>),
}

Operating system of the target.

Note

This value is closely related to the second and third element of the platform target triple, though it is not identical.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Aix

IBM AIX operating system aix

Amdhsa

AMD HSA architecture amdhsa

Android

Google’s Android mobile operating system android

Cuda

CUDA parallel computing platform cuda

Cygwin

POSIX layer for Windows cygwin

Dragonfly

DragonflyBSD dragonfly

Emscripten

The emscripten JavaScript transpiler emscripten

Espidf

Espressif IoT framework espidf

FreeBSD

The FreeBSD operating system freebsd

Fuchsia

Google’s next-gen Rust OS fuchsia

Haiku

Haiku, an open source BeOS clone haiku

Hermit

Unikernel targeting HPC and cloud environments hermit

Horizon

horizon

Hurd

hurd

IllumOS

illumos is a partly free and open-source Unix OS based on OpenSolaris illumos

iOS

Apple’s iOS mobile operating system ios

L4re

Microkernel OS framework l4re

Linux

Linux linux

Lynxos178

Real-time OS lynxos178

MacOS

Apple’s Mac OS X macos

NetBSD

The NetBSD operating system netbsd

None

none

Nto

QNX Neutrino OS nto

Nuttx

Embedded real-time OS nuttx

OpenBSD

The OpenBSD operating system openbsd

Psp

PlayStation Portable OS psp

Psx

PlayStation OS psx

Redox

Redox, a Unix-like OS written in Rust redox

Rtems

Real-time executive OS rtems

Solaris

Oracle’s (formerly Sun) Solaris operating system solaris

SolidAsp3

solid_asp3

TeeOS

Trusted Execution Environment OS teeos

Trusty

Android trusted environment trusty

TvOS

Apple TV OS tvos

Uefi

Firmware interface uefi

Unknown

unknown

VisionOS

Apple spatial OS visionos

Vita

PlayStation Vita OS vita

VxWorks

VVxWorks is a deterministic, priority-based preemptive RTOS with low latency and minimal jitter vxworks

Wasi

The WebAssembly System Interface wasi

WatchOS

Apple Watch OS watchos

Windows

Microsoft’s Windows operating system windows

Xous

Privacy-focused microkernel OS xous

Zkvm

Zero-knowledge proof VM zkvm

Other(Cow<'a, str>)

Unknown value

Implementations

impl<'a> Os<'a>

pub fn as_str(&self) -> &str

String representing this target OS which matches #[cfg(target_os)]

pub fn from_str(name: impl Into<Cow<'a, str>>) -> Self

Tries to parse the given string as an Os falling back to Os::Other for unknown values

impl Os<'_>

pub fn target() -> Result<Self, VarError>

Gets the current target Os.

Trait Implementations

impl<'a> Clone for Os<'a>

fn clone(&self) -> Os<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Os<'a>

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

Formats the value using the given formatter.

impl Display for Os<'_>

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

Formats the value using the given formatter.

impl<'a> Hash for Os<'a>

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<'a> Ord for Os<'a>

fn cmp(&self, other: &Os<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Os<'a>

fn eq(&self, other: &Os<'a>) -> 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<'a> PartialOrd for Os<'a>

fn partial_cmp(&self, other: &Os<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for Os<'a>

impl<'a> StructuralPartialEq for Os<'a>