Struct csv_diff::diff_result::DiffByteRecords

pub struct DiffByteRecords { /* private fields */ }

Holds all information about the difference between two CSVs, after they have been compared with CsvByteDiffLocal.diff. CSV records that are equal are not stored in this structure.

Also, keep in mind, that differences are stored unordered (with regard to the line in the CSV). You can use DiffByteRecords.sort_by_line to sort them in-place.

See the example on CsvByteDiffLocal for general usage.

Implementations

impl DiffByteRecords

pub fn headers(&self) -> &Headers

pub fn num_columns(&self) -> Option<usize>

pub fn sort_by_line(&mut self)

Sort the underlying DiffByteRecords by line.

Note that comparison is done in parallel. Therefore, without calling this method, the resulting DiffByteRecords are out of order after the comparison (with regard to their line in the original CSV).

pub fn sort_by_columns<E: Into<ColumnIdx>, I: IntoIterator<Item = E>>( &mut self, cols: I ) -> Result<(), ColumnIdxError>

pub fn as_slice(&self) -> &[DiffByteRecord]

Return the DiffByteRecords as a single slice.

Example

use csv_diff::{csv_diff::CsvByteDiffLocal, csv::Csv};
use std::collections::HashSet;
use std::iter::FromIterator;
// some csv data with a header, where the first column is a unique id
let csv_data_left = "id,name,kind\n\
                     1,lemon,fruit\n\
                     2,strawberry,fruit";
let csv_data_right = "id,name,kind\n\
                      1,lemon,fruit\n\
                      2,strawberry,nut\n\
                      3,cherry,fruit";

let csv_byte_diff = CsvByteDiffLocal::new()?;

let mut diff_byte_records = csv_byte_diff.diff(
    Csv::with_reader_seek(csv_data_left.as_bytes()),
    Csv::with_reader_seek(csv_data_right.as_bytes()),
)?;

let diff_byte_record_slice = diff_byte_records.as_slice();

assert_eq!(
    diff_byte_record_slice.len(),
    2
);
Ok(())

pub fn iter(&self) -> Iter<'_, DiffByteRecord>

Return an iterator over the DiffByteRecords.

Trait Implementations

impl Clone for DiffByteRecords

fn clone(&self) -> DiffByteRecords

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DiffByteRecords

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

Formats the value using the given formatter.

impl IntoIterator for DiffByteRecords

type Item = DiffByteRecord

The type of the elements being iterated over.

type IntoIter = DiffByteRecordsIntoIterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for DiffByteRecords

fn eq(&self, other: &DiffByteRecords) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DiffByteRecords