Struct csv_diff::diff_result::DiffByteRecords

pub struct DiffByteRecords(_);

Holds all information about the difference between two CSVs, after they have been compared with CsvByteDiff.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 CsvByteDiff for general usage.

Implementations

impl DiffByteRecords

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 as_slice(&self) -> &[DiffByteRecord]

Return the DiffByteRecords as a single slice.

Example

use std::io::Cursor;
use csv_diff::{csv_diff::CsvByteDiff, 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 = CsvByteDiff::new()?;

let mut diff_byte_records = csv_byte_diff.diff(
    Csv::new(Cursor::new(csv_data_left.as_bytes())),
    Csv::new(Cursor::new(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 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<DiffByteRecords> 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: &DiffByteRecords) -> bool

This method tests for !=.

impl StructuralPartialEq for DiffByteRecords