Struct CategoryCounter 

pub struct CategoryCounter<T: Hash + Eq> { /* private fields */ }

Accumulator for categorical data (counts by category)

Memory: O(k) where k is the number of unique categories

Implementations

impl<T: Hash + Eq> CategoryCounter<T>

pub fn new() -> Self

Create a new category counter

pub fn increment(&mut self, category: T)

Increment count for a category

pub fn increment_by(&mut self, category: T, amount: usize)

Increment count for a category by a specific amount

pub fn get(&self, category: &T) -> usize

Get count for a specific category

pub fn total(&self) -> usize

Get total count across all categories

pub fn num_categories(&self) -> usize

Get the number of unique categories

pub fn frequency(&self, category: &T) -> f64

Get frequency (proportion) for a category

pub fn categories(&self) -> &HashMap<T, usize>

Get all categories and their counts

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

Iterate over (category, count) pairs

impl CategoryCounter<String>

Specialized implementation for String to allow efficient &str increments

pub fn increment_str(&mut self, category: &str)

Optimized increment for &str - only allocates when category is new

This is much more efficient than increment(category.to_string()) because it only allocates a String when inserting a new category, not on every call.

For existing categories, this does a HashMap lookup with &str (no allocation), and only allocates a new String when the category is seen for the first time.

Trait Implementations

impl<T: Clone + Hash + Eq> Clone for CategoryCounter<T>

fn clone(&self) -> CategoryCounter<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Hash + Eq> Debug for CategoryCounter<T>

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

Formats the value using the given formatter.

impl<T: Default + Hash + Eq> Default for CategoryCounter<T>

fn default() -> CategoryCounter<T>

Returns the “default value” for a type.

impl<T: Hash + Eq + Send> Mergeable for CategoryCounter<T>

Implementation of Mergeable for parallel statistics computation

Merges category counts from multiple threads by summing counts for each category.

fn merge(&mut self, other: Self)

Merge another stats object into this one

fn merge_all(stats: Vec<Self>) -> Option<Self>

Merge multiple stats objects into one (convenience method)