Struct ListByRelayIds

pub struct ListByRelayIds<H: HasRelayIds>
where
    RsaIdentity: Hash + Eq + Clone,
    Ed25519Identity: Hash + Eq + Clone,
{
    rsa_map: HashMap<RsaIdentity, SmallVec<[usize; 4]>>,
    ed25519_map: HashMap<Ed25519Identity, SmallVec<[usize; 4]>>,
    values: Slab<H>,
}

A list of objects that can be accessed by relay identity.

Multiple objects in the list can have a given relay identity.

Invariants

Every object in the list must have at least one recognized relay identity; if it does not, it cannot be inserted.

This list may panic or give incorrect results if the values can change their keys through interior mutability.

General information

A list of elements of type H whose members can be accessed by multiple keys.

The keys are:

• rsa (RsaIdentity) (Option)
• ed25519 (Ed25519Identity) (Option)

Each element has a value for each required key, and up to one value for each optional key. There can be many elements for a given key value.

Requirements

Key types must have consistent Hash and Eq implementations, as they will be used as keys in a HashMap.

If all keys are optional, then every element inserted must have at least one non-None key.

An element must not change its keys over time through interior mutability.

If any of these rules is violated, the consequences are unspecified, and could include panics or wrong answers (but not memory-unsafety).

Fields

rsa_map: HashMap<RsaIdentity, SmallVec<[usize; 4]>>

The $key fields here are a set of maps from each of the key values to the lists of the positions of values with the same key within the Slab.

Invariants:

• There is an entry K=>idx in the map $key if and only if values[idx].$accessor() == K.
• Every value in values has at least one key.
• A list should never be empty.

The map values (the lists) are effectively a set, but using an inline vec should have better cache performance than something like HashSet.

The SmallVec size of 4 was chosen arbitrarily under the assumption that a given key will have a small number of values on average. The exact constant probably won’t matter, but inlining most of the lists should be good even if some spill into separate memory allocations. It’s not worth exposing this level of internal detail to the macro caller unless there’s a reason we need to.

ed25519_map: HashMap<Ed25519Identity, SmallVec<[usize; 4]>>

values: Slab<H>

A map from the indices to the values.

Implementations

impl<H: HasRelayIds> ListByRelayIds<H>

where RsaIdentity: Hash + Eq + Clone, Ed25519Identity: Hash + Eq + Clone,

pub fn new() -> Self

Construct a new ListByRelayIds.

pub fn with_capacity(n: usize) -> Self

Construct a new ListByRelayIds with a given capacity.

pub fn by_rsa<BorrowAsKey_>( &self, key: &BorrowAsKey_, ) -> ListByRelayIdsIter<'_, H>

where RsaIdentity: Borrow<BorrowAsKey_>, BorrowAsKey_: Hash + Eq + ?Sized,

Return an iterator of the elements whose rsa is key.

The iteration order is arbitrary.

pub fn contains_rsa<BorrowAsKey_>(&mut self, key: &BorrowAsKey_) -> bool

where RsaIdentity: Borrow<BorrowAsKey_>, BorrowAsKey_: Hash + Eq + ?Sized,

Return true if this list contains an element whose rsa is key.

pub fn remove_by_rsa<BorrowAsKey_>( &mut self, key: &BorrowAsKey_, filter: impl FnMut(&H) -> bool, ) -> Vec<H>

where RsaIdentity: Borrow<BorrowAsKey_>, BorrowAsKey_: Hash + Eq + ?Sized,

Remove and return the elements whose rsa is key and where filter returns true.

pub fn by_ed25519<BorrowAsKey_>( &self, key: &BorrowAsKey_, ) -> ListByRelayIdsIter<'_, H>

where Ed25519Identity: Borrow<BorrowAsKey_>, BorrowAsKey_: Hash + Eq + ?Sized,

Return an iterator of the elements whose ed25519 is key.

The iteration order is arbitrary.

pub fn contains_ed25519<BorrowAsKey_>(&mut self, key: &BorrowAsKey_) -> bool

where Ed25519Identity: Borrow<BorrowAsKey_>, BorrowAsKey_: Hash + Eq + ?Sized,

Return true if this list contains an element whose ed25519 is key.

pub fn remove_by_ed25519<BorrowAsKey_>( &mut self, key: &BorrowAsKey_, filter: impl FnMut(&H) -> bool, ) -> Vec<H>

where Ed25519Identity: Borrow<BorrowAsKey_>, BorrowAsKey_: Hash + Eq + ?Sized,

Remove and return the elements whose ed25519 is key and where filter returns true.

fn remove_at(&mut self, idx: usize) -> Option<H>

pub fn values(&self) -> impl Iterator<Item = &H> + '_

Return an iterator over the elements in this container.

pub fn into_values(self) -> impl Iterator<Item = H>

Consume this container and return an iterator of its values.

pub fn try_insert(&mut self, value: H) -> Result<(), Error>

Try to insert value.

Return Error::NoKeys if all the keys are optional, and value has no keys at all.

pub fn insert(&mut self, value: H)

See try_insert. Panicks on errors.

pub fn len(&self) -> usize

Return the number of elements in this container.

pub fn is_empty(&self) -> bool

Return true if there are no elements in this container.

pub fn capacity(&self) -> usize

Return the number of elements for which this container has allocated storage.

pub fn retain<F>(&mut self, pred: F)

where F: FnMut(&H) -> bool,

Remove every element that does not satisfy the predicate pred.

fn compact(&mut self)

Re-index all the values in this map, so that the map can use a more compact representation.

This should be done infrequently; it’s expensive.

fn check_consistency(&self)

Assert that this list appears to be in an internally consistent state.

This method can be very expensive, and it should never fail unless your code has a bug.

Panics

Panics if it finds bugs in this object, or constraint violations in its elements. See the (type documentation)Self for a list of constraints.

impl<H: HasRelayIds> ListByRelayIds<H>

pub fn by_id<'a, T>(&self, key: T) -> ListByRelayIdsIter<'_, H>

where T: Into<RelayIdRef<'a>>,

Return an iterator of the values in this list that have the key key.

pub fn by_all_ids<'a>( &'a self, key: &'a impl HasRelayIds, ) -> impl Iterator<Item = &'a H> + 'a

Return the values in this list that have all the relay IDs that key does.

Returns an empty iterator if key has no relay IDs.

pub fn all_overlapping<T>(&self, key: &T) -> Vec<&H>

where T: HasRelayIds,

Return a reference to every element in this set that shares any ID with key.

No element is returned more than once. Equality is compared using ByAddress.

pub fn all_subset<T>(&self, key: &T) -> Vec<&H>

where T: HasRelayIds,

Return a reference to every element in this list whose relay IDs are a subset of the relay IDs that key has.

No element is returned more than once. Equality is compared using ByAddress.

pub fn remove_by_id<'a, T>( &mut self, key: T, filter: impl FnMut(&H) -> bool, ) -> Vec<H>

where T: Into<RelayIdRef<'a>>,

Return the values in this list that have the key key and where filter returns true.

pub fn remove_exact<T>(&mut self, key: &T) -> Vec<H>

where T: HasRelayIds,

Remove and return the values in this list that have exactly the same relay IDs that key does.

pub fn remove_by_all_ids<T>(&mut self, key: &T) -> Vec<H>

where T: HasRelayIds,

Remove and return the values in this list that have all the same relay IDs that key does.

If key has no relay IDs, then no values are removed.

Trait Implementations

impl<H: Clone + HasRelayIds> Clone for ListByRelayIds<H>

where RsaIdentity: Hash + Eq + Clone, Ed25519Identity: Hash + Eq + Clone,

fn clone(&self) -> ListByRelayIds<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: Debug + HasRelayIds> Debug for ListByRelayIds<H>

where RsaIdentity: Hash + Eq + Clone, Ed25519Identity: Hash + Eq + Clone,

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

Formats the value using the given formatter.

impl<H: HasRelayIds> Default for ListByRelayIds<H>

where RsaIdentity: Hash + Eq + Clone, Ed25519Identity: Hash + Eq + Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<H: HasRelayIds> FromIterator<H> for ListByRelayIds<H>

where RsaIdentity: Hash + Eq + Clone, Ed25519Identity: Hash + Eq + Clone,

fn from_iter<IntoIter_>(iter: IntoIter_) -> Self

where IntoIter_: IntoIterator<Item = H>,

Creates a value from an iterator.