dbsp 0.287.0

Continuous streaming analytics engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use crate::{
    DBWeight,
    algebra::{AddAssignByRef, AddByRef, HasZero},
    declare_trait_object, declare_typed_trait_object,
    dynamic::data::DataTyped,
};

use super::{Data, DataTrait, DataTraitTyped};

/// A trait for types that can be used as weights in DBSP.
///
/// Such types must implement the plus operation and have a neutral element wrt addition (zero).
pub trait Weight: Data {
    /// Set the weight to zero.
    fn set_zero(&mut self);

    /// Check if the weight is zero.
    fn is_zero(&self) -> bool;

    /// Add the value of `rhs` to `self`, store the result in `result`.
    ///
    /// # Safety
    ///
    /// `rhs` and `result` must be valid pointers to values of type `Self`.
    unsafe fn raw_add(&self, rhs: *const u8, result: *mut u8);

    /// Add the value of `rhs` to `self`, store the result in `self`.
    ///
    /// # Safety
    ///
    /// `rhs` must be a valid pointer to a value of type `Self`
    unsafe fn raw_add_assign(&mut self, rhs: *const u8);
}

impl<T: DBWeight> Weight for T {
    fn set_zero(&mut self) {
        *self = HasZero::zero();
    }

    fn is_zero(&self) -> bool {
        HasZero::is_zero(self)
    }

    unsafe fn raw_add(&self, rhs: *const u8, result: *mut u8) {
        unsafe { *(result as *mut Self) = AddByRef::add_by_ref(self, &*(rhs as *const Self)) }
    }

    unsafe fn raw_add_assign(&mut self, rhs: *const u8) {
        unsafe { AddAssignByRef::add_assign_by_ref(self, &*(rhs as *const Self)) }
    }
}

/// Strongly typed weight.
///
/// A trait that includes the concrete weight type in its type signature.
/// See [`WeightTraitTyped`].
pub trait WeightTyped: Weight + DataTyped {}

impl<T> WeightTyped for T where T: Weight + DataTyped {}

/// A trait for trait objects that represent weights.
pub trait WeightTrait: DataTrait + Weight {
    /// Add `rhs` to `self` and store the result in `result`.
    fn add(&self, rhs: &Self, result: &mut Self) {
        debug_assert_eq!(self.as_any().type_id(), rhs.as_any().type_id());
        debug_assert_eq!(self.as_any().type_id(), result.as_any().type_id());

        unsafe {
            Weight::raw_add(
                self,
                rhs as *const Self as *const u8,
                result as *mut Self as *mut u8,
            )
        }
    }

    /// Add `rhs` to `self`, store the result in `self`.
    fn add_assign(&mut self, rhs: &Self) {
        debug_assert_eq!(self.as_any().type_id(), rhs.as_any().type_id());

        unsafe { Weight::raw_add_assign(self, rhs as *const Self as *const u8) }
    }
}

impl<Trait: ?Sized> WeightTrait for Trait where Trait: DataTrait + Weight {}

/// A trait for trait objects that include the concrete weight type in
/// their type signatures.
///
/// Such trait objects can be dereferenced into their concrete types.
///
/// See [`DynZWeight`](`crate::DynZWeight`) for an example of such a trait object.
pub trait WeightTraitTyped: WeightTrait + DataTraitTyped {}

impl<Trait: ?Sized> WeightTraitTyped for Trait where Trait: WeightTrait + DataTraitTyped {}

declare_trait_object!(DynWeight<> = dyn Weight<>
where
);

declare_typed_trait_object!(DynWeightTyped<T> = dyn WeightTyped<Type = T>
    [T]
where
    T: DBWeight,
);