Enum SubAggregator

pub enum SubAggregator {
    Const(SemId, TinyBlob),
    TheOnly(StateName),
    Copy(StateName),
    Unwrap(StateName),
    First(StateName),
    Nth(StateName, u16),
    Last(StateName),
    NthBack(StateName, u16),
    Neg(StateSelector),
    Add(StateSelector, StateSelector),
    Sub(StateSelector, StateSelector),
    Mul(StateSelector, StateSelector),
    Div(StateSelector, StateSelector),
    Rem(StateSelector, StateSelector),
    Exp(StateSelector, StateSelector),
    Count(StateName),
    CountUnique(StateName),
    SetV(StateName),
    MapV2U(StateName),
    MapV2ListU(StateName),
    MapV2SetU(StateName),
    SumUnwrap(StateName),
    SumOrDefault(StateName),
    ProdUnwrap(StateName),
    ProdOrDefault(StateName),
}

A set of pre-defined state sub-aggregators (see crate::Api::aggregators.

Variants

Const(SemId, TinyBlob)

The aggregated state is generated with a predefined constant strict-encoded value.

To produce a state with a unit value, use Self::Const(SemId::unit(), none!()).

TheOnly(StateName)

Takes the only element of the global state.

Fails if the state is not defined or has more than one defined element.

Copy(StateName)

Takes some other aggregated and copies it.

Fails if the other aggregated state is not defined.

Unwrap(StateName)

Unwraps an optional value.

Fails if the value is None, is not defined, multiple, or not an optional.

First(StateName)

Takes the first element of the global state.

Fails if the global state is not defined, i.e., has zero elements.

Nota bene

The global state does not have only a partial ordering (it is a lattice).

It is only in the case when one operation depends on outputs of another (via global or owned state) there is a guarantee that the global state defined by the second operation will always follow the first one.

It is the responsibility of the codex developer to ensure non-ambiguity when this aggregator is used.

Nth(StateName, u16)

Takes the nth element of the global state.

Fails if the global state is not defined, i.e., has zero elements, or if the nth-element is empty.

Nota bene

The global state does not have only a partial ordering (it is a lattice).

It is only in the case when one operation depends on outputs of another (via global or owned state) there is a guarantee that the global state defined by the second operation will always follow the first one.

It is the responsibility of the codex developer to ensure non-ambiguity when this aggregator is used.

Last(StateName)

Takes the last element of the global state.

Fails if the global state is not defined, i.e., has zero elements.

Nota bene

The global state does not have only a partial ordering (it is a lattice).

It is only in the case when one operation depends on outputs of another (via global or owned state) there is a guarantee that the global state defined by the second operation will always follow the first one.

It is the responsibility of the codex developer to ensure non-ambiguity when this aggregator is used.

NthBack(StateName, u16)

Takes the nth element of the global state, counting from the end of the list.

Fails if the global state is not defined, i.e., has zero elements, or if the nth-element is empty.

Nota bene

The global state does not have only a partial ordering (it is a lattice).

It is only in the case when one operation depends on outputs of another (via global or owned state) there is a guarantee that the global state defined by the second operation will always follow the first one.

It is the responsibility of the codex developer to ensure non-ambiguity when this aggregator is used.

Neg(StateSelector)

Integer-negate state.

Fails if the state is not defined or contains multiple elements. Also fails if the state is not an unsigned 64-bit integer or is greater than i64::MAX.

Add(StateSelector, StateSelector)

Sum two states of different types, expecting them to be integers.

Fails if any of the state is not defined or contains multiple elements. Also fails if the state is not an unsigned 64-bit integer or there is an overflow.

Sub(StateSelector, StateSelector)

Substracts the second state from the first state, expecting both to be integers.

Fails if any of the state is not defined or contains multiple elements. Also fails if the state is not an unsigned 64-bit integer or there is an overflow.

Mul(StateSelector, StateSelector)

Product two states of different types, expecting them to be integers.

Fails if any of the state is not defined or contains multiple elements. Also fails if the state is not an unsigned 64-bit integer or there is an overflow.

Div(StateSelector, StateSelector)

Divide the first state on the second state, expecting them to be integers. The resulting value is rounded towards zero.

Fails if any of the state is not defined or contains multiple elements. Also fails if the state is not an unsigned 64-bit integer, or the second state is zero.

Rem(StateSelector, StateSelector)

Modulo-divide the first state on the second state, expecting them to be integers.

Fails if any of the state is not defined or contains multiple elements. Also fails if the state is not an unsigned 64-bit integer, or the second state is zero.

Exp(StateSelector, StateSelector)

Exponentiates the first state with the second state, expecting them to be integers. The resulting value is rounded towards zero.

Fails if any of the state is not defined or contains multiple elements. Also fails if the first state is not an unsigned 64-bit integer, the second state is not an unsigned 32-bit integer, or there is an overflow.

Count(StateName)

Count the number of elements of the global state of a certain type.

CountUnique(StateName)

Count the number of unique elements of the global state of a certain type.

SetV(StateName)

Convert a verified state under the same state type into an ordered set.

Acts only on a global state; doesn’t recognize aggregated state.

If the global state with the name is absent returns an empty set.

MapV2U(StateName)

Map from a field-based element state to a non-verifiable structured state; when the field-based element state repeats, it is ignored and only the initial state is kept.

The map is sorted by its values, lexicographically.

Acts only on a global state; doesn’t recognize aggregated state.

If the global state with the name is absent returns an empty map.

Nota bene

The global state does not have only a partial ordering (it is a lattice).

It is only in the case when one operation depends on outputs of another (via global or owned state) there is a guarantee that the global state defined by the second operation will always follow the first one.

It is the responsibility of the codex developer to ensure non-ambiguity when this aggregator is used.

MapV2ListU(StateName)

Map from a field-based element state to a list of non-verifiable structured state; when the field-based element state repeats, the list is extended with the non-verifiable state.

The map is ordered according to the global state element order.

Acts only on a global state; doesn’t recognize aggregated state.

If the global state with the name is absent returns an empty map.

Nota bene

The global state does not have only a partial ordering (it is a lattice).

It is only in the case when one operation depends on outputs of another (via global or owned state) there is a guarantee that the global state defined by the second operation will always follow the first one.

It is the responsibility of the codex developer to ensure non-ambiguity when this aggregator is used.

MapV2SetU(StateName)

Map from a field-based element state to a set of non-verifiable structured state; when the field-based element state repeats, the set is extended with the non-verifiable state.

The map is ordered according to the global state element order.

Acts only on a global state; doesn’t recognize aggregated state.

If the global state with the name is absent returns an empty map.

Nota bene

The global state does not have only a partial ordering (it is a lattice).

It is only in the case when one operation depends on outputs of another (via global or owned state) there is a guarantee that the global state defined by the second operation will always follow the first one.

It is the responsibility of the codex developer to ensure non-ambiguity when this aggregator is used.

SumUnwrap(StateName)

Sums over verifiable part of a global state.

Acts only on a global state; doesn’t recognize aggregated state.

Fails if the global state doesn’t have any elements, or if there is an overflow, or the state type is not an unsigned integer.

SumOrDefault(StateName)

Sums over verifiable part of a global state.

Acts only on a global state; doesn’t recognize aggregated state.

Produces zero f the global state doesn’t have any elements, or if there is an overflow.

If any of the elements of the global state are not an unsigner integer, treats them as zero.

ProdUnwrap(StateName)

Takes a product of the elements of a global state, taking their verifiable part.

Acts only on a global state; doesn’t recognize aggregated state.

Fails if the global state doesn’t have any elements, or if there is an overflow, or the state type is not an unsigned integer.

ProdOrDefault(StateName)

Takes a product of the elements of a global state, taking their verifiable part.

Acts only on a global state; doesn’t recognize aggregated state.

Produces zero f the global state doesn’t have any elements, or if there is an overflow.

If any of the elements of the global state are not an unsigner integer, treats them as one.

Implementations

impl SubAggregator

pub fn depends_on(&self) -> Vec<&StateName>

Returns names of the other computed state which this aggregator depends on and which needs to be computed before running this aggregator.

pub fn aggregate( &self, global: &BTreeMap<StateName, BTreeMap<CellAddr, StateAtom>>, aggregated: &BTreeMap<StateName, StrictVal>, types: &TypeSystem, ) -> Option<StrictVal>

Compute state via applying some aggregator function.

Returns

Aggregated state value. If the computing fails due to any exception, None.

Trait Implementations

impl Clone for SubAggregator

fn clone(&self) -> SubAggregator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SubAggregator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SubAggregator

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for SubAggregator

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 Ord for SubAggregator

fn cmp(&self, other: &SubAggregator) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SubAggregator

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

fn partial_cmp(&self, other: &SubAggregator) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for SubAggregator

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StrictDecode for SubAggregator

fn strict_decode(reader: &mut impl TypedRead) -> Result<Self, DecodeError>

fn strict_read(reader: impl ReadRaw) -> Result<Self, DecodeError>

impl StrictDumb for SubAggregator

fn strict_dumb() -> Self

impl StrictEncode for SubAggregator

fn strict_encode<W: TypedWrite>(&self, writer: W) -> Result<W>

fn strict_write(&self, writer: impl WriteRaw) -> Result<(), Error>

impl StrictSum for SubAggregator

const ALL_VARIANTS: &'static [(u8, &'static str)]

fn variant_name(&self) -> &'static str

fn strict_check_variants()

fn variant_name_by_tag(tag: u8) -> Option<VariantName>

fn variant_ord(&self) -> u8

impl StrictType for SubAggregator

const STRICT_LIB_NAME: &'static str = LIB_NAME_SONIC

fn strict_name() -> Option<TypeName>

impl StrictUnion for SubAggregator

fn strict_type_info() -> TypeInfo<Self>

impl Eq for SubAggregator

impl StructuralPartialEq for SubAggregator