reifydb-flow 0.9.0

Flow execution substrate: the flow transaction/state layer and the operator contract
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 ReifyDB

use std::{
	cmp::Ordering,
	hash::{Hash, Hasher},
};

use reifydb_core::metrics::heap::HeapSize;
use reifydb_macro::operator_state;

#[operator_state]
#[derive(Debug, Clone, Copy)]
pub struct OrdF64(f64);

impl OrdF64 {
	#[inline]
	pub fn new(value: f64) -> Option<Self> {
		(!value.is_nan()).then_some(Self(value))
	}

	#[inline]
	pub fn get(self) -> f64 {
		self.0
	}
}

impl PartialEq for OrdF64 {
	#[inline]
	fn eq(&self, other: &Self) -> bool {
		self.0.total_cmp(&other.0) == Ordering::Equal
	}
}

impl Eq for OrdF64 {}

impl PartialOrd for OrdF64 {
	#[inline]
	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
		Some(self.cmp(other))
	}
}

impl Ord for OrdF64 {
	#[inline]
	fn cmp(&self, other: &Self) -> Ordering {
		self.0.total_cmp(&other.0)
	}
}

impl Hash for OrdF64 {
	#[inline]
	fn hash<H: Hasher>(&self, state: &mut H) {
		self.0.to_bits().hash(state);
	}
}

impl HeapSize for OrdF64 {
	fn heap_size(&self) -> usize {
		0
	}
}

#[cfg(test)]
mod tests {
	use super::*;
	use crate::window::accumulator::{invertible::multiset::Multiset, testkit::of64};

	#[test]
	fn ordf64_total_order_and_nan_rejection() {
		assert!(OrdF64::new(f64::NAN).is_none());
		assert!(of64(-1.0) < of64(0.0));
		assert!(of64(0.0) < of64(1.0));
		let mut ms: Multiset<OrdF64> = Multiset::default();
		ms.add(of64(2.5));
		ms.add(of64(-3.0));
		ms.add(of64(2.5));
		assert_eq!(ms.min(), Some(&of64(-3.0)));
		assert_eq!(ms.max(), Some(&of64(2.5)));
		assert_eq!(ms.total(), 3);
	}
}