Struct range::Range

pub struct Range<I> {
    pub(crate) begin: I,
    pub(crate) length: I,
}

A range of indices

Fields

begin: I

length: I

Implementations

impl<I: RangeIndex> Range<I>

pub fn new(begin: I, length: I) -> Range<I>

Create a new range from beginning and length offsets. This could be denoted as [begin, begin + length).

   |-- begin ->|-- length ->|
   |           |            |
<- o - - - - - +============+ - - - ->

pub fn empty() -> Range<I>

pub fn begin(&self) -> I

The index offset to the beginning of the range.

   |-- begin ->|
   |           |
<- o - - - - - +============+ - - - ->

pub fn length(&self) -> I

The index offset from the beginning to the end of the range.

               |-- length ->|
               |            |
<- o - - - - - +============+ - - - ->

pub fn end(&self) -> I

The index offset to the end of the range.

   |--------- end --------->|
   |                        |
<- o - - - - - +============+ - - - ->

pub fn contains(&self, i: I) -> bool

true if the index is between the beginning and the end of the range.

       false        true      false
         |           |          |
<- o - - + - - +=====+======+ - + - ->

pub fn is_empty(&self) -> bool

true if the offset from the beginning to the end of the range is zero.

pub fn shift_by(&mut self, delta: I)

Shift the entire range by the supplied index delta.

                    |-- delta ->|
                    |           |
<- o - +============+ - - - - - | - - - ->
                                |
<- o - - - - - - - +============+ - - - ->

pub fn extend_by(&mut self, delta: I)

Extend the end of the range by the supplied index delta.

                    |-- delta ->|
                    |           |
<- o - - - - - +====+ - - - - - | - - - ->
                                |
<- o - - - - - +================+ - - - ->

pub fn extend_to(&mut self, target: I)

Move the end of the range to the target index.

                              target
                                |
<- o - - - - - +====+ - - - - - | - - - ->
                                |
<- o - - - - - +================+ - - - ->

pub fn adjust_by(&mut self, begin_delta: I, length_delta: I)

Adjust the beginning offset and the length by the supplied deltas.

pub fn reset(&mut self, begin: I, length: I)

Set the begin and length values.

pub fn intersect(&self, other: &Range<I>) -> Range<I>

impl<I: RangeIndex> Range<I>

Methods for Ranges with indices based on integer values

pub fn each_index(&self) -> EachIndex<I>

Returns an iterater that increments over [begin, end).

Trait Implementations

impl<I: Clone> Clone for Range<I>

fn clone(&self) -> Range<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: RangeIndex> Debug for Range<I>

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

Formats the value using the given formatter.

impl<'de, I> Deserialize<'de> for Range<I>

where I: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I> MallocSizeOf for Range<I>

where I: MallocSizeOf,

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl<I> Serialize for Range<I>

where I: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: Copy> Copy for Range<I>