Struct TlsSet 

pub struct TlsSet<K> { /* private fields */ }

A sorted set with deterministic TLS codec serialization.

Examples

use xmtp_mls_common::tls_set::TlsSet;
use tls_codec::{Serialize, Deserialize};

let mut set = TlsSet::<u16>::new();
set.insert(3).unwrap();
set.insert(1).unwrap();
set.insert(2).unwrap();

let bytes = set.tls_serialize_detached().unwrap();
let deserialized = TlsSet::<u16>::tls_deserialize_exact(&bytes).unwrap();
assert_eq!(set, deserialized);

Implementations

impl<K: Ord + Eq> TlsSet<K>

pub fn new() -> Self

Create an empty set.

pub fn from_keys(iter: impl IntoIterator<Item = K>) -> Self

Create a set from an iterator of keys. Duplicates are silently ignored.

use xmtp_mls_common::tls_set::TlsSet;

let set = TlsSet::from_keys([3, 1, 2, 1]);
assert_eq!(set.len(), 3);

pub fn insert(&mut self, key: K) -> Result<(), TlsSetError>

Insert a key. Returns an error if the key already exists.

use xmtp_mls_common::tls_set::TlsSet;

let mut set = TlsSet::<u8>::new();
assert!(set.insert(1).is_ok());
assert!(set.insert(1).is_err()); // duplicate

pub fn remove(&mut self, key: &K) -> Result<(), TlsSetError>

Remove a key. Returns an error if the key doesn’t exist.

use xmtp_mls_common::tls_set::TlsSet;

let mut set = TlsSet::<u8>::new();
set.insert(1).unwrap();
assert!(set.remove(&1).is_ok());
assert!(set.remove(&1).is_err()); // already removed

pub fn contains(&self, key: &K) -> bool

Returns true if the set contains the key.

pub fn len(&self) -> usize

Returns the number of elements in the set.

pub fn is_empty(&self) -> bool

Returns true if the set is empty.

pub fn iter(&self) -> impl Iterator<Item = &K>

Iterate over keys in sorted order.

use xmtp_mls_common::tls_set::TlsSet;

let set = TlsSet::from_keys([3, 1, 2]);
let keys: Vec<_> = set.iter().collect();
assert_eq!(keys, vec![&1, &2, &3]);

impl<K: Ord + Eq + Clone + Serialize + Size> TlsSet<K>

pub fn apply_delta(&mut self, delta: TlsSetDelta<K>) -> Result<(), TlsSetError>

Apply a delta atomically. If any mutation fails, the set is unchanged.

If the delta contains any RemoveByHash mutations, a hash index of all existing keys is built once (O(n)) and used for lookups (O(1) each), avoiding O(n*m) behavior. Returns TlsSetError::DuplicateHash if two existing keys produce the same SHA-256 hash.

Performance

• Time: O(n + m) when the delta contains any RemoveByHash (one O(n) index build, then O(1) per lookup), or O(m) otherwise, where n is the current set size and m is the mutation count.
• Memory: O(m) — all mutations are resolved into a temporary Vec<TlsMapMutation> before being applied. This allocation is required to preserve atomicity: resolution must complete before any actual mutation happens, so a partial delta cannot leave the set in an inconsistent state. When RemoveByHash is present, an additional O(n) HashMap is allocated for the hash index, holding borrowed key references (no key cloning during index build).

use xmtp_mls_common::tls_set::{TlsSet, TlsSetDelta};

let mut set = TlsSet::<u8>::new();
set.insert(1).unwrap();

let delta = TlsSetDelta::new().insert(2).remove(1);
set.apply_delta(delta).unwrap();
assert!(set.contains(&2));
assert!(!set.contains(&1));

Trait Implementations

impl<K: Clone> Clone for TlsSet<K>

fn clone(&self) -> TlsSet<K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug> Debug for TlsSet<K>

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

Formats the value using the given formatter.

impl<K> Default for TlsSet<K>

fn default() -> Self

Returns the “default value” for a type.

impl<K> Deserialize for TlsSet<K>

where K: Deserialize + Size + Ord + Eq,

fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error>

where Self: Sized,

This function deserializes the bytes from the provided a std::io::Read and returns the populated struct.

fn tls_deserialize_exact(bytes: impl AsRef<[u8]>) -> Result<Self, Error>

where Self: Sized,

This function deserializes the provided bytes and returns the populated struct. All bytes must be consumed.

impl<K: Ord + Eq> FromIterator<K> for TlsSet<K>

fn from_iter<T: IntoIterator<Item = K>>(iter: T) -> Self

Creates a value from an iterator.

impl<K> IntoIterator for TlsSet<K>

type Item = K

The type of the elements being iterated over.

type IntoIter = Map<<TlsMap<K, ()> as IntoIterator>::IntoIter, fn((K, ())) -> K>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: PartialEq> PartialEq for TlsSet<K>

fn eq(&self, other: &TlsSet<K>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<K: Serialize + Size + Debug> Serialize for TlsSet<K>

fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error>

Serialize self and write it to the writer. The function returns the number of bytes written to writer.

fn tls_serialize_detached(&self) -> Result<Vec<u8>, Error>

Serialize self and return it as a byte vector.

impl<K: Size> Size for TlsSet<K>

fn tls_serialized_len(&self) -> usize

impl<K: Eq> Eq for TlsSet<K>

impl<K> StructuralPartialEq for TlsSet<K>