Struct RangeDeserializerBuilder

pub struct RangeDeserializerBuilder<'h, H> { /* private fields */ }

Builds a Range deserializer with some configuration options.

This can be used to optionally parse the first row as a header. Once built, a RangeDeserializers cannot be changed.

Implementations

impl RangeDeserializerBuilder<'static, &'static str>

pub fn new() -> Self

Constructs a new builder for configuring Range deserialization.

pub fn has_headers(&mut self, yes: bool) -> &mut Self

Decide whether to treat the first row as a special header row.

Example

fn main() -> Result<(), Error> {
    let path = format!("{}/tests/temperature.xlsx", env!("CARGO_MANIFEST_DIR"));
    let mut workbook: Xlsx<_> = open_workbook(path)?;
    let range = workbook.worksheet_range("Sheet1")?;

    let mut iter = RangeDeserializerBuilder::new()
        .has_headers(false)
        .from_range(&range)?;

    if let Some(result) = iter.next() {
        let row: Vec<Data> = result?;
        assert_eq!(row, [Data::from("label"), Data::from("value")]);
    } else {
        return Err(From::from("expected at least three records but got none"));
    }

    if let Some(result) = iter.next() {
        let row: Vec<Data> = result?;
        assert_eq!(row, [Data::from("celsius"), Data::from(22.2222)]);
    } else {
        return Err(From::from("expected at least three records but got one"));
    }

    Ok(())
}

impl<'h, H: AsRef<str> + Clone + 'h> RangeDeserializerBuilder<'h, H>

pub fn with_headers(headers: &'h [H]) -> Self

Build a RangeDeserializer from this configuration and keep only selected headers.

Example

fn main() -> Result<(), Error> {
    let path = format!("{}/tests/temperature.xlsx", env!("CARGO_MANIFEST_DIR"));
    let mut workbook: Xlsx<_> = open_workbook(path)?;
    let range = workbook.worksheet_range("Sheet1")?;
    let mut iter = RangeDeserializerBuilder::with_headers(&["value", "label"]).from_range(&range)?;

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

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

pub fn from_range<'cell, T, D>( &self, range: &'cell Range<T>, ) -> Result<RangeDeserializer<'cell, T, D>, DeError>

where T: ToCellDeserializer<'cell>, D: DeserializeOwned,

Build a RangeDeserializer from this configuration.

Example

fn main() -> Result<(), Error> {
    let path = format!("{}/tests/temperature.xlsx", env!("CARGO_MANIFEST_DIR"));
    let mut workbook: Xlsx<_> = open_workbook(path)?;
    let range = workbook.worksheet_range("Sheet1")?;
    let mut iter = RangeDeserializerBuilder::new().from_range(&range)?;

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

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

impl<'h> RangeDeserializerBuilder<'h, &str>

pub fn with_deserialize_headers<'de, T>() -> Self

where T: Deserialize<'de>,

Build a RangeDeserializer from this configuration and keep only selected headers from the specified deserialization struct.

Example

#[derive(Deserialize)]
struct Record {
    label: String,
    value: f64,
}

fn main() -> Result<(), Error> {
    let path = format!("{}/tests/temperature.xlsx", env!("CARGO_MANIFEST_DIR"));
    let mut workbook: Xlsx<_> = open_workbook(path)?;
    let range = workbook.worksheet_range("Sheet1")?;
    let mut iter =
        RangeDeserializerBuilder::with_deserialize_headers::<Record>().from_range(&range)?;

    if let Some(result) = iter.next() {
        let record: Record = result?;
        assert_eq!(record.label, "celsius");
        assert_eq!(record.value, 22.2222);

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

Trait Implementations

impl<'h, H: Clone> Clone for RangeDeserializerBuilder<'h, H>

fn clone(&self) -> RangeDeserializerBuilder<'h, H>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for RangeDeserializerBuilder<'static, &'static str>

fn default() -> Self

Returns the “default value” for a type.