Enum Region 

#[repr(u32)]
pub enum Region {
    P = 1,
    E = 2,
    J = 4,
    K = 8,
    W = 16,
    C = 32,
}

All unique regions of New Super Mario Bros. Wii, using the letter names from their game codes (SMNP01, SMNE01, etc.).

Variants

P = 1

International

E = 2

North America

J = 4

Japan

K = 8

Korea

W = 16

Taiwan

C = 32

China

Implementations

impl Region

pub const DEFAULT_ORDER: [Self; 6]

A list of all regions, in their “default” order. If conflicting copies of a region-specific file are found (and the configuration options request that files be overwritten instead of returning Err), smallworld will by default use the one corresponding to the region listed first here.

This is public because the default order in which files are prioritized is a documented guarantee. The array may change in the future, though, if new versions of NSMBW are ever released.

Trait Implementations

impl BitAnd for Region

type Output = BitFlags<Region>

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl BitFlag for Region

fn empty() -> BitFlags<Self>

Create a BitFlags with no flags set (in other words, with a value of 0).

fn all() -> BitFlags<Self>

Create a BitFlags with all flags set.

fn from_bits(bits: Self::Numeric) -> Result<BitFlags<Self>, FromBitsError<Self>>

Create a BitFlags if the raw value provided does not contain any illegal flags.

fn from_bits_truncate(bits: Self::Numeric) -> BitFlags<Self>

Create a BitFlags from an underlying bitwise value. If any invalid bits are set, ignore them.

unsafe fn from_bits_unchecked(bits: Self::Numeric) -> BitFlags<Self>

Create a BitFlags unsafely, without checking if the bits form a valid bit pattern for the type.

impl BitOr for Region

type Output = BitFlags<Region>

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl BitXor for Region

type Output = BitFlags<Region>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self::Output

Performs the ^ operation.

impl Clone for Region

fn clone(&self) -> Region

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Region

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

Formats the value using the given formatter.

impl From<&Region> for &str

fn from(value: &Region) -> Self

Converts to this type from the input type.

impl From<&Region> for RegionBitFlags

fn from(region: &Region) -> RegionBitFlags

Converts to this type from the input type.

impl From<Region> for &str

fn from(value: Region) -> Self

Converts to this type from the input type.

impl FromStr for Region

type Err = ParseRegionError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, ParseRegionError>

Parses a string s to return a value of this type.

impl Hash for Region

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 Not for Region

type Output = BitFlags<Region>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Region

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

const EMPTY: <Self as RawBitFlags>::Numeric = {transmute(0x00000000): <Region as enumflags2::_internal::RawBitFlags>::Numeric}

A value with no bits set.

const DEFAULT: <Self as RawBitFlags>::Numeric = {transmute(0x00000000): <Region as enumflags2::_internal::RawBitFlags>::Numeric}

The value used by the Default implementation. Equivalent to EMPTY, unless customized.

const ALL_BITS: <Self as RawBitFlags>::Numeric = {transmute(0x0000003f): <Region as enumflags2::_internal::RawBitFlags>::Numeric}

A value with all flag bits set.

const BITFLAGS_TYPE_NAME: &'static str = "BitFlags<Region>"

The name of the type for debug formatting purposes.

type Numeric = u32

The underlying integer type.

fn bits(self) -> <Self as RawBitFlags>::Numeric

Return the bits as a number type.

impl Copy for Region

impl Eq for Region

impl StructuralPartialEq for Region