Struct SharedTagSet 

pub struct SharedTagSet(/* private fields */);

A shared, read-only set of tags.

Structural sharing

In many cases, it is useful to extend a set of tags with additional tags, without needing to clone the additional tags or re-allocate the underlying storage to fit the entire set of tags. SharedTagSet supports this by utilizing “structural sharing”, where SharedTagSet is internally represented by a set of smart pointers to TagSet.

This allows SharedTagSet to be cheaply extended with additional SharedTagSet instances, without needing to allocate enough underlying storage to hold all of the individual tags. Extending a SharedTagSet will allocate a small amount of memory (8 bytes) for each additional SharedTagSet that is chained after the first additional one: this means that all new SharedTagSet instances can be extended once with no allocations whatsoever.

Implementations

impl SharedTagSet

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 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. If no tag in the set matches, None is returned.

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

Extends self with the tags from the other.

If any of the individual TagSet instances in other are already present in self, they will not be added again. This method does not avoid duplicates across different SharedTagSet instances, so if the same tag is present in both self and other, it will be present when querying the resulting SharedTagSet.

pub fn as_tag_sets(&self) -> &[Arc<TagSet>]

Returns a reference to the underlying TagSet instances.

pub fn size_of(&self) -> usize

Returns the size of the tag set, in bytes.

This includes the size of the vector holding any chained tagsets as well as each individual tag.

Additionally, the value returned by this method does not compensate for externalities such as whether or not tags are are inlined, interned, or heap allocated. This means that the value returned is essentially the worst-case usage, and should be used as a rough estimate.

Trait Implementations

impl Clone for SharedTagSet

fn clone(&self) -> SharedTagSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SharedTagSet

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

Formats the value using the given formatter.

impl Default for SharedTagSet

fn default() -> SharedTagSet

Returns the “default value” for a type.

impl Display for SharedTagSet

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

Formats the value using the given formatter.

impl From<TagSet> for SharedTagSet

fn from(tag_set: TagSet) -> Self

Converts to this type from the input type.

impl FromIterator<Tag> for SharedTagSet

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

Creates a value from an iterator.

impl Hash for SharedTagSet

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 SharedTagSet

type Item = &'a Tag

The type of the elements being iterated over.

type IntoIter = SharedTagSetIterator<'a>

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 SharedTagSet

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

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 SharedTagSet