Struct ComparisonBatch 

pub struct ComparisonBatch {
    pub n_pairs: usize,
    pub n_fields: usize,
    pub pair_ids: Vec<(u64, u64)>,
    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<(u64, u64)>

(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<(u64, u64)>, ) -> ComparisonBatch

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]) -> ComparisonBatch

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: &[ComparisonBatch]) -> ComparisonBatch

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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<ComparisonBatch, <__D as Deserializer<'de>>::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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.