mirror of
https://github.com/bitcoinresearchkit/brk.git
synced 2026-04-24 22:59:58 -07:00
brk: first commit
This commit is contained in:
nym21
887
_src/parser/datasets/_traits/any_dataset.rs
Normal file
887
_src/parser/datasets/_traits/any_dataset.rs
Normal file
@@ -0,0 +1,887 @@
|
||||
use itertools::Itertools;
|
||||
use rayon::prelude::*;
|
||||
use struct_iterable::Iterable;
|
||||
|
||||
use crate::{
|
||||
parser::datasets::{
|
||||
cohort_metadata::AddressCohortMetadataDataset, ComputeData, DateRecapDataset, RatioDataset,
|
||||
SubDataset,
|
||||
},
|
||||
structs::{
|
||||
AnyBiMap, AnyDateMap, AnyHeightMap, AnyMap, BiMap, Date, DateMap, Height, HeightMap,
|
||||
MapKind, Timestamp, OHLC,
|
||||
},
|
||||
};
|
||||
|
||||
use super::{AnyDatasetGroup, MinInitialStates};
|
||||
|
||||
pub trait AnyDataset: Iterable {
|
||||
fn get_min_initial_states(&self) -> &MinInitialStates;
|
||||
|
||||
fn needs_insert(&self, height: Height, date: Date) -> bool {
|
||||
self.needs_insert_height(height) || self.needs_insert_date(date)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn needs_insert_height(&self, height: Height) -> bool {
|
||||
!self.to_all_inserted_height_map_vec().is_empty()
|
||||
&& self
|
||||
.get_min_initial_states()
|
||||
.inserted
|
||||
.first_unsafe_height
|
||||
.unwrap_or(Height::ZERO)
|
||||
<= height
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn needs_insert_date(&self, date: Date) -> bool {
|
||||
!self.to_all_inserted_date_map_vec().is_empty()
|
||||
&& self
|
||||
.get_min_initial_states()
|
||||
.inserted
|
||||
.first_unsafe_date
|
||||
.map_or(true, |min_initial_first_unsafe_date| {
|
||||
min_initial_first_unsafe_date <= date
|
||||
})
|
||||
}
|
||||
|
||||
fn to_kind_bi_map_vec(&self, kind: MapKind) -> Vec<&(dyn AnyBiMap + Send + Sync)> {
|
||||
let mut v = vec![];
|
||||
|
||||
self.iter().for_each(|(_, any)| {
|
||||
if let Some(map) = any.downcast_ref::<BiMap<u8>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<u16>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<u32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<u64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<usize>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<f32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<f64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<OHLC>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<Date>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<Height>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<BiMap<Timestamp>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyBiMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(dataset) = any.downcast_ref::<RatioDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_bi_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_bi_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
} else if let Some(dataset) = any.downcast_ref::<AddressCohortMetadataDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_bi_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_bi_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
} else if let Some(dataset) = any.downcast_ref::<SubDataset>() {
|
||||
dataset.as_vec().into_iter().for_each(|dataset| {
|
||||
v.append(&mut dataset.to_kind_bi_map_vec(kind));
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
v
|
||||
}
|
||||
|
||||
fn to_kind_mut_bi_map_vec(&mut self, kind: MapKind) -> Vec<&mut dyn AnyBiMap> {
|
||||
let mut v = vec![];
|
||||
|
||||
self.iter_mut().for_each(|(_, any)| match any {
|
||||
any if any.is::<BiMap<u8>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<u8>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<u16>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<u16>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<u32>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<u32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<u64>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<u64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<usize>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<usize>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<f32>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<f32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<f64>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<f64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<OHLC>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<OHLC>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<Date>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<Date>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<Height>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<Height>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<BiMap<Timestamp>>() => {
|
||||
if let Some(map) = any.downcast_mut::<BiMap<Timestamp>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyBiMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<RatioDataset>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<RatioDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_mut_bi_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_mut_bi_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
}
|
||||
}
|
||||
any if any.is::<AddressCohortMetadataDataset>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<AddressCohortMetadataDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_mut_bi_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_mut_bi_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
}
|
||||
}
|
||||
any if any.is::<SubDataset>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<SubDataset>() {
|
||||
dataset.as_mut_vec().into_iter().for_each(|dataset| {
|
||||
v.append(&mut dataset.to_kind_mut_bi_map_vec(kind));
|
||||
});
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
});
|
||||
|
||||
v
|
||||
}
|
||||
|
||||
fn to_kind_date_map_vec(&self, kind: MapKind) -> Vec<&(dyn AnyDateMap + Send + Sync)> {
|
||||
let mut v = vec![];
|
||||
|
||||
self.iter().for_each(|(_, any)| {
|
||||
if let Some(map) = any.downcast_ref::<DateMap<u8>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<u16>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<u32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<u64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<usize>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<f32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<f64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<OHLC>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<Date>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<Height>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<DateMap<Timestamp>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(dataset) = any.downcast_ref::<DateRecapDataset<u32>>() {
|
||||
dataset.as_vec().into_iter().for_each(|map| {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
});
|
||||
} else if let Some(dataset) = any.downcast_ref::<DateRecapDataset<u64>>() {
|
||||
dataset.as_vec().into_iter().for_each(|map| {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
});
|
||||
} else if let Some(dataset) = any.downcast_ref::<DateRecapDataset<f32>>() {
|
||||
dataset.as_vec().into_iter().for_each(|map| {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyDateMap + Send + Sync))
|
||||
}
|
||||
});
|
||||
} else if let Some(dataset) = any.downcast_ref::<SubDataset>() {
|
||||
dataset.as_vec().into_iter().for_each(|dataset| {
|
||||
v.append(&mut dataset.to_kind_date_map_vec(kind));
|
||||
});
|
||||
} else if let Some(dataset) = any.downcast_ref::<AddressCohortMetadataDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_date_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_date_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
v
|
||||
}
|
||||
|
||||
fn to_kind_mut_date_map_vec(&mut self, kind: MapKind) -> Vec<&mut dyn AnyDateMap> {
|
||||
let mut v = vec![];
|
||||
|
||||
self.iter_mut().for_each(|(_, any)| match any {
|
||||
any if any.is::<DateMap<u8>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<u8>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<u16>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<u16>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<u32>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<u32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<u64>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<u64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<usize>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<usize>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<f32>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<f32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<f64>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<f64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<OHLC>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<OHLC>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<Date>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<Date>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<Height>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<Height>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateMap<Timestamp>>() => {
|
||||
if let Some(map) = any.downcast_mut::<DateMap<Timestamp>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<DateRecapDataset<u32>>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<DateRecapDataset<u32>>() {
|
||||
dataset.as_mut_vec().into_iter().for_each(|map| {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
any if any.is::<DateRecapDataset<u64>>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<DateRecapDataset<u64>>() {
|
||||
dataset.as_mut_vec().into_iter().for_each(|map| {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
any if any.is::<DateRecapDataset<f32>>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<DateRecapDataset<f32>>() {
|
||||
dataset.as_mut_vec().into_iter().for_each(|map| {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyDateMap);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
any if any.is::<SubDataset>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<SubDataset>() {
|
||||
dataset.as_mut_vec().into_iter().for_each(|dataset| {
|
||||
v.append(&mut dataset.to_kind_mut_date_map_vec(kind));
|
||||
});
|
||||
}
|
||||
}
|
||||
any if any.is::<AddressCohortMetadataDataset>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<AddressCohortMetadataDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_mut_date_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_mut_date_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
});
|
||||
|
||||
v
|
||||
}
|
||||
|
||||
fn to_kind_height_map_vec(&self, kind: MapKind) -> Vec<&(dyn AnyHeightMap + Send + Sync)> {
|
||||
let mut v = vec![];
|
||||
|
||||
self.iter().for_each(|(_, any)| {
|
||||
if let Some(map) = any.downcast_ref::<HeightMap<u8>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<u16>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<u32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<u64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<usize>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<f32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<f64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<OHLC>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<Date>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<Height>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(map) = any.downcast_ref::<HeightMap<Timestamp>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &(dyn AnyHeightMap + Send + Sync))
|
||||
}
|
||||
} else if let Some(dataset) = any.downcast_ref::<SubDataset>() {
|
||||
dataset.as_vec().into_iter().for_each(|dataset| {
|
||||
v.append(&mut dataset.to_kind_height_map_vec(kind));
|
||||
});
|
||||
} else if let Some(dataset) = any.downcast_ref::<AddressCohortMetadataDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_height_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_height_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
v
|
||||
}
|
||||
|
||||
fn to_kind_mut_height_map_vec(&mut self, kind: MapKind) -> Vec<&mut dyn AnyHeightMap> {
|
||||
let mut v = vec![];
|
||||
|
||||
self.iter_mut().for_each(|(_, any)| match any {
|
||||
any if any.is::<HeightMap<u8>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<u8>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<u16>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<u16>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<u32>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<u32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<u64>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<u64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<usize>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<usize>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<f32>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<f32>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<f64>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<f64>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<OHLC>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<OHLC>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<Date>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<Date>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<Height>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<Height>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<HeightMap<Timestamp>>() => {
|
||||
if let Some(map) = any.downcast_mut::<HeightMap<Timestamp>>() {
|
||||
if map.kind() == kind {
|
||||
v.push(map as &mut dyn AnyHeightMap);
|
||||
}
|
||||
}
|
||||
}
|
||||
any if any.is::<SubDataset>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<SubDataset>() {
|
||||
dataset.as_mut_vec().into_iter().for_each(|dataset| {
|
||||
v.append(&mut dataset.to_kind_mut_height_map_vec(kind));
|
||||
});
|
||||
}
|
||||
}
|
||||
any if any.is::<AddressCohortMetadataDataset>() => {
|
||||
if let Some(dataset) = any.downcast_mut::<AddressCohortMetadataDataset>() {
|
||||
match kind {
|
||||
MapKind::Inserted => dataset.to_inserted_mut_height_map_vec(),
|
||||
MapKind::Computed => dataset.to_computed_mut_height_map_vec(),
|
||||
}
|
||||
.into_iter()
|
||||
.for_each(|map| {
|
||||
v.push(map);
|
||||
});
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
});
|
||||
|
||||
v
|
||||
}
|
||||
|
||||
fn to_inserted_bi_map_vec(&self) -> Vec<&(dyn AnyBiMap + Send + Sync)> {
|
||||
self.to_kind_bi_map_vec(MapKind::Inserted)
|
||||
}
|
||||
|
||||
fn to_inserted_height_map_vec(&self) -> Vec<&(dyn AnyHeightMap + Send + Sync)> {
|
||||
self.to_kind_height_map_vec(MapKind::Inserted)
|
||||
}
|
||||
|
||||
fn to_inserted_date_map_vec(&self) -> Vec<&(dyn AnyDateMap + Send + Sync)> {
|
||||
self.to_kind_date_map_vec(MapKind::Inserted)
|
||||
}
|
||||
|
||||
fn to_inserted_mut_bi_map_vec(&mut self) -> Vec<&mut dyn AnyBiMap> {
|
||||
self.to_kind_mut_bi_map_vec(MapKind::Inserted)
|
||||
}
|
||||
|
||||
fn to_inserted_mut_height_map_vec(&mut self) -> Vec<&mut dyn AnyHeightMap> {
|
||||
self.to_kind_mut_height_map_vec(MapKind::Inserted)
|
||||
}
|
||||
|
||||
fn to_inserted_mut_date_map_vec(&mut self) -> Vec<&mut dyn AnyDateMap> {
|
||||
self.to_kind_mut_date_map_vec(MapKind::Inserted)
|
||||
}
|
||||
|
||||
fn to_all_inserted_height_map_vec(&self) -> Vec<&(dyn AnyHeightMap + Send + Sync)> {
|
||||
let mut vec = self.to_inserted_height_map_vec();
|
||||
|
||||
vec.append(
|
||||
&mut self
|
||||
.to_inserted_bi_map_vec()
|
||||
.iter()
|
||||
.map(|bi| bi.get_height())
|
||||
.collect_vec(),
|
||||
);
|
||||
|
||||
vec
|
||||
}
|
||||
|
||||
fn to_all_inserted_date_map_vec(&self) -> Vec<&(dyn AnyDateMap + Send + Sync)> {
|
||||
let mut vec = self.to_inserted_date_map_vec();
|
||||
|
||||
vec.append(
|
||||
&mut self
|
||||
.to_inserted_bi_map_vec()
|
||||
.iter()
|
||||
.map(|bi| bi.get_date())
|
||||
.collect_vec(),
|
||||
);
|
||||
|
||||
vec
|
||||
}
|
||||
|
||||
fn to_all_inserted_map_vec(&self) -> Vec<&(dyn AnyMap + Send + Sync)> {
|
||||
let heights = self
|
||||
.to_all_inserted_height_map_vec()
|
||||
.into_iter()
|
||||
.map(|d| d.as_any_map());
|
||||
|
||||
let dates = self
|
||||
.to_all_inserted_date_map_vec()
|
||||
.into_iter()
|
||||
.map(|d| d.as_any_map());
|
||||
|
||||
heights.chain(dates).collect_vec()
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn should_compute(&self, compute_data: &ComputeData) -> bool {
|
||||
compute_data
|
||||
.heights
|
||||
.last()
|
||||
.map_or(false, |height| self.should_compute_height(*height))
|
||||
|| compute_data
|
||||
.dates
|
||||
.last()
|
||||
.map_or(false, |date| self.should_compute_date(*date))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn should_compute_height(&self, height: Height) -> bool {
|
||||
!self.to_all_computed_height_map_vec().is_empty()
|
||||
&& self
|
||||
.get_min_initial_states()
|
||||
.computed
|
||||
.first_unsafe_height
|
||||
.unwrap_or(Height::ZERO)
|
||||
<= height
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn should_compute_date(&self, date: Date) -> bool {
|
||||
!self.to_all_computed_date_map_vec().is_empty()
|
||||
&& self
|
||||
.get_min_initial_states()
|
||||
.computed
|
||||
.first_unsafe_date
|
||||
.map_or(true, |min_initial_first_unsafe_date| {
|
||||
min_initial_first_unsafe_date <= date
|
||||
})
|
||||
}
|
||||
|
||||
fn to_computed_bi_map_vec(&self) -> Vec<&(dyn AnyBiMap + Send + Sync)> {
|
||||
self.to_kind_bi_map_vec(MapKind::Computed)
|
||||
}
|
||||
|
||||
fn to_computed_height_map_vec(&self) -> Vec<&(dyn AnyHeightMap + Send + Sync)> {
|
||||
self.to_kind_height_map_vec(MapKind::Computed)
|
||||
}
|
||||
|
||||
fn to_computed_date_map_vec(&self) -> Vec<&(dyn AnyDateMap + Send + Sync)> {
|
||||
self.to_kind_date_map_vec(MapKind::Computed)
|
||||
}
|
||||
|
||||
fn to_computed_mut_bi_map_vec(&mut self) -> Vec<&mut dyn AnyBiMap> {
|
||||
self.to_kind_mut_bi_map_vec(MapKind::Computed)
|
||||
}
|
||||
|
||||
fn to_computed_mut_height_map_vec(&mut self) -> Vec<&mut dyn AnyHeightMap> {
|
||||
self.to_kind_mut_height_map_vec(MapKind::Computed)
|
||||
}
|
||||
|
||||
fn to_computed_mut_date_map_vec(&mut self) -> Vec<&mut dyn AnyDateMap> {
|
||||
self.to_kind_mut_date_map_vec(MapKind::Computed)
|
||||
}
|
||||
|
||||
fn to_all_computed_height_map_vec(&self) -> Vec<&(dyn AnyHeightMap + Send + Sync)> {
|
||||
let mut vec = self.to_computed_height_map_vec();
|
||||
|
||||
vec.append(
|
||||
&mut self
|
||||
.to_computed_bi_map_vec()
|
||||
.iter()
|
||||
.map(|bi| bi.get_height())
|
||||
.collect_vec(),
|
||||
);
|
||||
|
||||
vec
|
||||
}
|
||||
|
||||
fn to_all_computed_date_map_vec(&self) -> Vec<&(dyn AnyDateMap + Send + Sync)> {
|
||||
let mut vec = self.to_computed_date_map_vec();
|
||||
|
||||
vec.append(
|
||||
&mut self
|
||||
.to_computed_bi_map_vec()
|
||||
.iter()
|
||||
.map(|bi| bi.get_date())
|
||||
.collect_vec(),
|
||||
);
|
||||
|
||||
vec
|
||||
}
|
||||
|
||||
fn to_all_computed_map_vec(&self) -> Vec<&(dyn AnyMap + Send + Sync)> {
|
||||
let heights = self
|
||||
.to_all_computed_height_map_vec()
|
||||
.into_iter()
|
||||
.map(|d| d.as_any_map());
|
||||
|
||||
let dates = self
|
||||
.to_all_computed_date_map_vec()
|
||||
.into_iter()
|
||||
.map(|d| d.as_any_map());
|
||||
|
||||
heights.chain(dates).collect_vec()
|
||||
}
|
||||
|
||||
fn to_all_map_vec(&self) -> Vec<&(dyn AnyMap + Send + Sync)> {
|
||||
let mut inserted = self.to_all_inserted_map_vec();
|
||||
|
||||
inserted.append(&mut self.to_all_computed_map_vec());
|
||||
|
||||
inserted
|
||||
}
|
||||
|
||||
// #[inline(always)]
|
||||
// fn is_empty(&self) -> bool {
|
||||
// self.to_any_map_vec().is_empty()
|
||||
// }
|
||||
|
||||
fn pre_export(&mut self) {
|
||||
self.to_inserted_mut_height_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.pre_export());
|
||||
|
||||
self.to_inserted_mut_date_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.pre_export());
|
||||
|
||||
self.to_inserted_mut_bi_map_vec().into_iter().for_each(|d| {
|
||||
d.as_any_mut_map()
|
||||
.into_iter()
|
||||
.for_each(|map| map.pre_export())
|
||||
});
|
||||
|
||||
self.to_computed_mut_height_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.pre_export());
|
||||
|
||||
self.to_computed_mut_date_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.pre_export());
|
||||
|
||||
self.to_computed_mut_bi_map_vec().into_iter().for_each(|d| {
|
||||
d.as_any_mut_map()
|
||||
.into_iter()
|
||||
.for_each(|map| map.pre_export())
|
||||
});
|
||||
}
|
||||
|
||||
fn export(&self) -> color_eyre::Result<()> {
|
||||
self.to_all_map_vec()
|
||||
.into_par_iter()
|
||||
.try_for_each(|map| -> color_eyre::Result<()> { map.export() })
|
||||
}
|
||||
|
||||
fn post_export(&mut self) {
|
||||
self.to_inserted_mut_height_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.post_export());
|
||||
|
||||
self.to_inserted_mut_date_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.post_export());
|
||||
|
||||
self.to_inserted_mut_bi_map_vec().into_iter().for_each(|d| {
|
||||
d.as_any_mut_map()
|
||||
.into_iter()
|
||||
.for_each(|map| map.post_export())
|
||||
});
|
||||
|
||||
self.to_computed_mut_height_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.post_export());
|
||||
|
||||
self.to_computed_mut_date_map_vec()
|
||||
.into_iter()
|
||||
.for_each(|map| map.post_export());
|
||||
|
||||
self.to_computed_mut_bi_map_vec().into_iter().for_each(|d| {
|
||||
d.as_any_mut_map()
|
||||
.into_iter()
|
||||
.for_each(|map| map.post_export())
|
||||
});
|
||||
}
|
||||
|
||||
fn reset_computed(&self) {
|
||||
self.to_all_computed_date_map_vec()
|
||||
.iter()
|
||||
.for_each(|map| map.delete_files());
|
||||
self.to_all_computed_height_map_vec()
|
||||
.iter()
|
||||
.for_each(|map| map.delete_files());
|
||||
}
|
||||
}
|
||||
7
_src/parser/datasets/_traits/any_dataset_group.rs
Normal file
7
_src/parser/datasets/_traits/any_dataset_group.rs
Normal file
@@ -0,0 +1,7 @@
|
||||
use super::AnyDataset;
|
||||
|
||||
pub trait AnyDatasetGroup {
|
||||
fn as_vec(&self) -> Vec<&(dyn AnyDataset + Send + Sync)>;
|
||||
|
||||
fn as_mut_vec(&mut self) -> Vec<&mut dyn AnyDataset>;
|
||||
}
|
||||
9
_src/parser/datasets/_traits/any_datasets.rs
Normal file
9
_src/parser/datasets/_traits/any_datasets.rs
Normal file
@@ -0,0 +1,9 @@
|
||||
use super::{AnyDataset, MinInitialStates};
|
||||
|
||||
pub trait AnyDatasets {
|
||||
fn get_min_initial_states(&self) -> &MinInitialStates;
|
||||
|
||||
fn to_any_dataset_vec(&self) -> Vec<&(dyn AnyDataset + Send + Sync)>;
|
||||
|
||||
fn to_mut_any_dataset_vec(&mut self) -> Vec<&mut dyn AnyDataset>;
|
||||
}
|
||||
279
_src/parser/datasets/_traits/min_initial_state.rs
Normal file
279
_src/parser/datasets/_traits/min_initial_state.rs
Normal file
@@ -0,0 +1,279 @@
|
||||
use allocative::Allocative;
|
||||
|
||||
use crate::structs::{AnyDateMap, AnyHeightMap, Config, Date, Height};
|
||||
|
||||
use super::{AnyDataset, AnyDatasets};
|
||||
|
||||
#[derive(Default, Debug, Clone, Copy, Allocative)]
|
||||
pub struct MinInitialStates {
|
||||
pub inserted: MinInitialState,
|
||||
pub computed: MinInitialState,
|
||||
}
|
||||
|
||||
impl MinInitialStates {
|
||||
pub fn consume(&mut self, other: Self) {
|
||||
self.inserted = other.inserted;
|
||||
self.computed = other.computed;
|
||||
}
|
||||
|
||||
pub fn compute_from_dataset(dataset: &dyn AnyDataset, config: &Config) -> Self {
|
||||
Self {
|
||||
inserted: MinInitialState::compute_from_dataset(dataset, Mode::Inserted, config),
|
||||
computed: MinInitialState::compute_from_dataset(dataset, Mode::Computed, config),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn compute_from_datasets(datasets: &dyn AnyDatasets, config: &Config) -> Self {
|
||||
Self {
|
||||
inserted: MinInitialState::compute_from_datasets(datasets, Mode::Inserted, config),
|
||||
computed: MinInitialState::compute_from_datasets(datasets, Mode::Computed, config),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn min_last_height(&self) -> Option<Height> {
|
||||
self.computed.last_height.min(self.inserted.last_height)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default, Debug, Clone, Copy, Allocative)]
|
||||
pub struct MinInitialState {
|
||||
pub first_unsafe_date: Option<Date>,
|
||||
pub first_unsafe_height: Option<Height>,
|
||||
pub last_date: Option<Date>,
|
||||
pub last_height: Option<Height>,
|
||||
}
|
||||
|
||||
enum Mode {
|
||||
Inserted,
|
||||
Computed,
|
||||
}
|
||||
|
||||
impl MinInitialState {
|
||||
fn compute_from_datasets(datasets: &dyn AnyDatasets, mode: Mode, config: &Config) -> Self {
|
||||
match mode {
|
||||
Mode::Inserted => {
|
||||
let contains_date_maps = |dataset: &&(dyn AnyDataset + Sync + Send)| {
|
||||
!dataset.to_all_inserted_date_map_vec().is_empty()
|
||||
};
|
||||
|
||||
let contains_height_maps = |dataset: &&(dyn AnyDataset + Sync + Send)| {
|
||||
!dataset.to_all_inserted_height_map_vec().is_empty()
|
||||
};
|
||||
|
||||
Self {
|
||||
first_unsafe_date: Self::min_datasets_date(
|
||||
datasets,
|
||||
contains_date_maps,
|
||||
|dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.inserted
|
||||
.first_unsafe_date
|
||||
.as_ref()
|
||||
.cloned()
|
||||
},
|
||||
),
|
||||
first_unsafe_height: Self::min_datasets_height(
|
||||
datasets,
|
||||
contains_height_maps,
|
||||
|dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.inserted
|
||||
.first_unsafe_height
|
||||
.as_ref()
|
||||
.cloned()
|
||||
},
|
||||
),
|
||||
last_date: Self::min_datasets_date(datasets, contains_date_maps, |dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.inserted
|
||||
.last_date
|
||||
.as_ref()
|
||||
.cloned()
|
||||
}),
|
||||
last_height: Self::min_datasets_height(
|
||||
datasets,
|
||||
contains_height_maps,
|
||||
|dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.inserted
|
||||
.last_height
|
||||
.as_ref()
|
||||
.cloned()
|
||||
},
|
||||
),
|
||||
}
|
||||
}
|
||||
Mode::Computed => {
|
||||
if config.recompute_computed() {
|
||||
// datasets.reset_computed();
|
||||
return Self::default();
|
||||
}
|
||||
|
||||
let contains_date_maps = |dataset: &&(dyn AnyDataset + Sync + Send)| {
|
||||
!dataset.to_all_computed_date_map_vec().is_empty()
|
||||
};
|
||||
|
||||
let contains_height_maps = |dataset: &&(dyn AnyDataset + Sync + Send)| {
|
||||
!dataset.to_all_computed_height_map_vec().is_empty()
|
||||
};
|
||||
|
||||
Self {
|
||||
first_unsafe_date: Self::min_datasets_date(
|
||||
datasets,
|
||||
contains_date_maps,
|
||||
|dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.computed
|
||||
.first_unsafe_date
|
||||
.as_ref()
|
||||
.cloned()
|
||||
},
|
||||
),
|
||||
first_unsafe_height: Self::min_datasets_height(
|
||||
datasets,
|
||||
contains_height_maps,
|
||||
|dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.computed
|
||||
.first_unsafe_height
|
||||
.as_ref()
|
||||
.cloned()
|
||||
},
|
||||
),
|
||||
last_date: Self::min_datasets_date(datasets, contains_date_maps, |dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.computed
|
||||
.last_date
|
||||
.as_ref()
|
||||
.cloned()
|
||||
}),
|
||||
last_height: Self::min_datasets_height(
|
||||
datasets,
|
||||
contains_height_maps,
|
||||
|dataset| {
|
||||
dataset
|
||||
.get_min_initial_states()
|
||||
.computed
|
||||
.last_height
|
||||
.as_ref()
|
||||
.cloned()
|
||||
},
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn min_datasets_date(
|
||||
datasets: &dyn AnyDatasets,
|
||||
is_not_empty: impl Fn(&&(dyn AnyDataset + Sync + Send)) -> bool,
|
||||
map: impl Fn(&(dyn AnyDataset + Sync + Send)) -> Option<Date>,
|
||||
) -> Option<Date> {
|
||||
Self::min_date(
|
||||
datasets
|
||||
.to_any_dataset_vec()
|
||||
.into_iter()
|
||||
.filter(is_not_empty)
|
||||
.map(map),
|
||||
)
|
||||
}
|
||||
|
||||
fn min_datasets_height(
|
||||
datasets: &dyn AnyDatasets,
|
||||
is_not_empty: impl Fn(&&(dyn AnyDataset + Sync + Send)) -> bool,
|
||||
map: impl Fn(&(dyn AnyDataset + Sync + Send)) -> Option<Height>,
|
||||
) -> Option<Height> {
|
||||
Self::min_height(
|
||||
datasets
|
||||
.to_any_dataset_vec()
|
||||
.into_iter()
|
||||
.filter(is_not_empty)
|
||||
.map(map),
|
||||
)
|
||||
}
|
||||
|
||||
fn compute_from_dataset(dataset: &dyn AnyDataset, mode: Mode, config: &Config) -> Self {
|
||||
match mode {
|
||||
Mode::Inserted => {
|
||||
let date_vec = dataset.to_all_inserted_date_map_vec();
|
||||
let height_vec = dataset.to_all_inserted_height_map_vec();
|
||||
|
||||
Self {
|
||||
first_unsafe_date: Self::compute_min_initial_first_unsafe_date_from_dataset(
|
||||
&date_vec,
|
||||
),
|
||||
first_unsafe_height: Self::compute_min_initial_first_unsafe_height_from_dataset(
|
||||
&height_vec,
|
||||
),
|
||||
last_date: Self::compute_min_initial_last_date_from_dataset(&date_vec),
|
||||
last_height: Self::compute_min_initial_last_height_from_dataset(&height_vec),
|
||||
}
|
||||
}
|
||||
Mode::Computed => {
|
||||
if config.recompute_computed() {
|
||||
dataset.reset_computed();
|
||||
return Self::default();
|
||||
}
|
||||
|
||||
let date_vec = dataset.to_all_computed_date_map_vec();
|
||||
let height_vec = dataset.to_all_computed_height_map_vec();
|
||||
|
||||
Self {
|
||||
first_unsafe_date: Self::compute_min_initial_first_unsafe_date_from_dataset(
|
||||
&date_vec,
|
||||
),
|
||||
first_unsafe_height: Self::compute_min_initial_first_unsafe_height_from_dataset(
|
||||
&height_vec,
|
||||
),
|
||||
last_date: Self::compute_min_initial_last_date_from_dataset(&date_vec),
|
||||
last_height: Self::compute_min_initial_last_height_from_dataset(&height_vec),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn compute_min_initial_last_date_from_dataset(
|
||||
arr: &[&(dyn AnyDateMap + Sync + Send)],
|
||||
) -> Option<Date> {
|
||||
Self::min_date(arr.iter().map(|map| map.get_initial_last_date()))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn compute_min_initial_last_height_from_dataset(
|
||||
arr: &[&(dyn AnyHeightMap + Sync + Send)],
|
||||
) -> Option<Height> {
|
||||
Self::min_height(arr.iter().map(|map| map.get_initial_last_height()))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn compute_min_initial_first_unsafe_date_from_dataset(
|
||||
arr: &[&(dyn AnyDateMap + Sync + Send)],
|
||||
) -> Option<Date> {
|
||||
Self::min_date(arr.iter().map(|map| map.get_initial_first_unsafe_date()))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn compute_min_initial_first_unsafe_height_from_dataset(
|
||||
arr: &[&(dyn AnyHeightMap + Sync + Send)],
|
||||
) -> Option<Height> {
|
||||
Self::min_height(arr.iter().map(|map| map.get_initial_first_unsafe_height()))
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn min_date(iter: impl Iterator<Item = Option<Date>>) -> Option<Date> {
|
||||
iter.min().and_then(|opt| opt)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn min_height(iter: impl Iterator<Item = Option<Height>>) -> Option<Height> {
|
||||
iter.min().and_then(|opt| opt)
|
||||
}
|
||||
}
|
||||
9
_src/parser/datasets/_traits/mod.rs
Normal file
9
_src/parser/datasets/_traits/mod.rs
Normal file
@@ -0,0 +1,9 @@
|
||||
mod any_dataset;
|
||||
mod any_dataset_group;
|
||||
mod any_datasets;
|
||||
mod min_initial_state;
|
||||
|
||||
pub use any_dataset::*;
|
||||
pub use any_dataset_group::*;
|
||||
pub use any_datasets::*;
|
||||
pub use min_initial_state::*;
|
||||
Reference in New Issue
Block a user