Enum Platform

pub enum Platform {
    Win64,
    Win32,
    Nix64,
    Nix32,
    Mac64,
    Mac32,
    None,
}

Platform struct, designed to completely describe the current platform or other possible platforms.

Variants

Win64

Win32

Nix64

Nix32

Mac64

Mac32

None

Implementations

impl Platform

pub fn new(platform: &str) -> Platform

Creates a new platform from a string.

Works through a number of different possibilities to make sure the correct platform is matched based on the string entered.

Supports exact matches to the enums as_str and as_short_str as well as pattern matching with keywords such as:

• 64,32
• win,nix,linux,mac
• lxx,wxx,mxx (for short codes)

pub fn clone(&self) -> Platform

Creates a copy of the enum object.

pub fn display(&self) -> &'static str

Displays the platform object using as_str

pub fn to_string(&self) -> String

returns a String object with the &str value of the platform

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

Returns a &str constant value for each type.

• Win64 === ‘Windows x86_64’
• Win32 === ‘Windows x32’
• Nix64 === ‘Linux x86_64’
• Nix32 === ‘Linux x32’
• Mac64 === ‘Mac OS x86_64’
• Mac32 === ‘Mac OS x32’
• None === ‘None’

pub fn to_short_string(&self) -> String

returns a String object with the short &str value of the platform

pub fn as_short_str(&self) -> &'static str

Returns a short &str constant value

• Win64 === ‘win64’
• Win32 === ‘win32’
• Nix64 === ‘nix64’
• Nix32 === ‘nix32’
• Mac64 === ‘mac64’
• Mac32 === ‘mac32’
• None === ‘None’

pub fn is_valid_execution_platform(&self) -> bool

Checks if a a binary were built for the self platform could be executed on the current user platform.

Assumes that 32 bit applications can be executed on 64 bit platforms. If you don’t want to assume this then don’t use this funtion and instead check absolute equality (==).

pub fn is_compatible(&self, other: &Platform) -> bool

Checks if this platform is compatible with the other platform,

Works on the assumption that 32 bit is compatible with 64 bit.

pub fn get_user_platform() -> Platform

Returns the current user platform

pub fn get_valid_execution_platform() -> Vec<Platform>

Returns a Vec of all the available execution platforms

Typically its a vector of 1, but also returns the 32bit version on 64bit systems.

pub fn iterator() -> Iter<'static, Platform>

An iterator that iterates through all the defined platforms

Trait Implementations

impl Debug for Platform

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Platform

fn deserialize<D>(deserializer: D) -> Result<Platform, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Platform

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

Formats the value using the given formatter.

impl Hash for Platform

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<Architecture> for Platform

fn eq(&self, other: &Architecture) -> 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 PartialEq<PartialPlatform> for Platform

fn eq(&self, other: &PartialPlatform) -> 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 PartialEq<Platform> for Architecture

fn eq(&self, other: &Platform) -> 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 PartialEq<Platform> for PartialPlatform

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

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Platform

impl StructuralPartialEq for Platform