Struct cursive::XY

source · 
pub struct XY<T> {
    pub x: T,
    pub y: T,
}
Expand description

A generic structure with a value for each axis.

Fields

x: T

X-axis value

y: T

Y-axis value

Implementations

Returns a position centered on both axis.

Returns a position absolute on both axis.

Returns a position relative to the parent on both axis.

Computes the offset required to draw a view.

When drawing a view with size in a container with available, and a parent with the absolute coordinates parent, drawing the child with its top-left corner at the returned coordinates will position him appropriately.

Returns a Vec2 with usize::max_value() in each axis.

Examples
assert!(Vec2::new(9999, 9999) < Vec2::max_value());

Saturating subtraction. Computes self - other, saturating at 0.

Never panics.

Examples
let u = Vec2::new(1, 2);
let v = Vec2::new(2, 1);
assert_eq!(u.saturating_sub(v), Vec2::new(0, 1));

Saturating addition with a signed vec.

Any coordinates saturates to 0.

Examples
let u = Vec2::new(1, 2);
let v = XY::<isize>::new(-2, 1);
assert_eq!(u.saturating_add(v), Vec2::new(0, 3));

Term-by-term integer division that rounds up.

Examples
let u = Vec2::new(1, 6);
let v = Vec2::new(2, 3);
assert_eq!(u.div_up(v), Vec2::new(1, 2));

Checked subtraction. Computes self - other if possible.

Returns None if self.x < other.x || self.y < other.y.

Never panics.

Examples
let xy = Vec2::new(1, 2);
assert_eq!(xy.checked_sub((1, 1)), Some(Vec2::new(0, 1)));
assert_eq!(xy.checked_sub((2, 2)), None);

Returns a XY<isize> from self.

Examples
let v: XY<isize> = Vec2::new(1, 2).signed().map(|i| i - 5);
assert_eq!(v, XY::new(-4, -3));

let u = Vec2::new(3, 4);
assert_eq!(u.saturating_add(v), Vec2::new(0, 1));

Returns true if self could fit inside other.

Shortcut for self.x <= other.x && self.y <= other.y.

If this returns true, then other - self will not underflow.

Examples
let v = Vec2::new(1, 2);
assert!(v.fits_in((1, 2)));
assert!(v.fits_in((3, 3)));
assert!(!v.fits_in((2, 1)));

Returns true if other could fit inside self.

Shortcut for self.x >= other.x && self.y >= other.y.

If this returns true, then self - other will not underflow.

Examples
let v = Vec2::new(1, 2);
assert!(v.fits((1, 2)));
assert!(v.fits((0, 0)));
assert!(!v.fits((2, 1)));

Returns a new Vec2 that is a maximum per coordinate.

Examples
assert_eq!(Vec2::max((1, 2), (3, 1)), Vec2::new(3, 2));

Returns a new Vec2 that is no larger than any input in both dimensions.

Examples
assert_eq!(Vec2::min((1, 2), (3, 1)), Vec2::new(1, 1));

Returns the minimum of self and other.

This is equivalent to Vec2::min(self, other).

Returns the maximum of self and other.

This is equivalent to Vec2::max(self, other).

Returns (max(self.x,other.x), self.y+other.y)

Returns (self.x+other.x, max(self.y,other.y))

Returns true if self fits in the given rectangle.

Returns a vector with the X component of self, and y=0.

Examples
let xy = XY::new(1, 2);
assert_eq!(xy.keep_x(), XY::new(1, 0));

Returns a vector with the Y component of self, and x=0.

Examples
let xy = XY::new(1, 2);
assert_eq!(xy.keep_y(), XY::new(0, 2));

Alias for Self::new(0,0).

Examples
assert_eq!(Vec2::zero(), Vec2::new(0, 0));

Creates a new XY from the given values.

Swaps the x and y values.

Examples
let xy = XY::new(1, 2);
assert_eq!(xy.swap(), XY::new(2, 1));

Returns f(self.x, self.y)

Examples
let xy = XY::new(1, 2);

assert_eq!(xy.fold(std::ops::Add::add), 3);
assert_eq!(xy.fold(std::ops::Mul::mul), 2);
assert_eq!(xy.fold(|x, y| x < y), true);

Creates a new XY by applying f to x and y.

Examples
let xy = XY::new(1, 2);

assert_eq!(xy.map(|v| v * 2), XY::new(2, 4));
assert_eq!(xy.map(|v| v > 1), XY::new(false, true));

Applies f on axis where condition is true.

Carries over self otherwise.

Examples
let xy = XY::new(1, 2);
let cond = XY::new(true, false);

assert_eq!(xy.map_if(cond, |v| v * 3), XY::new(3, 2));

Applies f on axis where condition is true.

Returns None otherwise.

Examples
let xy = XY::new(1, 2);
let cond = XY::new(true, false);

assert_eq!(xy.run_if(cond, |v| v * 3), XY::new(Some(3), None));

Creates a new XY by applying f to x, and carrying y over.

Examples
let xy = XY::new(1, 2);
assert_eq!(xy.map_x(|x| x * 10), XY::new(10, 2));

Creates a new XY by applying f to y, and carrying x over.

Examples
let xy = XY::new(1, 2);
assert_eq!(xy.map_y(|y| y * 10), XY::new(1, 20));

Destructure self into a pair.

Examples
let xy = XY::new(1, 2);
let (x, y) = xy.pair();
assert_eq!((x, y), (1, 2));

Return a XY with references to this one’s values.

Examples
fn longer(xy: &XY<String>, l: usize) -> XY<bool> {
    // `XY::map` takes ownership
    // So we need to get a XY<&String> from a &XY<String>
    let by_ref: XY<&String> = xy.as_ref();
    by_ref.map(|s| s.len() > l)
}

let xy = XY::new(String::from("a"), String::from("bbb"));

assert_eq!(longer(&xy, 2), XY::new(false, true));

Creates an iterator that returns references to x, then y.

Examples
let xy = XY::new(1, 2);
let vec: Vec<bool> = xy.iter().map(|&i| i > 1).collect();
assert_eq!(vec, vec![false, true]);

Returns a reference to the value on the given axis.

Examples
let xy = XY::new(1, 2);
assert_eq!(xy.get(Orientation::Horizontal), &1);
assert_eq!(xy.get(Orientation::Vertical), &2);

Returns a mutable reference to the value on the given axis.

Examples
let mut xy = XY::new(1, 2);
*xy.get_mut(Orientation::Horizontal) = 10;

assert_eq!(xy, XY::new(10, 2));

Returns a new XY of tuples made by zipping self and other.

Examples
let a = XY::new(1, 2);
let b = XY::new(true, false);
assert_eq!(a.zip(b), XY::new((1, true), (2, false)));

Returns a new XY of tuples made by zipping self, a and b.

Examples
let a = XY::new(1, 2);
let b = XY::new(true, false);
let c = XY::new("x", "y");
assert_eq!(a.zip3(b, c), XY::new((1, true, "x"), (2, false, "y")));

Returns a new XY of tuples made by zipping self, a, b and c.

Examples
let a = XY::new(1, 2);
let b = XY::new(true, false);
let c = XY::new("x", "y");
let d = XY::new(vec![1], vec![2, 3, 4]);
assert_eq!(
    XY::zip4(a, b, c, d),
    XY::new((1, true, "x", vec![1]), (2, false, "y", vec![2, 3, 4]))
);

Returns a new XY of tuples made by zipping self, a, b, c and d.

Examples
let a = XY::new(1, 2);
let b = XY::new(true, false);
let c = XY::new("x", "y");
let d = XY::new(vec![1], vec![2, 3, 4]);
let e = XY::new('a', 'b');

let xy: XY<Option<char>> = XY::zip5(a, b, c, d, e)
    .map(|(a, b, c, d, e)| {
        if b && d.contains(&a) {
            Some(e)
        } else {
            c.chars().next()
        }
    });
assert_eq!(xy, XY::new(Some('a'), Some('y')));

Returns a new XY by calling f on self and other for each axis.

Examples
let a = XY::new((1, 10), (2, 20));
let b = XY::new(true, false);
let xy = a.zip_map(b, |(a1, a2), b| if b { a1 } else { a2 });
assert_eq!(xy, XY::new(1, 20));

For each axis, keep the element from self if keep is true.

Examples
let xy = XY::new(1, 2);
let cond = XY::new(true, false);

assert_eq!(xy.keep(cond), XY::new(Some(1), None));

Returns a new XY with the axis o set to value.

Examples
let xy = XY::new(1, 2).with_axis(Orientation::Horizontal, 42);

assert_eq!(xy, XY::new(42, 2));

Returns a new XY with the axis o set to the value from other.

Examples
let other = XY::new(3, 4);
let xy = XY::new(1, 2).with_axis_from(Orientation::Horizontal, &other);

assert_eq!(xy, XY::new(3, 2));

Sets the axis o on self to the value from other.

Examples
let mut xy = XY::new(1, 2);
let other = XY::new(3, 4);
xy.set_axis_from(Orientation::Horizontal, &other);

assert_eq!(xy, XY::new(3, 2));

Creates a XY with both x and y set to value.

Examples
let xy = XY::both_from(42);

assert_eq!(xy, XY::new(42, 42));

Returns a new XY by calling unwrap_or on each axis.

Examples
let xy = XY::new(Some(1), None);
assert_eq!(xy.unwrap_or(XY::new(10, 20)), XY::new(1, 20));

Returns true if any of x or y is true.

Examples
assert_eq!(XY::new(true, false).any(), true);
assert_eq!(XY::new(false, false).any(), false);
assert_eq!(XY::new('a', 'b').map(|c| c == 'a').any(), true);

Returns true if both x and y are true.

Examples
assert_eq!(XY::new(true, false).both(), false);
assert_eq!(XY::new(true, true).both(), true);
assert_eq!(XY::new("abc", "de").map(|s| s.len() > 2).both(), false);

For each axis, keeps elements from other if self is true.

Examples
let choice = XY::new(true, false);
let values = XY::new(1, 2);
let selection = choice.select(values);

assert_eq!(selection, XY::new(Some(1), None));

For each axis, selects if_true if self is true, else if_false.

Examples
let choice = XY::new(true, false);
let values = XY::new(1, 2);
let fallback = XY::new(3, 4);
let selection = choice.select_or(values, fallback);

assert_eq!(selection, XY::new(1, 4));

Returns a term-by-term AND operation.

Examples
let a = XY::new(true, false);
let b = XY::new(true, true);
assert_eq!(a.and(b), XY::new(true, false));

Returns a term-by-term OR operation.

Examples
let a = XY::new(true, false);
let b = XY::new(true, true);
assert_eq!(a.or(b), XY::new(true, true));

Trait Implementations

Examples
let xy = XY::new(1, 2);
assert_eq!(xy + (2, 3), XY::new(3, 5));
The resulting type after applying the + operator.
Returns a copy of the value. Read more
Performs copy-assignment from source. Read more
Formats the value using the given formatter. Read more
Examples
let xy = XY::new(1, 4);
assert_eq!(xy / 2, XY::new(0, 2));
The resulting type after applying the / operator.
Examples
let u = XY::new(2, 3);
let v = XY::new(1, 2);
assert_eq!(u / v, XY::new(2, 1));
The resulting type after applying the / operator.

Clone a XY

Examples
let xy = XY::new(String::from("a"), String::from("ab"));
assert_eq!(XY::from(&xy), xy);

A pair is assumed to be (x, y)

Easily zip a pair of XY into a XY of pair

Examples
let xy: XY<isize> = XY::from((-1i32, -2i32));
assert_eq!(xy, XY::new(-1, -2));
Examples
let v = Vec2::from((1u16, 2u16));
assert_eq!(v, Vec2::new(1, 2));
Examples
let v = Vec2::from((1u32, 2u32));
assert_eq!(v, Vec2::new(1, 2));
Examples
let v = Vec2::from((1u8, 2u8));
assert_eq!(v, Vec2::new(1, 2));
Examples
let u = Vec2::new(1, 2);
let v: XY<isize> = XY::from(u);
assert_eq!(v, XY::new(1, 2));
Feeds this value into the given Hasher. Read more
Feeds a slice of this type into the given Hasher. Read more

Iterate over x, then y.

The type of the elements being iterated over.
Which kind of iterator are we turning this into?
Examples
let u = XY::new(1, 2);
let v = XY::new(2, 3);
assert_eq!(u * v, XY::new(2, 6));
The resulting type after applying the * operator.
Examples
let v = Vec2::new(1, 2);
assert_eq!(v * 2, Vec2::new(2, 4));
The resulting type after applying the * operator.
This method tests for self and other values to be equal, and is used by ==. Read more
This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more

a < b <=> a.x < b.x && a.y < b.y

This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Examples
let xy = XY::new(1, 2);
assert_eq!(xy - (1, 0), XY::new(0, 2));
The resulting type after applying the - operator.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.