Enum RangeOrCell

pub enum RangeOrCell {
    Cell(Address),
    ColumnRange {
        from: Column,
        to: Column,
    },
    NonContiguous(Vec<Self>),
    Range {
        from: Address,
        to: Address,
    },
    RowRange {
        from: Row,
        to: Row,
    },
}

Variants

Cell(Address)

Just a single cell

ColumnRange

A range between two columns

• from - Where the range begins
• to - Where the range ends

Fields

from: Column

to: Column

NonContiguous(Vec<Self>)

A set of cells and ranges

Note: rkyv requires that we add the omit_bounds for anything self-referential.

Range

A range between two positions

• from - Where the range begins
• to - Where the range ends

Fields

from: Address

to: Address

RowRange

A range between two rows

• from - Where the range begins
• to - Where the range ends

Fields

from: Row

to: Row

Implementations

impl RangeOrCell

pub fn iter(&self) -> RangeOrCellIterator

impl RangeOrCell

pub fn column<C: Into<Column>>(x: C) -> Self

Create a RangeOrCell::ColumnRange at the given x index

pub fn column_range<C: Into<Column>>(xa: C, xb: C) -> Self

Create a RangeOrCell::ColumnRange between two columns.

pub fn range<A: Into<Address>>(aa: A, ab: A) -> Self

Create a RangeOrCell::Range between two addresses.

pub fn row<R: Into<Row>>(y: R) -> Self

Create a RangeOrCell::RowRange at the given y index

pub fn row_range<R: Into<Row>>(ya: R, yb: R) -> Self

Create a RangeOrCell::RowRange between two rows.

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

This function has a lot going on because we need to handle every combination of every RangeOrCell containing every other combination of a RangeOrCell. The rules are nuanced but I think intuitive if you think through how it would look on a grid.

pub fn shift_down(self, rows: usize) -> Self

pub fn shift_left(self, columns: usize) -> Self

pub fn shift_right(self, columns: usize) -> Self

pub fn shift_up(self, rows: usize) -> Self

pub fn with_x(self, x: Index) -> Self

Set the x component of the underlying RangeOrCell. Depending on the variant of the enum the rules will be different

pub fn with_y(&self, y: usize) -> Self

Trait Implementations

impl Clone for RangeOrCell

fn clone(&self) -> RangeOrCell

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RangeOrCell

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

Formats the value using the given formatter.

impl Display for RangeOrCell

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

Formats the value using the given formatter.

impl FromStr for RangeOrCell

type Err = Error

The associated error which can be returned from parsing.

fn from_str(a1: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl Into<A1> for RangeOrCell

We allow converting from a more specific type (RangeOrCell) to a more general one (A1) but it can’t happen the other way around, so therefore we need to implement Into rather than From

fn into(self) -> A1

Converts this type into the (usually inferred) input type.

impl Into<RangeOrCell> for Address

fn into(self) -> RangeOrCell

Converts this type into the (usually inferred) input type.

impl Into<RangeOrCell> for Column

fn into(self) -> RangeOrCell

Converts this type into the (usually inferred) input type.

impl Into<RangeOrCell> for Row

fn into(self) -> RangeOrCell

Converts this type into the (usually inferred) input type.

impl IntoIterator for RangeOrCell

type Item = RangeOrCell

The type of the elements being iterated over.

type IntoIter = RangeOrCellIntoIterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> RangeOrCellIntoIterator

Creates an iterator from a value.

impl PartialEq for RangeOrCell

fn eq(&self, other: &RangeOrCell) -> 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 StructuralPartialEq for RangeOrCell