Struct Line 

#[repr(C)]
pub struct Line<T> {
    pub start: T,
    pub end: T,
}

Expresses a linear set by its starting and termination points

This type is fully isomorphic with core::ops::Range and Span. However, unlike core::ops::Range, this type is not an iterator and therefore can implement Copy. Points may have any number of dimensions.

Fields

start: T

The start point

end: T

The first point excluded by the set

Implementations

impl<T> Line<T>

pub const fn new(start: T, end: T) -> Self

Create a new line

Example

let line = lset::Line::new(5, 10);
assert_eq!(line.start, 5);
assert_eq!(line.end, 10);

pub fn is_empty(&self) -> bool

where T: PartialEq,

Indicates whether the line is empty

Example

use lset::*;
assert!(Line::from(2..2).is_empty());
assert!(!Line::from(2..3).is_empty());

impl<T: PartialOrd> Line<T>

pub fn intersection(self, other: Self) -> Option<Self>

Returns the intersection between the sets, if any.

use lset::*;

let a = Line::new(0, 5);
let b = Line::new(2, 7);
let c = Line::new(5, 10);

assert_eq!(a.intersection(b), Some(Line::new(2, 5)));
assert_eq!(b.intersection(c), Some(Line::new(5, 7)));
assert_eq!(a.intersection(a), Some(a));
assert_eq!(b.intersection(b), Some(b));
assert_eq!(c.intersection(c), Some(c));
assert_eq!(a.intersection(c), None);

Trait Implementations

impl<T: Add<T, Output = T>> Add<T> for Line<T>

fn add(self, rhs: T) -> Self::Output

Grows the line by the size of the operand

Example

let before = lset::Line::new(5, 10);
let after = before + 5;
assert_eq!(after.start, 5);
assert_eq!(after.end, 15);

type Output = Line<T>

The resulting type after applying the + operator.

impl<T: AddAssign<T>> AddAssign<T> for Line<T>

fn add_assign(&mut self, rhs: T)

Grows the line by the size of the operand

Example

let mut line = lset::Line::new(5, 10);
line += 5;
assert_eq!(line.start, 5);
assert_eq!(line.end, 15);

impl<T: Clone> Clone for Line<T>

fn clone(&self) -> Line<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: PartialOrd> Contains<Line<T>> for Line<T>

fn contains(&self, value: &Self) -> bool

Indicates whether the line contains another line

Example

use lset::*;
assert!(Line::from(4..8).contains(&Line::from(5..7)));
assert!(Line::from(4..8).contains(&Line::from(4..7)));
assert!(Line::from(4..8).contains(&Line::from(5..8)));
assert!(Line::from(4..8).contains(&Line::from(4..8)));
assert!(!Line::from(4..8).contains(&Line::from(3..8)));
assert!(!Line::from(4..8).contains(&Line::from(4..9)));
assert!(!Line::from(4..8).contains(&Line::from(3..9)));
assert!(!Line::from(4..8).contains(&Line::from(2..10)));
assert!(!Line::from(4..8).contains(&Line::from(6..5)));
assert!(!Line::from(7..3).contains(&Line::from(5..6)));

impl<T: PartialOrd> Contains<T> for Line<T>

fn contains(&self, value: &T) -> bool

Indicates whether the line contains a point

Example

use lset::*;
assert!(!Line::from(2..3).contains(&1));
assert!(Line::from(2..3).contains(&2));
assert!(!Line::from(2..3).contains(&3));
assert!(!Line::from(3..2).contains(&1));
assert!(!Line::from(3..2).contains(&2));
assert!(!Line::from(3..2).contains(&3));

impl<T: Debug> Debug for Line<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Line<T>

fn default() -> Line<T>

Returns the “default value” for a type.

impl<T> From<Line<T>> for Range<T>

fn from(value: Line<T>) -> Self

Converts a Line into a Range

Example

use lset::*;
assert_eq!(5..10, std::ops::Range::from(Line::new(5, 10)));
assert_eq!(5..10, Line::new(5, 10).into());

impl<T: Clone + Sub<T, Output = U>, U> From<Line<T>> for Span<T, U>

fn from(value: Line<T>) -> Self

Converts a Line into a Span

Example

use lset::*;
assert_eq!(Span::new(5, 10), Span::from(Line::new(5, 15)));
assert_eq!(Span::new(5, 10), (Line::new(5, 15)).into());

impl<T> From<Range<T>> for Line<T>

fn from(value: Range<T>) -> Self

Converts a Range into a Line

Example

use lset::*;
assert_eq!(Line::new(5, 10), Line::from(5..10));
assert_eq!(Line::new(5, 10), (5..10).into());

impl<T: Clone + Add<U, Output = T>, U> From<Span<T, U>> for Line<T>

fn from(value: Span<T, U>) -> Self

Converts a Span into a Line

Example

use lset::*;
assert_eq!(Line::new(5, 10), Line::from(Span::new(5, 5)));
assert_eq!(Line::new(5, 10), Span::new(5, 5).into());

impl<T: PartialEq> PartialEq for Line<T>

fn eq(&self, other: &Line<T>) -> 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<T: PartialOrd> PartialOrd for Line<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Compares two Line types.

Example

use lset::*;
assert!(Line::new(5, 10) <= Line::new(5, 10));
assert!(Line::new(5, 10) >= Line::new(5, 10));
assert!(Line::new(5, 10) < Line::new(10, 15));
assert!(Line::new(10, 15) > Line::new(5, 10));

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy + Sub<T, Output = T>> Shl<T> for Line<T>

fn shl(self, rhs: T) -> Self::Output

Shifts the line downwards without changing size

Example

let before = lset::Line::new(5, 10);
let after = before << 5;
assert_eq!(after.start, 0);
assert_eq!(after.end, 5);

type Output = Line<T>

The resulting type after applying the << operator.

impl<T: Copy + SubAssign<T>> ShlAssign<T> for Line<T>

fn shl_assign(&mut self, rhs: T)

Shifts the line downwards without changing size

Example

let mut line = lset::Line::new(5, 10);
line <<= 5;
assert_eq!(line.start, 0);
assert_eq!(line.end, 5);

impl<T: Copy + Add<T, Output = T>> Shr<T> for Line<T>

fn shr(self, rhs: T) -> Self::Output

Shifts the line upwards without changing size

Example

let before = lset::Line::new(5, 10);
let after = before >> 5;
assert_eq!(after.start, 10);
assert_eq!(after.end, 15);

type Output = Line<T>

The resulting type after applying the >> operator.

impl<T: Copy + AddAssign<T>> ShrAssign<T> for Line<T>

fn shr_assign(&mut self, rhs: T)

Shifts the line upwards without changing size

Example

let mut line = lset::Line::new(5, 10);
line >>= 5;
assert_eq!(line.start, 10);
assert_eq!(line.end, 15);

impl<T: PartialOrd> Split<Line<T>> for Line<T>

fn split(self, at: Self) -> Option<(Self, Self)>

Splits a line by another line

Example

use lset::*;
let line = Line::from(2..5);
assert_eq!(line.split(Line::from(1..4)), None);
assert_eq!(line.split(Line::from(3..6)), None);
assert_eq!(line.split(Line::from(2..2)), None);
assert_eq!(line.split(Line::from(2..3)), Some((Line::from(2..2), Line::from(3..5))));
assert_eq!(line.split(Line::from(3..3)), None);
assert_eq!(line.split(Line::from(3..4)), Some((Line::from(2..3), Line::from(4..5))));
assert_eq!(line.split(Line::from(4..4)), None);
assert_eq!(line.split(Line::from(4..5)), Some((Line::from(2..4), Line::from(5..5))));
assert_eq!(line.split(Line::from(5..5)), None);
assert_eq!(line.split(line), Some((Line::from(2..2), Line::from(5..5))));

impl<T: PartialOrd + Copy> Split<T> for Line<T>

fn split(self, at: T) -> Option<(Self, Self)>

Splits a line at a point

Example

use lset::*;
let line = Line::from(2..4);
assert_eq!(line.split(1), None);
assert_eq!(line.split(2), Some((Line::from(2..2), line)));
assert_eq!(line.split(3), Some((Line::from(2..3), Line::from(3..4))));
assert_eq!(line.split(4), Some((line, Line::from(4..4))));
assert_eq!(line.split(5), None);

impl<T: Sub<T, Output = T>> Sub<T> for Line<T>

fn sub(self, rhs: T) -> Self::Output

Shrinks the line by the size of the operand

Example

let before = lset::Line::new(5, 10);
let after = before - 5;
assert_eq!(after.start, 5);
assert_eq!(after.end, 5);

type Output = Line<T>

The resulting type after applying the - operator.

impl<T: SubAssign<T>> SubAssign<T> for Line<T>

fn sub_assign(&mut self, rhs: T)

Shrinks the line by the size of the operand

Example

let mut line = lset::Line::new(5, 10);
line -= 5;
assert_eq!(line.start, 5);
assert_eq!(line.end, 5);

impl<T: Copy> Copy for Line<T>

impl<T: Eq> Eq for Line<T>

impl<T> StructuralPartialEq for Line<T>