Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-04-25 15:19:58 -07:00
Code Issues Packages Projects Releases Wiki Activity

computer: convert vecs functions to iterators

Browse Source
This commit is contained in:
nym21
2025-09-10 16:25:38 +02:00
parent dfa077a1c9
commit 9b92c5ce38
47 changed files with 2037 additions and 1330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
crates/brk_computer/src/chain.rs
View File

@@ -903,8 +903,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -1647,9 +1646,9 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
vec![
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_interval as &dyn AnyCollectableVec,
&self.height_to_vbytes,
&self.difficultyepoch_to_timestamp,
@@ -1671,60 +1670,74 @@ impl Vecs {
&self.semesterindex_to_block_count_target,
&self.yearindex_to_block_count_target,
&self.decadeindex_to_block_count_target,
],
self.indexes_to_hash_rate.vecs(),
self.indexes_to_hash_rate_1w_sma.vecs(),
self.indexes_to_hash_rate_1m_sma.vecs(),
self.indexes_to_hash_rate_2m_sma.vecs(),
self.indexes_to_hash_rate_1y_sma.vecs(),
self.timeindexes_to_timestamp.vecs(),
self.indexes_to_block_count.vecs(),
self.indexes_to_1w_block_count.vecs(),
self.indexes_to_1m_block_count.vecs(),
self.indexes_to_1y_block_count.vecs(),
self.indexes_to_block_interval.vecs(),
self.indexes_to_block_size.vecs(),
self.indexes_to_block_vbytes.vecs(),
self.indexes_to_block_weight.vecs(),
self.indexes_to_difficulty.vecs(),
self.indexes_to_difficultyepoch.vecs(),
self.indexes_to_halvingepoch.vecs(),
self.indexes_to_coinbase.vecs(),
self.indexes_to_emptyoutput_count.vecs(),
self.indexes_to_fee.vecs(),
self.indexes_to_fee_rate.vecs(),
self.indexes_to_input_count.vecs(),
self.indexes_to_opreturn_count.vecs(),
self.indexes_to_output_count.vecs(),
self.indexes_to_p2a_count.vecs(),
self.indexes_to_p2ms_count.vecs(),
self.indexes_to_p2pk33_count.vecs(),
self.indexes_to_p2pk65_count.vecs(),
self.indexes_to_difficulty_as_hash.vecs(),
self.indexes_to_p2pkh_count.vecs(),
self.indexes_to_p2sh_count.vecs(),
self.indexes_to_p2tr_count.vecs(),
self.indexes_to_p2wpkh_count.vecs(),
self.indexes_to_p2wsh_count.vecs(),
self.indexes_to_subsidy.vecs(),
self.indexes_to_tx_count.vecs(),
self.indexes_to_tx_v1.vecs(),
self.indexes_to_tx_v2.vecs(),
self.indexes_to_tx_v3.vecs(),
self.indexes_to_tx_vsize.vecs(),
self.indexes_to_tx_weight.vecs(),
self.indexes_to_unknownoutput_count.vecs(),
self.indexes_to_exact_utxo_count.vecs(),
self.indexes_to_unclaimed_rewards.vecs(),
self.indexes_to_subsidy_usd_1y_sma
.as_ref()
.map_or(vec![], |v| v.vecs()),
self.indexes_to_puell_multiple
.as_ref()
.map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
]
.into_iter(),
);
iter = Box::new(iter.chain(self.indexes_to_hash_rate.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_1w_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_1m_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_2m_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_rate_1y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_timestamp.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_block_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_interval.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_size.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_vbytes.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_block_weight.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficulty.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficultyepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_halvingepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficulty_as_hash.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coinbase.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_fee.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_fee_rate.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_v1.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_v2.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_v3.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_vsize.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_weight.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_emptyoutput_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_input_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_opreturn_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_output_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2a_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2ms_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2pk33_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2pk65_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2pkh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2sh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2tr_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2wpkh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_p2wsh_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_unknownoutput_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_subsidy.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_exact_utxo_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_unclaimed_rewards.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_subsidy_usd_1y_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_puell_multiple
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter
}
}

86
crates/brk_computer/src/cointime.rs
View File

@@ -249,8 +249,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -609,34 +608,59 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.indexes_to_coinblocks_created.vecs(),
self.indexes_to_coinblocks_stored.vecs(),
self.indexes_to_liveliness.vecs(),
self.indexes_to_vaultedness.vecs(),
self.indexes_to_activity_to_vaultedness_ratio.vecs(),
self.indexes_to_vaulted_supply.vecs(),
self.indexes_to_active_supply.vecs(),
self.indexes_to_thermo_cap.vecs(),
self.indexes_to_investor_cap.vecs(),
self.indexes_to_vaulted_cap.vecs(),
self.indexes_to_active_cap.vecs(),
self.indexes_to_vaulted_price.vecs(),
self.indexes_to_vaulted_price_ratio.vecs(),
self.indexes_to_active_price.vecs(),
self.indexes_to_active_price_ratio.vecs(),
self.indexes_to_true_market_mean.vecs(),
self.indexes_to_true_market_mean_ratio.vecs(),
self.indexes_to_cointime_price.vecs(),
self.indexes_to_cointime_cap.vecs(),
self.indexes_to_cointime_price_ratio.vecs(),
self.indexes_to_cointime_value_destroyed.vecs(),
self.indexes_to_cointime_value_created.vecs(),
self.indexes_to_cointime_value_stored.vecs(),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(iter.chain(self.indexes_to_coinblocks_created.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coinblocks_stored.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_liveliness.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaultedness.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_activity_to_vaultedness_ratio
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_vaulted_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_thermo_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_investor_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaulted_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaulted_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_vaulted_price_ratio.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_active_price_ratio.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_true_market_mean.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_true_market_mean_ratio
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_cointime_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_cointime_cap.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_cointime_price_ratio.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_cointime_value_destroyed
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_cointime_value_created
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_cointime_value_stored.iter_any_collectable()));
iter
}
}

43
crates/brk_computer/src/constants.rs
View File

@@ -156,8 +156,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -247,25 +246,25 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.constant_0.vecs(),
self.constant_1.vecs(),
self.constant_2.vecs(),
self.constant_3.vecs(),
self.constant_4.vecs(),
self.constant_38_2.vecs(),
self.constant_50.vecs(),
self.constant_61_8.vecs(),
self.constant_100.vecs(),
self.constant_600.vecs(),
self.constant_minus_1.vecs(),
self.constant_minus_2.vecs(),
self.constant_minus_3.vecs(),
self.constant_minus_4.vecs(),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(iter.chain(self.constant_0.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_1.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_3.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_4.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_38_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_50.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_61_8.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_100.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_600.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_1.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_3.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_4.iter_any_collectable()));
iter
}
}

8
crates/brk_computer/src/fetched.rs
View File

@@ -42,8 +42,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -140,10 +139,11 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
vec![
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.dateindex_to_price_ohlc_in_cents as &dyn AnyCollectableVec,
&self.height_to_price_ohlc_in_cents,
]
.into_iter()
}
}

129
crates/brk_computer/src/grouped/builder_eager.rs
View File

@@ -541,7 +541,7 @@ where
pub fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
))
}
@@ -589,47 +589,96 @@ where
self.cumulative.as_ref().unwrap()
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
let mut v: Vec<&dyn AnyCollectableVec> = vec![];
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
if let Some(first) = self.first.as_ref() {
v.push(first.as_ref());
}
if let Some(last) = self.last.as_ref() {
v.push(last.as_ref());
}
if let Some(min) = self.min.as_ref() {
v.push(min.as_ref());
}
if let Some(max) = self.max.as_ref() {
v.push(max.as_ref());
}
if let Some(median) = self.median.as_ref() {
v.push(median.as_ref());
}
if let Some(average) = self.average.as_ref() {
v.push(average.as_ref());
}
if let Some(sum) = self.sum.as_ref() {
v.push(sum.as_ref());
}
if let Some(cumulative) = self.cumulative.as_ref() {
v.push(cumulative.as_ref());
}
if let Some(pct90) = self.pct90.as_ref() {
v.push(pct90.as_ref());
}
if let Some(pct75) = self.pct75.as_ref() {
v.push(pct75.as_ref());
}
if let Some(pct25) = self.pct25.as_ref() {
v.push(pct25.as_ref());
}
if let Some(pct10) = self.pct10.as_ref() {
v.push(pct10.as_ref());
}
iter = Box::new(
iter.chain(
self.first
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.last
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.min
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.max
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.median
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.average
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.sum
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.cumulative
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct90
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct75
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct25
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.pct10
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
v
iter
}
pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {

79
crates/brk_computer/src/grouped/builder_lazy.rs
View File

@@ -217,7 +217,7 @@ where
pub fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.vecs().into_iter().map(|v| v.len()).min().unwrap(),
self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
))
}
@@ -245,32 +245,61 @@ where
self.cumulative.as_ref().unwrap()
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
let mut v: Vec<&dyn AnyCollectableVec> = vec![];
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
if let Some(first) = self.first.as_ref() {
v.push(first.as_ref());
}
if let Some(last) = self.last.as_ref() {
v.push(last.as_ref());
}
if let Some(min) = self.min.as_ref() {
v.push(min.as_ref());
}
if let Some(max) = self.max.as_ref() {
v.push(max.as_ref());
}
if let Some(average) = self.average.as_ref() {
v.push(average.as_ref());
}
if let Some(sum) = self.sum.as_ref() {
v.push(sum.as_ref());
}
if let Some(cumulative) = self.cumulative.as_ref() {
v.push(cumulative.as_ref());
}
iter = Box::new(
iter.chain(
self.first
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.last
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.min
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.max
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.average
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.sum
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.cumulative
.as_ref()
.map(|x| x.as_ref() as &dyn AnyCollectableVec),
),
);
v
iter
}
}

29
crates/brk_computer/src/grouped/from_dateindex.rs
View File

@@ -143,21 +143,22 @@ where
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.dateindex
.as_ref()
.map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
self.dateindex_extra.vecs(),
self.weekindex.vecs(),
self.monthindex.vecs(),
self.quarterindex.vecs(),
self.semesterindex.vecs(),
self.yearindex.vecs(),
self.decadeindex.vecs(),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
.map(|x| x as &dyn AnyCollectableVec)
.into_iter(),
);
iter = Box::new(iter.chain(self.dateindex_extra.iter_any_collectable()));
iter = Box::new(iter.chain(self.weekindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.monthindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.quarterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.semesterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.yearindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.decadeindex.iter_any_collectable()));
iter
}
}

34
crates/brk_computer/src/grouped/from_height.rs
View File

@@ -199,24 +199,24 @@ where
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.height
.as_ref()
.map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
self.height_extra.vecs(),
self.dateindex.vecs(),
self.weekindex.vecs(),
self.difficultyepoch.vecs(),
self.monthindex.vecs(),
self.quarterindex.vecs(),
self.semesterindex.vecs(),
self.yearindex.vecs(),
// self.halvingepoch.vecs(),
self.decadeindex.vecs(),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
.map(|x| x as &dyn AnyCollectableVec)
.into_iter(),
);
iter = Box::new(iter.chain(self.height_extra.iter_any_collectable()));
iter = Box::new(iter.chain(self.dateindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.weekindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.difficultyepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.monthindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.quarterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.semesterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.yearindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.decadeindex.iter_any_collectable()));
iter
}
}

15
crates/brk_computer/src/grouped/from_height_strict.rs
View File

@@ -82,15 +82,10 @@ where
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
vec![&self.height as &dyn AnyCollectableVec],
self.height_extra.vecs(),
self.difficultyepoch.vecs(),
// self.halvingepoch.vecs(),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.height as &dyn AnyCollectableVec]
.into_iter()
.chain(self.height_extra.iter_any_collectable())
.chain(self.difficultyepoch.iter_any_collectable())
}
}

34
crates/brk_computer/src/grouped/from_txindex.rs
View File

@@ -226,25 +226,25 @@ where
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.txindex
.as_ref()
.map_or(vec![], |v| vec![v.as_ref() as &dyn AnyCollectableVec]),
self.height.vecs(),
self.dateindex.vecs(),
self.weekindex.vecs(),
self.difficultyepoch.vecs(),
self.monthindex.vecs(),
self.quarterindex.vecs(),
self.semesterindex.vecs(),
self.yearindex.vecs(),
// self.halvingepoch.vecs(),
self.decadeindex.vecs(),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
.map(|x| x.as_ref() as &dyn AnyCollectableVec)
.into_iter(),
);
iter = Box::new(iter.chain(self.height.iter_any_collectable()));
iter = Box::new(iter.chain(self.dateindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.weekindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.difficultyepoch.iter_any_collectable()));
iter = Box::new(iter.chain(self.monthindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.quarterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.semesterindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.yearindex.iter_any_collectable()));
iter = Box::new(iter.chain(self.decadeindex.iter_any_collectable()));
iter
}
}

159
crates/brk_computer/src/grouped/ratio_from_dateindex.rs
View File

@@ -632,37 +632,132 @@ impl ComputedRatioVecsFromDateIndex {
.collect::<Vec<_>>()
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.price.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio.vecs(),
self.ratio_1w_sma.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_1m_sma.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_sd.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_1y_sd.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_2y_sd.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_4y_sd.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct1.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct2.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct5.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct95.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct98.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct99.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct1_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct2_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct5_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.ratio_pct95_in_usd
.as_ref()
.map_or(vec![], |v| v.vecs()),
self.ratio_pct98_in_usd
.as_ref()
.map_or(vec![], |v| v.vecs()),
self.ratio_pct99_in_usd
.as_ref()
.map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.price.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.ratio.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.ratio_1w_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_1m_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.ratio_sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.ratio_1y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_2y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_4y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct1
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct2
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct5
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct95
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct98
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct99
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct1_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct2_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct5_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct95_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct98_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct99_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter
}
}

145
crates/brk_computer/src/grouped/sd_from_dateindex.rs
View File

@@ -805,39 +805,116 @@ impl ComputedStandardDeviationVecsFromDateIndex {
.map(|c| c.dateindex.as_mut().unwrap())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.sma.as_ref().map_or(vec![], |v| v.vecs()),
self.sd.vecs(),
self.p0_5sd.as_ref().map_or(vec![], |v| v.vecs()),
self.p1sd.as_ref().map_or(vec![], |v| v.vecs()),
self.p1_5sd.as_ref().map_or(vec![], |v| v.vecs()),
self.p2sd.as_ref().map_or(vec![], |v| v.vecs()),
self.p2_5sd.as_ref().map_or(vec![], |v| v.vecs()),
self.p3sd.as_ref().map_or(vec![], |v| v.vecs()),
self.m0_5sd.as_ref().map_or(vec![], |v| v.vecs()),
self.m1sd.as_ref().map_or(vec![], |v| v.vecs()),
self.m1_5sd.as_ref().map_or(vec![], |v| v.vecs()),
self.m2sd.as_ref().map_or(vec![], |v| v.vecs()),
self.m2_5sd.as_ref().map_or(vec![], |v| v.vecs()),
self.m3sd.as_ref().map_or(vec![], |v| v.vecs()),
self._0sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.p0_5sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.p1sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.p1_5sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.p2sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.p2_5sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.p3sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.m0_5sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.m1sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.m1_5sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.m2sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.m2_5sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.m3sd_in_usd.as_ref().map_or(vec![], |v| v.vecs()),
self.zscore.as_ref().map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.sma.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.p0_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p1sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p1_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p2sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p2_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p3sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m0_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m1sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m1_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m2sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m2_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m3sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self._0sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.p0_5sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.p1sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.p1_5sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.p2sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.p2_5sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.p3sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.m0_5sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.m1sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.m1_5sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.m2sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.m2_5sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.m3sd_in_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.zscore.iter().flat_map(|v| v.iter_any_collectable())));
iter
}
}

14
crates/brk_computer/src/grouped/value_from_dateindex.rs
View File

@@ -131,14 +131,10 @@ impl ComputedValueVecsFromDateIndex {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.sats.vecs(),
self.bitcoin.vecs(),
self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
std::iter::empty()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}

14
crates/brk_computer/src/grouped/value_from_height.rs
View File

@@ -131,14 +131,10 @@ impl ComputedValueVecsFromHeight {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.sats.vecs(),
self.bitcoin.vecs(),
self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
std::iter::empty()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}

24
crates/brk_computer/src/grouped/value_from_txindex.rs
View File

@@ -204,18 +204,16 @@ impl ComputedValueVecsFromTxindex {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.sats.vecs(),
vec![&self.bitcoin_txindex as &dyn AnyCollectableVec],
self.bitcoin.vecs(),
self.dollars_txindex
.as_ref()
.map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]),
self.dollars.as_ref().map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.bitcoin_txindex as &dyn AnyCollectableVec]
.into_iter()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(
self.dollars_txindex
.iter()
.map(|v| v as &dyn AnyCollectableVec),
)
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}

14
crates/brk_computer/src/grouped/value_height.rs
View File

@@ -101,14 +101,10 @@ impl ComputedHeightValueVecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
vec![&self.bitcoin as &dyn AnyCollectableVec],
self.sats.as_ref().map_or(vec![], |v| vec![v]),
self.dollars.as_ref().map_or(vec![], |v| vec![v]),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.bitcoin as &dyn AnyCollectableVec]
.into_iter()
.chain(self.sats.iter().map(|v| v as &dyn AnyCollectableVec))
.chain(self.dollars.iter().map(|v| v as &dyn AnyCollectableVec))
}
}

10
crates/brk_computer/src/indexes.rs
View File

@@ -475,8 +475,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -934,9 +933,9 @@ impl Vecs {
})
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
vec![
&self.dateindex_to_date,
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.dateindex_to_date as &dyn AnyCollectableVec,
&self.dateindex_to_dateindex,
&self.dateindex_to_first_height,
&self.dateindex_to_height_count,
@@ -997,6 +996,7 @@ impl Vecs {
&self.yearindex_to_yearindex,
&self.outputindex_to_txindex,
]
.into_iter()
}
}

29
crates/brk_computer/src/lib.rs
View File

@@ -187,21 +187,20 @@ impl Computer {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.constants.vecs(),
self.indexes.vecs(),
self.market.vecs(),
self.chain.vecs(),
self.stateful.vecs(),
self.cointime.vecs(),
self.pools.vecs(),
self.fetched.as_ref().map_or(vec![], |v| v.vecs()),
self.price.as_ref().map_or(vec![], |v| v.vecs()),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.fetched.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.price.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.pools.iter_any_collectable()));
iter = Box::new(iter.chain(self.constants.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes.iter_any_collectable()));
iter = Box::new(iter.chain(self.market.iter_any_collectable()));
iter = Box::new(iter.chain(self.chain.iter_any_collectable()));
iter = Box::new(iter.chain(self.stateful.iter_any_collectable()));
iter = Box::new(iter.chain(self.cointime.iter_any_collectable()));
iter
}
pub fn static_clone(&self) -> &'static Self {

365
crates/brk_computer/src/market.rs
View File

@@ -1516,8 +1516,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -2327,176 +2326,202 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.indexes_to_price_ath.vecs(),
self.indexes_to_price_drawdown.vecs(),
self.indexes_to_days_since_price_ath.vecs(),
self.indexes_to_max_days_between_price_aths.vecs(),
self.indexes_to_max_years_between_price_aths.vecs(),
self.indexes_to_price_1w_sma.vecs(),
self.indexes_to_price_8d_sma.vecs(),
self.indexes_to_price_13d_sma.vecs(),
self.indexes_to_price_21d_sma.vecs(),
self.indexes_to_price_1m_sma.vecs(),
self.indexes_to_price_34d_sma.vecs(),
self.indexes_to_price_55d_sma.vecs(),
self.indexes_to_price_89d_sma.vecs(),
self.indexes_to_price_144d_sma.vecs(),
self.indexes_to_price_200d_sma.vecs(),
self.indexes_to_price_1y_sma.vecs(),
self.indexes_to_price_2y_sma.vecs(),
self.indexes_to_price_200w_sma.vecs(),
self.indexes_to_price_4y_sma.vecs(),
self.indexes_to_price_1w_ema.vecs(),
self.indexes_to_price_8d_ema.vecs(),
self.indexes_to_price_13d_ema.vecs(),
self.indexes_to_price_21d_ema.vecs(),
self.indexes_to_price_1m_ema.vecs(),
self.indexes_to_price_34d_ema.vecs(),
self.indexes_to_price_55d_ema.vecs(),
self.indexes_to_price_89d_ema.vecs(),
self.indexes_to_price_144d_ema.vecs(),
self.indexes_to_price_200d_ema.vecs(),
self.indexes_to_price_1y_ema.vecs(),
self.indexes_to_price_2y_ema.vecs(),
self.indexes_to_price_200w_ema.vecs(),
self.indexes_to_price_4y_ema.vecs(),
self.indexes_to_price_200d_sma_x0_8.vecs(),
self.indexes_to_price_200d_sma_x2_4.vecs(),
self.price_1d_ago.vecs(),
self.price_1w_ago.vecs(),
self.price_1m_ago.vecs(),
self.price_3m_ago.vecs(),
self.price_6m_ago.vecs(),
self.price_1y_ago.vecs(),
self.price_2y_ago.vecs(),
self.price_3y_ago.vecs(),
self.price_4y_ago.vecs(),
self.price_5y_ago.vecs(),
self.price_6y_ago.vecs(),
self.price_8y_ago.vecs(),
self.price_10y_ago.vecs(),
self._1d_price_returns.vecs(),
self._1w_price_returns.vecs(),
self._1m_price_returns.vecs(),
self._3m_price_returns.vecs(),
self._6m_price_returns.vecs(),
self._1y_price_returns.vecs(),
self._2y_price_returns.vecs(),
self._3y_price_returns.vecs(),
self._4y_price_returns.vecs(),
self._5y_price_returns.vecs(),
self._6y_price_returns.vecs(),
self._8y_price_returns.vecs(),
self._10y_price_returns.vecs(),
self._2y_cagr.vecs(),
self._3y_cagr.vecs(),
self._4y_cagr.vecs(),
self._5y_cagr.vecs(),
self._6y_cagr.vecs(),
self._8y_cagr.vecs(),
self._10y_cagr.vecs(),
self._1w_dca_returns.vecs(),
self._1m_dca_returns.vecs(),
self._3m_dca_returns.vecs(),
self._6m_dca_returns.vecs(),
self._1y_dca_returns.vecs(),
self._2y_dca_returns.vecs(),
self._3y_dca_returns.vecs(),
self._4y_dca_returns.vecs(),
self._5y_dca_returns.vecs(),
self._6y_dca_returns.vecs(),
self._8y_dca_returns.vecs(),
self._10y_dca_returns.vecs(),
self._2y_dca_cagr.vecs(),
self._3y_dca_cagr.vecs(),
self._4y_dca_cagr.vecs(),
self._5y_dca_cagr.vecs(),
self._6y_dca_cagr.vecs(),
self._8y_dca_cagr.vecs(),
self._10y_dca_cagr.vecs(),
self._1w_dca_avg_price.vecs(),
self._1m_dca_avg_price.vecs(),
self._3m_dca_avg_price.vecs(),
self._6m_dca_avg_price.vecs(),
self._1y_dca_avg_price.vecs(),
self._2y_dca_avg_price.vecs(),
self._3y_dca_avg_price.vecs(),
self._4y_dca_avg_price.vecs(),
self._5y_dca_avg_price.vecs(),
self._6y_dca_avg_price.vecs(),
self._8y_dca_avg_price.vecs(),
self._10y_dca_avg_price.vecs(),
self._1w_dca_stack.vecs(),
self._1m_dca_stack.vecs(),
self._3m_dca_stack.vecs(),
self._6m_dca_stack.vecs(),
self._1y_dca_stack.vecs(),
self._2y_dca_stack.vecs(),
self._3y_dca_stack.vecs(),
self._4y_dca_stack.vecs(),
self._5y_dca_stack.vecs(),
self._6y_dca_stack.vecs(),
self._8y_dca_stack.vecs(),
self._10y_dca_stack.vecs(),
self.dca_class_2025_stack.vecs(),
self.dca_class_2024_stack.vecs(),
self.dca_class_2023_stack.vecs(),
self.dca_class_2022_stack.vecs(),
self.dca_class_2021_stack.vecs(),
self.dca_class_2020_stack.vecs(),
self.dca_class_2019_stack.vecs(),
self.dca_class_2018_stack.vecs(),
self.dca_class_2017_stack.vecs(),
self.dca_class_2016_stack.vecs(),
self.dca_class_2015_stack.vecs(),
self.dca_class_2025_avg_price.vecs(),
self.dca_class_2024_avg_price.vecs(),
self.dca_class_2023_avg_price.vecs(),
self.dca_class_2022_avg_price.vecs(),
self.dca_class_2021_avg_price.vecs(),
self.dca_class_2020_avg_price.vecs(),
self.dca_class_2019_avg_price.vecs(),
self.dca_class_2018_avg_price.vecs(),
self.dca_class_2017_avg_price.vecs(),
self.dca_class_2016_avg_price.vecs(),
self.dca_class_2015_avg_price.vecs(),
self.dca_class_2025_returns.vecs(),
self.dca_class_2024_returns.vecs(),
self.dca_class_2023_returns.vecs(),
self.dca_class_2022_returns.vecs(),
self.dca_class_2021_returns.vecs(),
self.dca_class_2020_returns.vecs(),
self.dca_class_2019_returns.vecs(),
self.dca_class_2018_returns.vecs(),
self.dca_class_2017_returns.vecs(),
self.dca_class_2016_returns.vecs(),
self.dca_class_2015_returns.vecs(),
self.indexes_to_1d_returns_1w_sd.vecs(),
self.indexes_to_1d_returns_1m_sd.vecs(),
self.indexes_to_1d_returns_1y_sd.vecs(),
self.indexes_to_price_1w_volatility.vecs(),
self.indexes_to_price_1m_volatility.vecs(),
self.indexes_to_price_1y_volatility.vecs(),
self.indexes_to_price_2w_choppiness_index.vecs(),
self.indexes_to_price_1w_min.vecs(),
self.indexes_to_price_1w_max.vecs(),
self.indexes_to_price_2w_min.vecs(),
self.indexes_to_price_2w_max.vecs(),
self.indexes_to_price_1m_min.vecs(),
self.indexes_to_price_1m_max.vecs(),
self.indexes_to_price_1y_min.vecs(),
self.indexes_to_price_1y_max.vecs(),
vec![
&self.height_to_price_ath,
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_price_ath as &dyn AnyCollectableVec,
&self.height_to_price_drawdown,
&self.dateindex_to_price_true_range,
&self.dateindex_to_price_true_range_2w_sum,
],
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
]
.into_iter(),
);
iter = Box::new(iter.chain(self.indexes_to_price_ath.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_drawdown.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_days_since_price_ath.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_max_days_between_price_aths
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_max_years_between_price_aths
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_price_1w_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_8d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_13d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_21d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_34d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_55d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_89d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_144d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200w_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_4y_sma.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_sma_x0_8.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_sma_x2_4.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1w_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_8d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_13d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_21d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_34d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_55d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_89d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_144d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200d_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2y_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_200w_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_4y_ema.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1d_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1w_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1m_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_3m_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_6m_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_1y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_2y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_3y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_4y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_5y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_6y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_8y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self.price_10y_ago.iter_any_collectable()));
iter = Box::new(iter.chain(self._1d_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_price_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2025_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2024_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2023_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2022_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2021_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2020_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2019_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2018_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2017_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2016_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2015_returns.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_cagr.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2025_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2024_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2023_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2022_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2021_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2020_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2019_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2018_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2017_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2016_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2015_avg_price.iter_any_collectable()));
iter = Box::new(iter.chain(self._1w_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._1m_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._3m_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._6m_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._1y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._2y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._3y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._4y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._5y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._6y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._8y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self._10y_dca_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2025_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2024_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2023_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2022_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2021_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2020_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2019_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2018_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2017_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2016_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.dca_class_2015_stack.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_returns_1w_sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_returns_1m_sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_returns_1y_sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1w_volatility.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_volatility.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_volatility.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.indexes_to_price_2w_choppiness_index
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_price_1w_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1w_max.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2w_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_2w_max.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1m_max.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_price_1y_max.iter_any_collectable()));
iter
}
}

22
crates/brk_computer/src/pools/mod.rs
View File

@@ -70,8 +70,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -224,16 +223,13 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.vecs
.iter()
.flat_map(|(_, vecs)| vecs.vecs())
.collect::<Vec<_>>(),
vec![&self.height_to_pool],
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.height_to_pool as &dyn AnyCollectableVec]
.into_iter()
.chain(
self.vecs
.iter()
.flat_map(|(_, vecs)| vecs.iter_any_collectable()),
)
}
}

38
crates/brk_computer/src/pools/vecs.rs
View File

@@ -374,24 +374,24 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.indexes_to_blocks_mined.vecs(),
self.indexes_to_1w_blocks_mined.vecs(),
self.indexes_to_1m_blocks_mined.vecs(),
self.indexes_to_1y_blocks_mined.vecs(),
self.indexes_to_subsidy.vecs(),
self.indexes_to_fee.vecs(),
self.indexes_to_coinbase.vecs(),
self.indexes_to_dominance.vecs(),
self.indexes_to_1d_dominance.vecs(),
self.indexes_to_1w_dominance.vecs(),
self.indexes_to_1m_dominance.vecs(),
self.indexes_to_1y_dominance.vecs(),
self.indexes_to_days_since_block.vecs(),
]
.into_iter()
.flatten()
.collect()
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(iter.chain(self.indexes_to_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_subsidy.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_fee.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coinbase.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_days_since_block.iter_any_collectable()));
iter
}
}

89
crates/brk_computer/src/price.rs
View File

@@ -326,8 +326,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -1228,9 +1227,9 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
vec![
vec![
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.dateindex_to_price_close_in_cents as &dyn AnyCollectableVec,
&self.dateindex_to_price_high_in_cents,
&self.dateindex_to_price_low_in_cents,
@@ -1247,7 +1246,6 @@ impl Vecs {
&self.quarterindex_to_price_ohlc,
&self.semesterindex_to_price_ohlc,
&self.yearindex_to_price_ohlc,
// &self.halvingepoch_to_price_ohlc,
&self.decadeindex_to_price_ohlc,
&self.height_to_price_ohlc_in_sats,
&self.dateindex_to_price_ohlc_in_sats,
@@ -1257,28 +1255,63 @@ impl Vecs {
&self.quarterindex_to_price_ohlc_in_sats,
&self.semesterindex_to_price_ohlc_in_sats,
&self.yearindex_to_price_ohlc_in_sats,
// &self.halvingepoch_to_price_ohlc_in_sats,
&self.decadeindex_to_price_ohlc_in_sats,
],
self.timeindexes_to_price_close.vecs(),
self.timeindexes_to_price_high.vecs(),
self.timeindexes_to_price_low.vecs(),
self.timeindexes_to_price_open.vecs(),
self.chainindexes_to_price_close.vecs(),
self.chainindexes_to_price_high.vecs(),
self.chainindexes_to_price_low.vecs(),
self.chainindexes_to_price_open.vecs(),
self.timeindexes_to_price_close_in_sats.vecs(),
self.timeindexes_to_price_high_in_sats.vecs(),
self.timeindexes_to_price_low_in_sats.vecs(),
self.timeindexes_to_price_open_in_sats.vecs(),
self.chainindexes_to_price_close_in_sats.vecs(),
self.chainindexes_to_price_high_in_sats.vecs(),
self.chainindexes_to_price_low_in_sats.vecs(),
self.chainindexes_to_price_open_in_sats.vecs(),
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
]
.into_iter(),
);
iter = Box::new(iter.chain(self.timeindexes_to_price_close.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_price_high.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_price_low.iter_any_collectable()));
iter = Box::new(iter.chain(self.timeindexes_to_price_open.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_close.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_high.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_low.iter_any_collectable()));
iter = Box::new(iter.chain(self.chainindexes_to_price_open.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.timeindexes_to_price_close_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.timeindexes_to_price_high_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.timeindexes_to_price_low_in_sats.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.timeindexes_to_price_open_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_close_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_high_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_low_in_sats
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.chainindexes_to_price_open_in_sats
.iter_any_collectable(),
),
);
iter
}
}

32
crates/brk_computer/src/stateful/address_cohort.rs
View File

@@ -1,4 +1,4 @@
use std::{ops::Deref, path::Path};
use std::path::Path;
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
@@ -84,17 +84,21 @@ impl Vecs {
)?,
})
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.inner
.iter_any_collectable()
.chain([&self.height_to_addr_count as &dyn AnyCollectableVec])
.chain(self.indexes_to_addr_count.iter_any_collectable())
}
}
impl DynCohortVecs for Vecs {
fn min_height_vecs_len(&self) -> usize {
[
std::cmp::min(
self.height_to_addr_count.len(),
self.inner.min_height_vecs_len(),
]
.into_iter()
.min()
.unwrap()
)
}
fn reset_state_starting_height(&mut self) {
@@ -185,15 +189,6 @@ impl DynCohortVecs for Vecs {
self.inner
.compute_rest_part1(indexes, price, starting_indexes, exit)
}
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.inner.vecs(),
self.indexes_to_addr_count.vecs(),
vec![&self.height_to_addr_count],
]
.concat()
}
}
impl CohortVecs for Vecs {
@@ -247,10 +242,3 @@ impl CohortVecs for Vecs {
)
}
}
impl Deref for Vecs {
type Target = common::Vecs;
fn deref(&self) -> &Self::Target {
&self.inner
}
}

44
crates/brk_computer/src/stateful/address_cohorts.rs
View File

@@ -458,18 +458,17 @@ impl Vecs {
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
let by_size_range = self.0.amount_range.as_vec();
let by_size_range = &self.0.amount_range;
[
self.0
.ge_amount
.as_mut_vec()
.into_iter()
.iter_mut()
.map(|(filter, vecs)| {
(
vecs,
by_size_range
.into_iter()
.iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
@@ -478,13 +477,12 @@ impl Vecs {
.collect::<Vec<_>>(),
self.0
.lt_amount
.as_mut_vec()
.into_iter()
.iter_mut()
.map(|(filter, vecs)| {
(
vecs,
by_size_range
.into_iter()
.iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
@@ -506,7 +504,7 @@ impl Vecs {
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
self.as_mut_vecs()
self.iter_mut()
.into_iter()
.try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit))
}
@@ -525,26 +523,24 @@ impl Vecs {
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> Result<()> {
self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| {
v.into_iter().try_for_each(|(_, v)| {
v.compute_rest_part2(
indexes,
price,
starting_indexes,
height_to_supply,
dateindex_to_supply,
height_to_market_cap,
dateindex_to_market_cap,
height_to_realized_cap,
dateindex_to_realized_cap,
exit,
)
})
self.0.iter_mut().try_for_each(|(_, v)| {
v.compute_rest_part2(
indexes,
price,
starting_indexes,
height_to_supply,
dateindex_to_supply,
height_to_market_cap,
dateindex_to_market_cap,
height_to_realized_cap,
dateindex_to_realized_cap,
exit,
)
})
}
pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
self.as_mut_separate_vecs()
self.iter_separate_mut()
.into_iter()
.try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))
}

8
crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs
View File

@@ -75,11 +75,9 @@ impl AddressTypeToIndexesToAddressCount {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.0
.as_typed_vec()
.into_iter()
.flat_map(|(_, v)| v.vecs())
.collect::<Vec<_>>()
.iter_typed()
.flat_map(|(_, v)| v.iter_any_collectable())
}
}

4
crates/brk_computer/src/stateful/addresstype/typeindex_tree.rs
View File

@@ -27,6 +27,10 @@ impl<T> AddressTypeToTypeIndexTree<T> {
mem::swap(own, other);
}
}
pub fn unwrap(self) -> ByAddressType<BTreeMap<TypeIndex, T>> {
self.0
}
}
impl<T> Default for AddressTypeToTypeIndexTree<T> {

4
crates/brk_computer/src/stateful/addresstype/vec.rs
View File

@@ -38,6 +38,10 @@ impl<T> AddressTypeToVec<T> {
mem::swap(own, other);
}
}
pub fn unwrap(self) -> ByAddressType<Vec<T>> {
self.0
}
}
impl<T> Default for AddressTypeToVec<T> {

1067
crates/brk_computer/src/stateful/common.rs
View File

File diff suppressed because it is too large Load Diff

174
crates/brk_computer/src/stateful/mod.rs
View File

@@ -493,8 +493,7 @@ impl Vecs {
};
this.db.retain_regions(
this.vecs()
.into_iter()
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
@@ -598,8 +597,9 @@ impl Vecs {
+ dateindex_to_first_height.version()
+ dateindex_to_height_count.version();
let mut separate_utxo_vecs = self.utxo_cohorts.as_mut_separate_vecs();
let mut separate_address_vecs = self.address_cohorts.as_mut_separate_vecs();
let mut separate_utxo_vecs = self.utxo_cohorts.iter_separate_mut().collect::<Vec<_>>();
let mut separate_address_vecs =
self.address_cohorts.iter_separate_mut().collect::<Vec<_>>();
separate_utxo_vecs
.par_iter_mut()
@@ -878,13 +878,11 @@ impl Vecs {
info!("Processing chain at {height}...");
self.utxo_cohorts
.as_mut_separate_vecs()
.iter_mut()
.iter_separate_mut()
.for_each(|(_, v)| v.state.as_mut().unwrap().reset_single_iteration_values());
self.address_cohorts
.as_mut_separate_vecs()
.iter_mut()
.iter_separate_mut()
.for_each(|(_, v)| v.state.as_mut().unwrap().reset_single_iteration_values());
let timestamp = height_to_timestamp_fixed_iter.unwrap_get_inner(height);
@@ -1252,12 +1250,11 @@ impl Vecs {
let dateindex = is_date_last_height.then_some(dateindex);
self.utxo_cohorts.as_mut_separate_vecs()
.into_par_iter()
self.utxo_cohorts.iter_separate_mut().par_bridge()
.map(|(_, v)| v as &mut dyn DynCohortVecs)
.chain(
self.address_cohorts.as_mut_separate_vecs()
.into_par_iter()
self.address_cohorts.iter_separate_mut()
.par_bridge()
.map(|(_, v)| v as &mut dyn DynCohortVecs),
)
.try_for_each(|v| {
@@ -1315,8 +1312,7 @@ impl Vecs {
starting_indexes.height,
&self
.addresstype_to_height_to_addr_count
.as_typed_vec()
.into_iter()
.iter_typed()
.map(|(_, v)| v)
.collect::<Vec<_>>(),
exit,
@@ -1330,8 +1326,7 @@ impl Vecs {
starting_indexes.height,
&self
.addresstype_to_height_to_empty_addr_count
.as_typed_vec()
.into_iter()
.iter_typed()
.map(|(_, v)| v)
.collect::<Vec<_>>(),
exit,
@@ -1635,10 +1630,10 @@ impl Vecs {
&mut self,
height: Height,
chain_state: &[BlockState],
mut addresstype_to_typeindex_to_loadedaddressdata: AddressTypeToTypeIndexTree<
addresstype_to_typeindex_to_loadedaddressdata: AddressTypeToTypeIndexTree<
WithAddressDataSource<LoadedAddressData>,
>,
mut addresstype_to_typeindex_to_emptyaddressdata: AddressTypeToTypeIndexTree<
addresstype_to_typeindex_to_emptyaddressdata: AddressTypeToTypeIndexTree<
WithAddressDataSource<EmptyAddressData>,
>,
with_changes: bool,
@@ -1647,30 +1642,28 @@ impl Vecs {
info!("Flushing...");
self.utxo_cohorts
.as_mut_separate_vecs()
.par_iter_mut()
.iter_separate_mut()
.par_bridge()
.try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))?;
self.address_cohorts
.as_mut_separate_vecs()
.par_iter_mut()
.iter_separate_mut()
.par_bridge()
.try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))?;
self.height_to_unspendable_supply.safe_flush(exit)?;
self.height_to_opreturn_supply.safe_flush(exit)?;
self.addresstype_to_height_to_addr_count
.as_mut_vec()
.into_iter()
.iter_mut()
.try_for_each(|v| v.safe_flush(exit))?;
self.addresstype_to_height_to_empty_addr_count
.as_mut_vec()
.into_iter()
.iter_mut()
.try_for_each(|v| v.safe_flush(exit))?;
let mut addresstype_to_typeindex_to_new_or_updated_anyaddressindex =
AddressTypeToTypeIndexTree::default();
addresstype_to_typeindex_to_emptyaddressdata
.into_typed_vec()
.into_iter()
.unwrap()
.into_iter_typed()
.try_for_each(|(_type, tree)| -> Result<()> {
tree.into_iter().try_for_each(
|(typeindex, emptyaddressdata_with_source)| -> Result<()> {
@@ -1722,8 +1715,8 @@ impl Vecs {
})?;
addresstype_to_typeindex_to_loadedaddressdata
.into_typed_vec()
.into_iter()
.unwrap()
.into_iter_typed()
.try_for_each(|(_type, tree)| -> Result<()> {
tree.into_iter().try_for_each(
|(typeindex, loadedaddressdata_with_source)| -> Result<()> {
@@ -1775,8 +1768,8 @@ impl Vecs {
})?;
addresstype_to_typeindex_to_new_or_updated_anyaddressindex
.into_typed_vec()
.into_iter()
.unwrap()
.into_iter_typed()
.try_for_each(|(_type, tree)| -> Result<()> {
tree.into_iter()
.try_for_each(|(typeindex, anyaddressindex)| -> Result<()> {
@@ -1844,42 +1837,10 @@ impl Vecs {
Ok(())
}
pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
[
self.utxo_cohorts
.vecs()
.into_iter()
.flat_map(|v| v.vecs())
.collect::<Vec<_>>(),
self.address_cohorts
.vecs()
.into_iter()
.flat_map(|v| v.vecs())
.collect::<Vec<_>>(),
self.indexes_to_unspendable_supply.vecs(),
self.indexes_to_opreturn_supply.vecs(),
self.indexes_to_addr_count.vecs(),
self.indexes_to_empty_addr_count.vecs(),
self.addresstype_to_indexes_to_addr_count.vecs(),
self.indexes_to_market_cap
.as_ref()
.map_or(vec![], |v| v.vecs()),
self.addresstype_to_indexes_to_empty_addr_count.vecs(),
self.addresstype_to_height_to_addr_count
.as_typed_vec()
.into_iter()
.map(|(_, v)| v as &dyn AnyCollectableVec)
.collect::<Vec<_>>(),
self.addresstype_to_height_to_empty_addr_count
.as_typed_vec()
.into_iter()
.map(|(_, v)| v as &dyn AnyCollectableVec)
.collect::<Vec<_>>(),
self.height_to_market_cap
.as_ref()
.map_or(vec![], |v| vec![v]),
vec![
&self.height_to_unspendable_supply,
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_unspendable_supply as &dyn AnyCollectableVec,
&self.height_to_opreturn_supply,
&self.chain_state,
&self.p2pk33addressindex_to_anyaddressindex,
@@ -1894,18 +1855,77 @@ impl Vecs {
&self.emptyaddressindex_to_emptyaddressdata,
&self.loadedaddressindex_to_loadedaddressindex,
&self.emptyaddressindex_to_emptyaddressindex,
],
]
.into_iter()
.flatten()
.collect::<Vec<_>>()
]
.into_iter(),
);
iter = Box::new(
iter.chain(
self.utxo_cohorts
.iter_right()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.address_cohorts
.iter_right()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.indexes_to_unspendable_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_opreturn_supply.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_addr_count.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_empty_addr_count.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.addresstype_to_indexes_to_addr_count
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_market_cap
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.addresstype_to_indexes_to_empty_addr_count
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.addresstype_to_height_to_addr_count
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.addresstype_to_height_to_empty_addr_count
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter = Box::new(
iter.chain(
self.height_to_market_cap
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter
}
}
impl AddressTypeToVec<(TypeIndex, Sats)> {
#[allow(clippy::too_many_arguments)]
fn process_received(
mut self,
self,
vecs: &mut address_cohorts::Vecs,
addresstype_to_typeindex_to_loadedaddressdata: &mut AddressTypeToTypeIndexTree<
WithAddressDataSource<LoadedAddressData>,
@@ -1920,7 +1940,7 @@ impl AddressTypeToVec<(TypeIndex, Sats)> {
WithAddressDataSource<LoadedAddressData>,
>,
) {
self.into_typed_vec().into_iter().for_each(|(_type, vec)| {
self.unwrap().into_iter_typed().for_each(|(_type, vec)| {
vec.into_iter().for_each(|(type_index, value)| {
let mut is_new = false;
let mut from_any_empty = false;
@@ -2024,7 +2044,7 @@ impl HeightToAddressTypeToVec<(TypeIndex, Sats)> {
WithAddressDataSource<LoadedAddressData>,
>,
) -> Result<()> {
self.0.into_iter().try_for_each(|(prev_height, mut v)| {
self.0.into_iter().try_for_each(|(prev_height, v)| {
let prev_price = height_to_price_close_vec
.as_ref()
.map(|v| **v.get(prev_height.unwrap_to_usize()).unwrap());
@@ -2042,7 +2062,7 @@ impl HeightToAddressTypeToVec<(TypeIndex, Sats)> {
.unwrap()
.is_more_than_hour();
v.into_typed_vec().into_iter().try_for_each(|(_type, vec)| {
v.unwrap().into_iter_typed().try_for_each(|(_type, vec)| {
vec.into_iter().try_for_each(|(type_index, value)| {
let typeindex_to_loadedaddressdata =
addresstype_to_typeindex_to_loadedaddressdata

4
crates/brk_computer/src/stateful/trait.rs
View File

@@ -1,6 +1,6 @@
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use vecdb::{AnyCollectableVec, AnyIterableVec, Exit};
use vecdb::{AnyIterableVec, Exit};
use crate::{Indexes, indexes, price};
@@ -33,8 +33,6 @@ pub trait DynCohortVecs: Send + Sync {
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()>;
fn vecs(&self) -> Vec<&dyn AnyCollectableVec>;
}
pub trait CohortVecs: DynCohortVecs {

6
crates/brk_computer/src/stateful/utxo_cohort.rs
View File

@@ -2,7 +2,7 @@ use std::{ops::Deref, path::Path};
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, Format};
use vecdb::{AnyIterableVec, Database, Exit, Format};
use crate::{
Indexes, UTXOCohortState, indexes, price,
@@ -129,10 +129,6 @@ impl DynCohortVecs for Vecs {
self.inner
.compute_rest_part1(indexes, price, starting_indexes, exit)
}
fn vecs(&self) -> Vec<&dyn AnyCollectableVec> {
self.inner.vecs()
}
}
impl CohortVecs for Vecs {

218
crates/brk_computer/src/stateful/utxo_cohorts.rs
View File

@@ -1457,8 +1457,7 @@ impl Vecs {
let mut vecs = self
.age_range
.as_mut_vec()
.into_iter()
.iter_mut()
.map(|(filter, v)| (filter, &mut v.state))
.collect::<Vec<_>>();
@@ -1502,9 +1501,8 @@ impl Vecs {
let mut time_based_vecs = self
.0
.age_range
.as_mut_vec()
.into_iter()
.chain(self.0.epoch.as_mut_vec())
.iter_mut()
.chain(self.0.epoch.iter_mut())
.collect::<Vec<_>>();
let last_timestamp = chain_state.last().unwrap().timestamp;
@@ -1550,8 +1548,10 @@ impl Vecs {
);
});
sent.by_type.spendable.as_typed_vec().into_iter().for_each(
|(output_type, supply_state)| {
sent.by_type
.spendable
.iter_typed()
.for_each(|(output_type, supply_state)| {
self.0
._type
.get_mut(output_type)
@@ -1567,12 +1567,10 @@ impl Vecs {
days_old_float,
older_than_hour,
)
},
);
});
sent.by_size_group
.as_typed_vec()
.into_iter()
.iter_typed()
.for_each(|(group, supply_state)| {
self.0
.amount_range
@@ -1605,24 +1603,20 @@ impl Vecs {
v.state.as_mut().unwrap().receive(&supply_state, price);
});
self._type
.as_mut_vec()
.into_iter()
.for_each(|(filter, vecs)| {
let output_type = match filter {
GroupFilter::Type(output_type) => *output_type,
_ => unreachable!(),
};
vecs.state
.as_mut()
.unwrap()
.receive(received.by_type.get(output_type), price)
});
self._type.iter_mut().for_each(|(filter, vecs)| {
let output_type = match filter {
GroupFilter::Type(output_type) => *output_type,
_ => unreachable!(),
};
vecs.state
.as_mut()
.unwrap()
.receive(received.by_type.get(output_type), price)
});
received
.by_size_group
.as_typed_vec()
.into_iter()
.iter_typed()
.for_each(|(group, supply_state)| {
self.amount_range
.get_mut(group)
@@ -1639,95 +1633,64 @@ impl Vecs {
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
let by_date_range = self.0.age_range.as_vec();
let by_size_range = self.0.amount_range.as_vec();
let by_date_range = &self.0.age_range;
let by_size_range = &self.0.amount_range;
[
vec![(
&mut self.0.all.1,
[(
&mut self.0.all.1,
by_date_range.iter().map(|(_, v)| v).collect::<Vec<_>>(),
)]
.into_iter()
.chain(self.0.min_age.iter_mut().map(|(filter, vecs)| {
(
vecs,
by_date_range
.into_iter()
.iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)],
self.0
.min_age
.as_mut_vec()
.into_iter()
.map(|(filter, vecs)| {
(
vecs,
by_date_range
.into_iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>(),
self.0
.max_age
.as_mut_vec()
.into_iter()
.map(|(filter, vecs)| {
(
vecs,
by_date_range
.into_iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>(),
self.0
.term
.as_mut_vec()
.into_iter()
.map(|(filter, vecs)| {
(
vecs,
by_date_range
.into_iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>(),
self.0
.ge_amount
.as_mut_vec()
.into_iter()
.map(|(filter, vecs)| {
(
vecs,
by_size_range
.into_iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>(),
self.0
.lt_amount
.as_mut_vec()
.into_iter()
.map(|(filter, vecs)| {
(
vecs,
by_size_range
.into_iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>(),
]
.into_iter()
.flatten()
)
}))
.chain(self.0.max_age.iter_mut().map(|(filter, vecs)| {
(
vecs,
by_date_range
.iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
}))
.chain(self.0.term.iter_mut().map(|(filter, vecs)| {
(
vecs,
by_date_range
.iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
}))
.chain(self.0.ge_amount.iter_mut().map(|(filter, vecs)| {
(
vecs,
by_size_range
.iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
}))
.chain(self.0.lt_amount.iter_mut().map(|(filter, vecs)| {
(
vecs,
by_size_range
.iter()
.filter(|(other, _)| filter.includes(other))
.map(|(_, v)| v)
.collect::<Vec<_>>(),
)
}))
.try_for_each(|(vecs, stateful)| {
vecs.compute_from_stateful(starting_indexes, &stateful, exit)
})
@@ -1740,7 +1703,7 @@ impl Vecs {
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
self.as_mut_vecs()
self.iter_mut()
.into_iter()
.try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit))
}
@@ -1759,27 +1722,24 @@ impl Vecs {
dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
exit: &Exit,
) -> Result<()> {
self.0.as_boxed_mut_vecs().into_iter().try_for_each(|v| {
v.into_iter().try_for_each(|(_, v)| {
v.compute_rest_part2(
indexes,
price,
starting_indexes,
height_to_supply,
dateindex_to_supply,
height_to_market_cap,
dateindex_to_market_cap,
height_to_realized_cap,
dateindex_to_realized_cap,
exit,
)
})
self.iter_mut().into_iter().try_for_each(|(_, v)| {
v.compute_rest_part2(
indexes,
price,
starting_indexes,
height_to_supply,
dateindex_to_supply,
height_to_market_cap,
dateindex_to_market_cap,
height_to_realized_cap,
dateindex_to_realized_cap,
exit,
)
})
}
pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
self.as_mut_separate_vecs()
.into_iter()
self.iter_separate_mut()
.try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))
}
}