Struct WrappingRange

pub struct WrappingRange {
    pub start: u128,
    pub end: u128,
}

Inclusive wrap-around range of valid values, that is, if start > end, it represents start..=MAX, followed by 0..=end.

That is, for an i8 primitive, a range of 254..=2 means following sequence:

254 (-2), 255 (-1), 0, 1, 2

This is intended specifically to mirror LLVM’s !range metadata semantics.

Fields

start: u128

end: u128

Implementations

impl WrappingRange

pub fn full(size: Size) -> Self

pub fn contains(&self, v: u128) -> bool

Returns true if v is contained in the range.

pub fn contains_range(&self, other: Self, size: Size) -> bool

Returns true if all the values in other are contained in this range, when the values are considered as having width size.

pub(crate) fn with_start(self, start: u128) -> Self

Returns self with replaced start

pub(crate) fn with_end(self, end: u128) -> Self

Returns self with replaced end

pub(crate) fn is_full_for(&self, size: Size) -> bool

Returns true if size completely fills the range.

Note that this is not the same as self == WrappingRange::full(size). Niche calculations can produce full ranges which are not the canonical one; for example Option<NonZero<u16>> gets valid_range: (..=0) | (1..).

pub fn no_unsigned_wraparound(&self, size: Size) -> Result<bool, RangeFull>

Checks whether this range is considered non-wrapping when the values are interpreted as unsigned numbers of width size.

Returns Ok(true) if there’s no wrap-around, Ok(false) if there is, and Err(..) if the range is full so it depends how you think about it.

pub fn no_signed_wraparound(&self, size: Size) -> Result<bool, RangeFull>

Checks whether this range is considered non-wrapping when the values are interpreted as signed numbers of width size.

This is heavily dependent on the size, as 100..=200 does wrap when interpreted as i8, but doesn’t when interpreted as i16.

Returns Ok(true) if there’s no wrap-around, Ok(false) if there is, and Err(..) if the range is full so it depends how you think about it.

Trait Implementations

impl Clone for WrappingRange

fn clone(&self) -> WrappingRange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WrappingRange

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

Formats the value using the given formatter.

impl Hash for WrappingRange

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<__CTX> HashStable<__CTX> for WrappingRange

where __CTX: HashStableContext,

fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)

impl PartialEq for WrappingRange

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

impl Eq for WrappingRange

impl StructuralPartialEq for WrappingRange

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes