Struct calamine::Range

pub struct Range<T: CellType> { /* fields omitted */ }

A struct which represents a squared selection of cells

Methods

impl<T: CellType> Range<T>

fn new(start: (u32, u32), end: (u32, u32)) -> Range<T>

Creates a new Range

When possible, prefer the more efficient Range::from_sparse

fn start(&self) -> (u32, u32)

Get top left cell position (row, column)

fn end(&self) -> (u32, u32)

Get bottom right cell position (row, column)

fn width(&self) -> usize

Get column width

fn height(&self) -> usize

Get column width

fn get_size(&self) -> (usize, usize)

Get size

fn is_empty(&self) -> bool

Is range empty

fn set_value(&mut self, absolute_position: (u32, u32), value: T) -> Result<()>

Set inner value from absolute position

Will try to resize inner structure if the value is out of bounds. For relative positions, use Index trait

Try to avoid this method as much as possible and prefer initializing the Range with from_sparce constructor.

Examples

use calamine::{Range, DataType};

let mut range = Range::new((0, 0), (5, 2));
assert_eq!(range.get_value((2, 1)), &DataType::Empty);
range.set_value((2, 1), DataType::Float(1.0))
    .expect("Cannot set value at position (2, 1)");
assert_eq!(range.get_value((2, 1)), &DataType::Float(1.0));

fn get_value(&self, absolute_position: (u32, u32)) -> &T

Get cell value from absolute position

For relative positions, use Index trait

Panics if indexes are out of range bounds

fn rows(&self) -> Rows<T>

Get an iterator over inner rows

Examples

use calamine::{Range, DataType};

let range: Range<DataType> = Range::new((0, 0), (5, 2));
// with rows item row: &[DataType]
assert_eq!(range.rows().map(|r| r.len()).sum::<usize>(), 18);

fn used_cells(&self) -> UsedCells<T>

Get an iterator over used cells only

Trait Implementations

impl<T: Debug + CellType> Debug for Range<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Default + CellType> Default for Range<T>

fn default() -> Range<T>

Returns the "default value" for a type.

impl<T: Clone + CellType> Clone for Range<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: CellType> Index<usize> for Range<T>

type Output = [T]

The returned type after indexing

fn index(&self, index: usize) -> &[T]

The method for the indexing (container[index]) operation

impl<T: CellType> Index<(usize, usize)> for Range<T>

type Output = T

The returned type after indexing

fn index(&self, index: (usize, usize)) -> &T

The method for the indexing (container[index]) operation

impl<T: CellType> IndexMut<usize> for Range<T>

fn index_mut(&mut self, index: usize) -> &mut [T]

The method for the mutable indexing (container[index]) operation

impl<T: CellType> IndexMut<(usize, usize)> for Range<T>

fn index_mut(&mut self, index: (usize, usize)) -> &mut T

The method for the mutable indexing (container[index]) operation