Struct TagSet 

pub struct TagSet { /* private fields */ }

A mutable set of tags, optionally backed by a SharedTagSet base.

TagSet supports efficient mutation through an overlay approach: it wraps an immutable SharedTagSet base with a small set of additions and a bitset tracking which base tags have been removed. This avoids full materialization when only a few tags need to change.

Memory layout

When no mutations have been made, TagSet is compact (base pointer + None overlay). The mutation state (additions and removals) is heap-allocated on demand only when insert_tag, remove_tags, or similar mutating methods are called.

Construction

A TagSet can be created from scratch (empty base, tags go into additions) or by wrapping an existing SharedTagSet for mutation. When constructed from scratch, the usage pattern is the same as before: call insert_tag in a loop, then into_shared to freeze.

Conversion

When converting back to SharedTagSet via into_shared, if no mutations have been made, the base is returned as-is with zero cost. Otherwise, the effective tags are materialized into a new SharedTagSet.

Implementations

impl TagSet

pub fn with_capacity(capacity: usize) -> Self

Creates a new, empty TagSet with the given capacity for additions.

pub fn is_empty(&self) -> bool

Returns true if the tag set is empty.

pub fn len(&self) -> usize

Returns the number of tags in the set.

pub fn insert_tag<T>(&mut self, tag: T)

where T: Into<Tag>,

Inserts a tag into the set.

If the tag is already present in the set, this does nothing. Presence is checked by exact tag value (both name and value), not just by name — multiple tags with the same name but different values can coexist.

pub fn remove_tags<T>(&mut self, tag_name: T) -> Option<Vec<Tag>>

where T: AsRef<str>,

Removes all tags with the given name from the set.

Returns the removed tags, or None if no tags matched.

pub fn has_tag<T>(&self, tag: T) -> bool

where T: AsRef<str>,

Returns true if the given tag is contained in the set.

This matches the complete tag, rather than just the name.

pub fn get_single_tag<T>(&self, tag_name: T) -> Option<&Tag>

where T: AsRef<str>,

Gets a single tag, by name, from the set.

If multiple tags are present with the same name, the first tag with a matching name will be returned. Additions are checked before the base. If no tag in the set matches, None is returned.

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

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

Retains only the tags specified by the predicate.

In other words, remove all tags t for which f(&t) returns false.

pub fn merge_missing(&mut self, other: Self)

Merges the tags from another set into this set.

If a tag from other is already present in this set, it will not be added.

pub fn merge_missing_shared(&mut self, other: &SharedTagSet)

Merges the tags from a shared set into this set.

If a tag from other is already present in this set, it will not be added.

pub fn merge_shared(&mut self, other: &SharedTagSet)

Merges the tags from a shared set into this set.

This method does not attempt to avoid adding duplicate tags.

pub fn into_shared(self) -> SharedTagSet

Consumes this TagSet and returns a shared, read-only version of it.

If no mutations have been made (no additions, no removals), the base SharedTagSet is returned as-is with zero cost.

pub fn size_of(&self) -> usize

Returns the estimated size of the tag set, in bytes.

This includes the size of the base SharedTagSet, additions, and removal tracking. The value returned is a rough estimate and does not compensate for inlined, interned, or heap-allocated tags.

pub fn is_modified(&self) -> bool

Returns true if this TagSet has been modified from its base.

Trait Implementations

impl Clone for TagSet

fn clone(&self) -> TagSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TagSet

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

Formats the value using the given formatter.

impl Default for TagSet

fn default() -> TagSet

Returns the “default value” for a type.

impl Display for TagSet

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

Formats the value using the given formatter.

impl Extend<Tag> for TagSet

fn extend<T: IntoIterator<Item = Tag>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<SharedTagSet> for TagSet

fn from(shared: SharedTagSet) -> Self

Converts to this type from the input type.

impl From<Tag> for TagSet

fn from(tag: Tag) -> Self

Converts to this type from the input type.

impl From<TagSet> for SharedTagSet

fn from(tag_set: TagSet) -> Self

Converts to this type from the input type.

impl FromIterator<Tag> for TagSet

fn from_iter<I: IntoIterator<Item = Tag>>(iter: I) -> Self

Creates a value from an iterator.

impl Hash for TagSet

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IntoIterator for &'a TagSet

type Item = &'a Tag

The type of the elements being iterated over.

type IntoIter = TagSetIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for TagSet

type Item = Tag

The type of the elements being iterated over.

type IntoIter = TagSetIntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<TagSet> for SharedTagSet

fn eq(&self, other: &TagSet) -> 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 PartialEq for TagSet

fn eq(&self, other: &TagSet) -> 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 Serialize for TagSet

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TagSet