Struct RecordSet 

pub struct RecordSet<T> { /* private fields */ }

A container that lets callers organize records by identifier.

Deduplication by identifier

The same EntryId appearing twice in one payload is legal: it can carry one version of the entry per device. A merge can only apply one result, so which one is used has to be fixed first: first-inserted wins, and whoever builds the payload is responsible for putting the version it wants adopted first.

Last-inserted-wins is not used: that would make the order inside a payload a security-relevant property (the last record decides), while the peer controls that order.

Genericity

Two places need a “record set deduplicated by identifier”, with different element types:

• MergedRecord: the semantic record after decryption, used by the merge layer.
• crate::sync::Record: the wire-format record that is still encrypted, used by payload packing and parsing.

One generic container instead of two implementations is not just less code: the two deduplication rules must be identical (both are first-inserted wins), and two implementations would silently drift apart, showing up as a payload deduplicated on the sending side and not on the receiving side — a failure that reproduces only on the peer.

Implementations

impl<T: HasEntryId> RecordSet<T>

pub fn new() -> Self

An empty set.

pub fn insert(&mut self, record: T) -> bool

Inserts a record; does not overwrite when the same ID already exists.

Returns whether the record was actually inserted (false means this ID is already present).

pub fn len(&self) -> usize

How many records there are.

pub fn is_empty(&self) -> bool

Whether the set is empty.

pub fn get(&self, id: &EntryId) -> Option<&T>

Borrows the record for one ID.

pub fn iter(&self) -> impl Iterator<Item = (&EntryId, &T)>

Iterates in ID order.

A BTreeMap rather than a HashMap: the iteration order has to be deterministic, otherwise the same payload would produce a different merge order on different devices and the order of the conflict list would follow; for the wire format it would also make two payloads with identical content produce different plaintext.

Trait Implementations

impl<T: Debug> Debug for RecordSet<T>

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

Formats the value using the given formatter.

impl<T> Default for RecordSet<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> IntoIterator for &'a RecordSet<T>

fn into_iter(self) -> Self::IntoIter

Borrows every record in ID order.

Borrowing rather than a records() -> Vec<T>: the latter requires every record to be copyable, and both element types deliberately have no Clone (they hold key material). Borrowing lets merge_into take a &RecordSet directly, without copying the key material of a whole payload just to pass it around — one sync would copy hundreds of seeds for no reason at all.

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Values<'a, EntryId, T>

Which kind of iterator are we turning this into?