Struct Limits 

pub struct Limits<U> {
    pub v: f32x4,
    /* private fields */
}

The Limits type represents both a minimum size and a maximum size for a given unit. Adding limits together actually merges them, by taking the largest minimum size and the smallest maximum size of either. You aren’t expected to construct this type manually, however - the Limits constructor takes a range parameter to make it easier to represent the minimum and maximum range of sizes you want.

Examples

use feather_ui::euclid::Size2D;
use feather_ui::{AbsLimits, RelLimits, Logical, Relative};

// Results in a minimum size of [-inf, 10.0] and a maximum size of [inf, 200.0]
let limits = AbsLimits::new(.., 10.0..200.0);
assert_eq!(limits.min(), Size2D::<f32, Logical>::new(f32::NEG_INFINITY, 10.0));
assert_eq!(limits.max(), Size2D::<f32, Logical>::new(f32::INFINITY, 200.0));

// Results in a minimum size of [-inf, -inf] and a maximum size of [1.0, inf]
let rlimits = RelLimits::new(..1.0, ..);
assert_eq!(rlimits.min(), Size2D::<f32, Relative>::new(f32::NEG_INFINITY, f32::NEG_INFINITY));
assert_eq!(rlimits.max(), Size2D::<f32, Relative>::new(1.0, f32::INFINITY));

// Result in a minimum size of [0.0, 10.0] and a maximum size of [inf, 100.0]
let merged = AbsLimits::new(0.0.., 5.0..100.0) + limits;
assert_eq!(merged.min(), Size2D::<f32, Logical>::new(0.0, 10.0));
assert_eq!(merged.max(), Size2D::<f32, Logical>::new(f32::INFINITY, 100.0));

Fields

v: f32x4

Implementations

impl<U> Limits<U>

pub fn new(x: impl RangeBounds<f32>, y: impl RangeBounds<f32>) -> Self

pub fn min(&self) -> Size2D<f32, U>

pub fn max(&self) -> Size2D<f32, U>

pub fn set_min(&mut self, bound: Size2D<f32, U>)

pub fn set_max(&mut self, bound: Size2D<f32, U>)

pub fn to_untyped(self) -> Limits<UnknownUnit>

Discard the units

pub fn cast_unit<V>(self) -> Limits<V>

Cast the unit

Trait Implementations

impl<U> Add for Limits<U>

type Output = Limits<U>

The resulting type after applying the + operator.

fn add(self, rhs: Limits<U>) -> Self::Output

Performs the + operation.

impl<U: Clone> Clone for Limits<U>

fn clone(&self) -> Limits<U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<U: Debug> Debug for Limits<U>

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

Formats the value using the given formatter.

impl<U> Default for Limits<U>

fn default() -> Self

Returns the “default value” for a type.

impl From<Limits<Logical>> for DLimits

fn from(value: AbsLimits) -> Self

Converts to this type from the input type.

impl From<Limits<Pixel>> for DLimits

fn from(value: PxLimits) -> Self

Converts to this type from the input type.

impl<U: PartialEq> PartialEq for Limits<U>

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

impl<U> StructuralPartialEq for Limits<U>