Enum OsType 

#[non_exhaustive]
pub enum OsType {
    LINUX,
    MACOS,
    WINDOWS,
    FREEBSD,
    OPENBSD,
    NETBSD,
    DRAGONFLY,
    SOLARIS,
    ILLUMOS,
    ANDROID,
    IOS,
    REDOX,
    FUCHSIA,
    HERMIT,
    VXWORKS,
    AIX,
    HAIKU,
}

Available on crate feature sys only.

Operating system type.

This enum provides type-safe operating system identifiers. All variants are validated at construction time.

Invariants

• All variants represent valid operating systems
• OS type is determined at compile time for current() method

Examples

use bare_types::sys::OsType;

// Use predefined constants
let os = OsType::LINUX;
assert!(os.is_unix());

// Get current OS
let current = OsType::current();
println!("Running on: {}", current);

// Convert to string representation
assert_eq!(OsType::LINUX.as_str(), "linux");

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.

LINUX

GNU/Linux distributions

MACOS

macOS (formerly OS X)

WINDOWS

Microsoft Windows

FREEBSD

FreeBSD operating system

OPENBSD

OpenBSD operating system

NETBSD

NetBSD operating system

DRAGONFLY

DragonFly BSD

SOLARIS

Oracle Solaris

ILLUMOS

Illumos-based systems (OpenIndiana, SmartOS, etc.)

ANDROID

Android mobile OS

IOS

Apple iOS

REDOX

Redox OS (Rust-based microkernel)

FUCHSIA

Google Fuchsia

HERMIT

HermitCore unikernel

VXWORKS

Wind River VxWorks

AIX

IBM AIX

HAIKU

Haiku OS (BeOS-inspired)

Implementations

impl OsType

pub const fn current() -> Self

Returns the current operating system (compile-time constant).

This method returns the operating system the code was compiled for, not necessarily the OS of the host system (especially relevant for cross-compilation).

Examples

use bare_types::sys::OsType;

let os = OsType::current();
println!("Compiled for: {}", os);

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

Returns the string representation of this OS.

Examples

use bare_types::sys::OsType;

assert_eq!(OsType::LINUX.as_str(), "linux");
assert_eq!(OsType::MACOS.as_str(), "macos");
assert_eq!(OsType::WINDOWS.as_str(), "windows");

pub const fn is_unix(&self) -> bool

Returns true if this is a Unix-like operating system.

Examples

use bare_types::sys::OsType;

assert!(OsType::LINUX.is_unix());
assert!(OsType::MACOS.is_unix());
assert!(OsType::FREEBSD.is_unix());
assert!(!OsType::WINDOWS.is_unix());

pub const fn is_bsd(&self) -> bool

Returns true if this is a BSD operating system.

Examples

use bare_types::sys::OsType;

assert!(OsType::FREEBSD.is_bsd());
assert!(OsType::OPENBSD.is_bsd());
assert!(OsType::NETBSD.is_bsd());
assert!(OsType::DRAGONFLY.is_bsd());
assert!(OsType::MACOS.is_bsd());
assert!(!OsType::LINUX.is_bsd());
assert!(!OsType::WINDOWS.is_bsd());

pub const fn is_windows(&self) -> bool

Returns true if this is Microsoft Windows.

Examples

use bare_types::sys::OsType;

assert!(OsType::WINDOWS.is_windows());
assert!(!OsType::LINUX.is_windows());
assert!(!OsType::MACOS.is_windows());

pub const fn is_mobile(&self) -> bool

Returns true if this is a mobile operating system.

Examples

use bare_types::sys::OsType;

assert!(OsType::ANDROID.is_mobile());
assert!(OsType::IOS.is_mobile());
assert!(!OsType::LINUX.is_mobile());
assert!(!OsType::WINDOWS.is_mobile());

pub const fn is_desktop(&self) -> bool

Returns true if this is a desktop operating system.

Examples

use bare_types::sys::OsType;

assert!(OsType::LINUX.is_desktop());
assert!(OsType::MACOS.is_desktop());
assert!(OsType::WINDOWS.is_desktop());
assert!(!OsType::ANDROID.is_desktop());
assert!(!OsType::IOS.is_desktop());

pub const fn is_embedded(&self) -> bool

Returns true if this is an embedded/real-time operating system.

Examples

use bare_types::sys::OsType;

assert!(OsType::VXWORKS.is_embedded());
assert!(!OsType::LINUX.is_embedded());

pub const fn is_microkernel(&self) -> bool

Returns true if this is a microkernel-based operating system.

Examples

use bare_types::sys::OsType;

assert!(OsType::REDOX.is_microkernel());
assert!(OsType::FUCHSIA.is_microkernel());
assert!(!OsType::LINUX.is_microkernel());

pub const fn is_posix(&self) -> bool

Returns true if this OS supports POSIX APIs.

Examples

use bare_types::sys::OsType;

assert!(OsType::LINUX.is_posix());
assert!(OsType::MACOS.is_posix());
assert!(!OsType::WINDOWS.is_posix());

pub const fn is_tier1(&self) -> bool

Returns true if this is a tier 1 supported Rust target.

Tier 1 targets are guaranteed to work with Rust.

Examples

use bare_types::sys::OsType;

assert!(OsType::LINUX.is_tier1());
assert!(OsType::MACOS.is_tier1());
assert!(OsType::WINDOWS.is_tier1());
// Tier 2/3 targets return false
// assert!(!OsType::FREEBSD.is_tier1());

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

Returns the family of this OS as a string.

Examples

use bare_types::sys::OsType;

assert_eq!(OsType::LINUX.family(), "unix");
assert_eq!(OsType::MACOS.family(), "unix");
assert_eq!(OsType::WINDOWS.family(), "windows");

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for OsType

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for OsType

fn clone(&self) -> OsType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OsType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OsType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OsType

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

Formats the value using the given formatter.

impl FromStr for OsType

type Err = OsTypeError

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 OsType

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 Ord for OsType

fn cmp(&self, other: &OsType) -> 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 PartialEq for OsType

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

fn partial_cmp(&self, other: &OsType) -> 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 Serialize for OsType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for OsType

type Error = OsTypeError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for OsType

impl Eq for OsType

impl StructuralPartialEq for OsType