Enum Aggregator 

pub enum Aggregator<N, K, L, W, A>
where
    N: Field,
    K: Field,
    L: Field,
    W: Field,
    A: Field,
{
    Binary,
    Names(Option<BTreeSet<N>>),
    Kinds(Option<BTreeSet<K>>),
    Labels(Option<BTreeSet<L>>),
    Weights {
        fields: Option<BTreeSet<W>>,
        absolute: bool,
    },
    Annotations(Option<BTreeSet<A>>),
}

What to aggregate by.

Variants

Binary

Whether any objects have been counted.

Names(Option<BTreeSet<N>>)

Aggregated occurrences of these kinds. None means all.

Kinds(Option<BTreeSet<K>>)

Aggregated occurrences of these kinds. None means all.

Labels(Option<BTreeSet<L>>)

Aggregated occurrences of these labels. None means all.

Weights

Aggregate weight value.

Fields

fields: Option<BTreeSet<W>>

absolute: bool

Annotations(Option<BTreeSet<A>>)

Aggregate annotation key occurrence.

Implementations

impl<N, K, L, W, A> Aggregator<N, K, L, W, A>

where N: Field, K: Field, L: Field, W: Field, A: Field,

pub fn all_names() -> Self

Aggregator for all names.

pub fn for_name(value: N) -> Self

Aggregator for a single name.

pub fn all_kinds() -> Self

Aggregator for all kinds.

pub fn for_kind(value: K) -> Self

Aggregator for a single kind.

pub fn all_labels() -> Self

Aggregator for all labels.

pub fn for_label(value: L) -> Self

Aggregator for a single kind.

pub fn all_weights(absolute: bool) -> Self

Aggregator for all weights.

pub fn for_weight(value: W, absolute: bool) -> Self

Aggregator for a single weight.

pub fn all_annotations() -> Self

Aggregator for all annotations.

pub fn for_annotation(value: A) -> Self

Aggregator for a single annotation.

pub fn as_all(&self) -> Self

Create an instance that selects all fields.

Trait Implementations

impl<N, K, L, W, A> Clone for Aggregator<N, K, L, W, A>

where N: Field + Clone, K: Field + Clone, L: Field + Clone, W: Field + Clone, A: Field + Clone,

fn clone(&self) -> Aggregator<N, K, L, W, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N, K, L, W, A> Debug for Aggregator<N, K, L, W, A>

where N: Field + Debug, K: Field + Debug, L: Field + Debug, W: Field + Debug, A: Field + Debug,

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

Formats the value using the given formatter.

impl<N, K, L, W, A> Default for Aggregator<N, K, L, W, A>

where N: Field, K: Field, L: Field, W: Field, A: Field,

fn default() -> Aggregator<N, K, L, W, A>

Returns the “default value” for a type.

impl<'de, N, K, L, W, A> Deserialize<'de> for Aggregator<N, K, L, W, A>

where N: Field + Deserialize<'de>, K: Field + Deserialize<'de>, L: Field + Deserialize<'de>, W: Field + Deserialize<'de>, A: Field + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<N, K, L, W, A> PartialEq for Aggregator<N, K, L, W, A>

where N: Field + PartialEq, K: Field + PartialEq, L: Field + PartialEq, W: Field + PartialEq, A: Field + PartialEq,

fn eq(&self, other: &Aggregator<N, K, L, W, A>) -> 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<N, K, L, W, A> Serialize for Aggregator<N, K, L, W, A>

where N: Field + Serialize, K: Field + Serialize, L: Field + Serialize, W: Field + Serialize, A: Field + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<N, K, L, W, A> StructuralPartialEq for Aggregator<N, K, L, W, A>

where N: Field, K: Field, L: Field, W: Field, A: Field,