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>

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

Creates a new Range

When possible, prefer the more efficient Range::from_sparse

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

Get top left cell position (row, column)

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

Get bottom right cell position (row, column)

pub fn width(&self) -> usize

Get column width

pub fn height(&self) -> usize

Get column width

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

Get size in (height, width) format

pub fn is_empty(&self) -> bool

Is range empty

pub fn from_sparse(cells: Vec<Cell<T>>) -> Range<T>

Creates a Range from a coo sparse vector of Cells.

Coordinate list (COO) is the natural way cells are stored Inner size is defined only by non empty.

cells: Vec of non empty Cells, sorted by row

Panics

panics when a Cell row is lower than the first Cell row or bigger than the last Cell row.

pub fn set_value(&mut self, absolute_position: (u32, u32), value: T)

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.

Panics

If absolute_position > Cell start

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));
assert_eq!(range.get_value((2, 1)), &DataType::Float(1.0));

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

Get cell value from absolute position

The coordinate format is (row, column). For relative positions, use Index trait

Panics if indexes are out of range bounds

Important traits for Rows<'a, T>

impl<'a, T: 'a + CellType> Iterator for Rows<'a, T> type Item = &'a [T];

pub 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);

Important traits for UsedCells<'a, T>

impl<'a, T: 'a + CellType> Iterator for UsedCells<'a, T> type Item = (usize, usize, &'a T);

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

Get an iterator over used cells only

pub fn deserialize<'a, D>(
    &'a self
) -> Result<RangeDeserializer<'a, T, D>, DeError> where
    T: ToCellDeserializer<'a>,
    D: DeserializeOwned, 

Build a RangeDeserializer from this configuration.

Example

fn example() -> Result<(), Error> {
    let path = format!("{}/tests/tempurature.xlsx", env!("CARGO_MANIFEST_DIR"));
    let mut workbook: Xlsx<_> = open_workbook(path)?;
    let mut sheet = workbook.worksheet_range("Sheet1")
        .ok_or(Error::Msg("Cannot find 'Sheet1'"))??;
    let mut iter = sheet.deserialize()?;

    if let Some(result) = iter.next() {
        let (label, value): (String, f64) = result?;
        assert_eq!(label, "celcius");
        assert_eq!(value, 22.2222);

        Ok(())
    } else {
        return Err(From::from("expected at least one record but got none"));
    }
}

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]

Performs 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

Performs the indexing (container[index]) operation.

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

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

Performs 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

Performs the mutable indexing (container[index]) operation.