Struct Span 

#[repr(C)]
pub struct Span<T, U = T> {
    pub start: T,
    pub count: U,
}

Expresses a linear set by its start element and number of elements.

This type is fully isomorphic with core::ops::Range and Line. However, unlike core::ops::Range, this type is not an iterator and therefore can implement Copy.

Fields

start: T

The start element

count: U

The number of elments

Implementations

impl<T, U> Span<T, U>

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

Create a new span

Example

let span = lset::Span::new(5, 10);
assert_eq!(span.start, 5);
assert_eq!(span.count, 10);

pub fn is_empty(&self) -> bool

where T: Copy + PartialEq + Add<U, Output = T>, U: Copy,

Indicates whether the span is empty

Example

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

impl<T, U> Span<T, U>

where Span<T, U>: Into<Line<T>> + From<Line<T>>, T: PartialOrd,

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

Returns the intersection between the sets, if any.

use lset::*;

let a = Span::new(0, 5);
let b = Span::new(2, 5);
let c = Span::new(5, 5);

assert_eq!(a.intersection(b), Some(Span::new(2, 3)));
assert_eq!(b.intersection(c), Some(Span::new(5, 2)));
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 Span<T>

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

Grows the line by the size of the operand

Example

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

type Output = Span<T>

The resulting type after applying the + operator.

impl<T: AddAssign<T>> AddAssign<T> for Span<T>

fn add_assign(&mut self, rhs: T)

Grows the line by the size of the operand

Example

let mut span = lset::Span::new(5, 10);
span += 5;
assert_eq!(span.start, 5);
assert_eq!(span.count, 15);

impl<T: Clone, U: Clone> Clone for Span<T, U>

fn clone(&self) -> Span<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, U> Contains<Span<T, U>> for Span<T, U>

where Self: Into<Line<T>> + Clone, T: PartialOrd,

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

Indicates whether the span contains another span

Example

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

impl<T, U> Contains<T> for Span<T, U>

where Self: Into<Line<T>> + Clone, Line<T>: Contains<T>,

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

Indicates whether the span contains a point

Example

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

impl<T: Debug, U: Debug> Debug for Span<T, U>

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

Formats the value using the given formatter.

impl<T: Default, U: Default> Default for Span<T, U>

fn default() -> Span<T, U>

Returns the “default value” for a type.

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: Copy + Sub<T, Output = U>, U> From<Range<T>> for Span<T, U>

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

Converts a Range into a Span

Example

use lset::*;
assert_eq!(Span::new(5, 10), Span::from(5..15));
assert_eq!(Span::new(5, 10), (5..15).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: Clone + Add<U, Output = T>, U> From<Span<T, U>> for Range<T>

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

Converts a Span into a Range

Example

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

impl<T: PartialEq, U: PartialEq> PartialEq for Span<T, U>

fn eq(&self, other: &Span<T, 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<T: PartialEq, U: PartialEq> PartialOrd for Span<T, U>

where Span<T, U>: Copy + Into<Line<T>>, Line<T>: PartialOrd,

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

Compares two Span types.

Example

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

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 Span<T>

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

Shifts the line downwards without changing size

Example

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

type Output = Span<T>

The resulting type after applying the << operator.

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

fn shl_assign(&mut self, rhs: T)

Shifts the line downwards without changing size

Example

let mut span = lset::Span::new(5, 10);
span <<= 5;
assert_eq!(span.start, 0);
assert_eq!(span.count, 10);

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

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

Shifts the line upwards without changing size

Example

let before = lset::Span::new(5, 10);
let after = before >> 5;
assert_eq!(after.start, 10);
assert_eq!(after.count, 10);

type Output = Span<T>

The resulting type after applying the >> operator.

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

fn shr_assign(&mut self, rhs: T)

Shifts the line upwards without changing size

Example

let mut span = lset::Span::new(5, 10);
span >>= 5;
assert_eq!(span.start, 10);
assert_eq!(span.count, 10);

impl<T, U> Split<Span<T, U>> for Span<T, U>

where Self: Into<Line<T>>, Line<T>: Into<Self> + Split<Line<T>>,

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

Splits a span by another span

Example

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

impl<T, U> Split<U> for Span<T, U>

where T: Add<U, Output = T> + Clone, Line<T>: Split<T> + Into<Self>, Self: Into<Line<T>>,

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

Splits a span at a offset

Example

use lset::*;
let span = Span::from(2..4);
assert_eq!(span.split(0), Some((Span::from(2..2), span)));
assert_eq!(span.split(1), Some((Span::from(2..3), Span::from(3..4))));
assert_eq!(span.split(2), Some((span, Span::from(4..4))));
assert_eq!(span.split(3), None);

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

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

Shrinks the line by the size of the operand

Example

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

type Output = Span<T>

The resulting type after applying the - operator.

impl<T: SubAssign<T>> SubAssign<T> for Span<T>

fn sub_assign(&mut self, rhs: T)

Shrinks the line by the size of the operand

Example

let mut span = lset::Span::new(5, 10);
span -= 5;
assert_eq!(span.start, 5);
assert_eq!(span.count, 5);

impl<T: Copy, U: Copy> Copy for Span<T, U>

impl<T: Eq, U: Eq> Eq for Span<T, U>

impl<T, U> StructuralPartialEq for Span<T, U>