Struct ComparisonBatch 

pub struct ComparisonBatch {
    pub n_pairs: usize,
    pub n_fields: usize,
    pub pair_ids: Vec<(RecordId, RecordId)>,
    pub levels: Vec<u8>,
}

Field-major SoA batch of comparison results for many pairs.

Layout

levels[field_idx * n_pairs + pair_idx] = ComparisonLevel as u8

All values for field 0 across every pair are contiguous, then field 1, etc.

Fields

n_pairs: usize

n_fields: usize

pair_ids: Vec<(RecordId, RecordId)>

(record_a_id, record_b_id) for pair p.

levels: Vec<u8>

Field-major levels: levels[f * n_pairs + p].

Implementations

impl ComparisonBatch

pub fn new( n_pairs: usize, n_fields: usize, pair_ids: Vec<(RecordId, RecordId)>, ) -> Self

Allocate a zeroed batch (all levels = ComparisonLevel::None).

pub fn level(&self, field: usize, pair: usize) -> ComparisonLevel

Read the level for (field, pair).

pub fn set_level(&mut self, field: usize, pair: usize, level: ComparisonLevel)

Write the level for (field, pair).

pub fn pair_as_vector(&self, pair_idx: usize) -> ComparisonVector

Reconstruct a ComparisonVector for pair p.

pub fn from_vectors(vectors: &[ComparisonVector]) -> Self

Build from an existing Vec<ComparisonVector> for migration / tests.

pub fn into_vectors(&self) -> Vec<ComparisonVector>

Convert back to Vec<ComparisonVector> for callers that still need it.

pub fn concat(chunks: &[Self]) -> Self

Concatenate multiple field-major batches (same n_fields) into one.

Each chunk may have a different n_pairs. The merged layout remains field-major with n_pairs_total = sum of all chunk n_pairs.

Trait Implementations

impl Clone for ComparisonBatch

fn clone(&self) -> ComparisonBatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComparisonBatch

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ComparisonBatch

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ComparisonBatch

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.