diff --git a/Cargo.lock b/Cargo.lock index 458c9f4f5..b93cdec42 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4119,8 +4119,6 @@ checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc" [[package]] name = "seqdb" version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c97f1528725c4bb77e7f804440e353ef2c55dd73dceffc0ef856873b01a5216b" dependencies = [ "allocative", "allocative_derive", @@ -4977,8 +4975,6 @@ checksum = "8f54a172d0620933a27a4360d3db3e2ae0dd6cceae9730751a036bbf182c4b23" [[package]] name = "vecdb" version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0f9d0664d3ddb92e67ecc155b748ba16bb2d0c04a92276a33be6eac1a38d533" dependencies = [ "allocative", "allocative_derive", @@ -4999,8 +4995,6 @@ dependencies = [ [[package]] name = "vecdb_derive" version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d263723d1fbfeed0a279d8983e6b7f58ece72a6fa2bf4772d630b72d1ba2b298" dependencies = [ "quote", "syn 2.0.106", diff --git a/Cargo.toml b/Cargo.toml index b4fe85362..cd4cb67a6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,10 +10,19 @@ package.repository = "https://github.com/bitcoinresearchkit/brk" package.readme = "README.md" package.rust-version = "1.89" +[profile.dev] +lto = "thin" +debug = true +codegen-units = 2 +opt-level = 3 +overflow-checks = true + [profile.release] lto = "fat" codegen-units = 1 panic = "abort" +strip = true +overflow-checks = false [profile.profiling] inherits = "release" @@ -22,6 +31,17 @@ debug = true [profile.dist] inherits = "release" +[profile.clippy] +inherits = "dev" +lto = "off" +codegen-units = 256 +opt-level = 0 +incremental = true +debug = false +overflow-checks = false +panic = "abort" +debug-assertions = false + [workspace.dependencies] allocative = { version = "0.3.4", features = ["parking_lot"] } allocative_derive = "0.3.3" @@ -55,8 +75,8 @@ serde_bytes = "0.11.17" serde_derive = "1.0.219" serde_json = { version = "1.0.143", features = ["float_roundtrip"] } tokio = { version = "1.47.1", features = ["rt-multi-thread"] } -# vecdb = { path = "../seqdb/crates/vecdb", features = ["derive"]} -vecdb = { version = "0.2.12", features = ["derive"]} +vecdb = { path = "../seqdb/crates/vecdb", features = ["derive"]} +# vecdb = { version = "0.2.12", features = ["derive"]} zerocopy = "0.8.27" zerocopy-derive = "0.8.27" diff --git a/crates/brk_computer/src/chain.rs b/crates/brk_computer/src/chain.rs index 38eabed54..da1562b71 100644 --- a/crates/brk_computer/src/chain.rs +++ b/crates/brk_computer/src/chain.rs @@ -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 { + let mut iter: Box> = 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::>() + ] + .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 } } diff --git a/crates/brk_computer/src/cointime.rs b/crates/brk_computer/src/cointime.rs index 33457aa2c..9ba700483 100644 --- a/crates/brk_computer/src/cointime.rs +++ b/crates/brk_computer/src/cointime.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = + 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 } } diff --git a/crates/brk_computer/src/constants.rs b/crates/brk_computer/src/constants.rs index def3bbc22..db1d9cd66 100644 --- a/crates/brk_computer/src/constants.rs +++ b/crates/brk_computer/src/constants.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = + 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 } } diff --git a/crates/brk_computer/src/fetched.rs b/crates/brk_computer/src/fetched.rs index 7accefb33..ee31b75a2 100644 --- a/crates/brk_computer/src/fetched.rs +++ b/crates/brk_computer/src/fetched.rs @@ -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 { + [ &self.dateindex_to_price_ohlc_in_cents as &dyn AnyCollectableVec, &self.height_to_price_ohlc_in_cents, ] + .into_iter() } } diff --git a/crates/brk_computer/src/grouped/builder_eager.rs b/crates/brk_computer/src/grouped/builder_eager.rs index 8c31b1a6b..c0ce9c1c0 100644 --- a/crates/brk_computer/src/grouped/builder_eager.rs +++ b/crates/brk_computer/src/grouped/builder_eager.rs @@ -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 { + let mut iter: Box> = + 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<()> { diff --git a/crates/brk_computer/src/grouped/builder_lazy.rs b/crates/brk_computer/src/grouped/builder_lazy.rs index 50fff16b3..1ce901b14 100644 --- a/crates/brk_computer/src/grouped/builder_lazy.rs +++ b/crates/brk_computer/src/grouped/builder_lazy.rs @@ -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 { + let mut iter: Box> = + 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 } } diff --git a/crates/brk_computer/src/grouped/from_dateindex.rs b/crates/brk_computer/src/grouped/from_dateindex.rs index e552c7ebf..a0c9a6562 100644 --- a/crates/brk_computer/src/grouped/from_dateindex.rs +++ b/crates/brk_computer/src/grouped/from_dateindex.rs @@ -143,21 +143,22 @@ where Ok(()) } - pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> { - [ + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = 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::>() + .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 } } diff --git a/crates/brk_computer/src/grouped/from_height.rs b/crates/brk_computer/src/grouped/from_height.rs index 959dba904..9b4248742 100644 --- a/crates/brk_computer/src/grouped/from_height.rs +++ b/crates/brk_computer/src/grouped/from_height.rs @@ -199,24 +199,24 @@ where Ok(()) } - pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> { - [ + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = 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::>() + .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 } } diff --git a/crates/brk_computer/src/grouped/from_height_strict.rs b/crates/brk_computer/src/grouped/from_height_strict.rs index 2866334d9..e8ae63d04 100644 --- a/crates/brk_computer/src/grouped/from_height_strict.rs +++ b/crates/brk_computer/src/grouped/from_height_strict.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + [&self.height as &dyn AnyCollectableVec] + .into_iter() + .chain(self.height_extra.iter_any_collectable()) + .chain(self.difficultyepoch.iter_any_collectable()) } } diff --git a/crates/brk_computer/src/grouped/from_txindex.rs b/crates/brk_computer/src/grouped/from_txindex.rs index a773f973d..d40901c90 100644 --- a/crates/brk_computer/src/grouped/from_txindex.rs +++ b/crates/brk_computer/src/grouped/from_txindex.rs @@ -226,25 +226,25 @@ where Ok(()) } - pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> { - [ + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = 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::>() + .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 } } diff --git a/crates/brk_computer/src/grouped/ratio_from_dateindex.rs b/crates/brk_computer/src/grouped/ratio_from_dateindex.rs index 1c1a96ce8..397fc2eb5 100644 --- a/crates/brk_computer/src/grouped/ratio_from_dateindex.rs +++ b/crates/brk_computer/src/grouped/ratio_from_dateindex.rs @@ -632,37 +632,132 @@ impl ComputedRatioVecsFromDateIndex { .collect::>() } - 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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = + 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 } } diff --git a/crates/brk_computer/src/grouped/sd_from_dateindex.rs b/crates/brk_computer/src/grouped/sd_from_dateindex.rs index ab6cf6126..cdd7c1630 100644 --- a/crates/brk_computer/src/grouped/sd_from_dateindex.rs +++ b/crates/brk_computer/src/grouped/sd_from_dateindex.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = + 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 } } diff --git a/crates/brk_computer/src/grouped/value_from_dateindex.rs b/crates/brk_computer/src/grouped/value_from_dateindex.rs index 58b57e27f..aaa93c3e5 100644 --- a/crates/brk_computer/src/grouped/value_from_dateindex.rs +++ b/crates/brk_computer/src/grouped/value_from_dateindex.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + 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())) } } diff --git a/crates/brk_computer/src/grouped/value_from_height.rs b/crates/brk_computer/src/grouped/value_from_height.rs index 0c72ec8d2..da250799f 100644 --- a/crates/brk_computer/src/grouped/value_from_height.rs +++ b/crates/brk_computer/src/grouped/value_from_height.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + 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())) } } diff --git a/crates/brk_computer/src/grouped/value_from_txindex.rs b/crates/brk_computer/src/grouped/value_from_txindex.rs index fd7ab2cf4..aed536721 100644 --- a/crates/brk_computer/src/grouped/value_from_txindex.rs +++ b/crates/brk_computer/src/grouped/value_from_txindex.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + [&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())) } } diff --git a/crates/brk_computer/src/grouped/value_height.rs b/crates/brk_computer/src/grouped/value_height.rs index 9917fc207..953d269d0 100644 --- a/crates/brk_computer/src/grouped/value_height.rs +++ b/crates/brk_computer/src/grouped/value_height.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + [&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)) } } diff --git a/crates/brk_computer/src/indexes.rs b/crates/brk_computer/src/indexes.rs index 3b77c44c2..0e194de0d 100644 --- a/crates/brk_computer/src/indexes.rs +++ b/crates/brk_computer/src/indexes.rs @@ -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 { + [ + &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() } } diff --git a/crates/brk_computer/src/lib.rs b/crates/brk_computer/src/lib.rs index d37064ffc..30cfdd514 100644 --- a/crates/brk_computer/src/lib.rs +++ b/crates/brk_computer/src/lib.rs @@ -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::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = + 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 { diff --git a/crates/brk_computer/src/market.rs b/crates/brk_computer/src/market.rs index 5eb5e2cfc..860e7e52c 100644 --- a/crates/brk_computer/src/market.rs +++ b/crates/brk_computer/src/market.rs @@ -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 { + let mut iter: Box> = 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::>() + ] + .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 } } diff --git a/crates/brk_computer/src/pools/mod.rs b/crates/brk_computer/src/pools/mod.rs index 90c37b52e..5c03114b7 100644 --- a/crates/brk_computer/src/pools/mod.rs +++ b/crates/brk_computer/src/pools/mod.rs @@ -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![&self.height_to_pool], - ] - .into_iter() - .flatten() - .collect::>() + pub fn iter_any_collectable(&self) -> impl Iterator { + [&self.height_to_pool as &dyn AnyCollectableVec] + .into_iter() + .chain( + self.vecs + .iter() + .flat_map(|(_, vecs)| vecs.iter_any_collectable()), + ) } } diff --git a/crates/brk_computer/src/pools/vecs.rs b/crates/brk_computer/src/pools/vecs.rs index 90fcdf38b..f613021dc 100644 --- a/crates/brk_computer/src/pools/vecs.rs +++ b/crates/brk_computer/src/pools/vecs.rs @@ -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 { + let mut iter: Box> = + 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 } } diff --git a/crates/brk_computer/src/price.rs b/crates/brk_computer/src/price.rs index 3cdc8af18..5cc39aeec 100644 --- a/crates/brk_computer/src/price.rs +++ b/crates/brk_computer/src/price.rs @@ -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 { + let mut iter: Box> = 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::>() + ] + .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 } } diff --git a/crates/brk_computer/src/stateful/address_cohort.rs b/crates/brk_computer/src/stateful/address_cohort.rs index cf8d3fda0..f6b0edea5 100644 --- a/crates/brk_computer/src/stateful/address_cohort.rs +++ b/crates/brk_computer/src/stateful/address_cohort.rs @@ -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 { + 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 - } -} diff --git a/crates/brk_computer/src/stateful/address_cohorts.rs b/crates/brk_computer/src/stateful/address_cohorts.rs index 94ba6f610..08a1fb994 100644 --- a/crates/brk_computer/src/stateful/address_cohorts.rs +++ b/crates/brk_computer/src/stateful/address_cohorts.rs @@ -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::>(), @@ -478,13 +477,12 @@ impl Vecs { .collect::>(), 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::>(), @@ -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>, 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)) } diff --git a/crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs b/crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs index 3e053cbe6..f0bc40391 100644 --- a/crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs +++ b/crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs @@ -75,11 +75,9 @@ impl AddressTypeToIndexesToAddressCount { Ok(()) } - pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> { + pub fn iter_any_collectable(&self) -> impl Iterator { self.0 - .as_typed_vec() - .into_iter() - .flat_map(|(_, v)| v.vecs()) - .collect::>() + .iter_typed() + .flat_map(|(_, v)| v.iter_any_collectable()) } } diff --git a/crates/brk_computer/src/stateful/addresstype/typeindex_tree.rs b/crates/brk_computer/src/stateful/addresstype/typeindex_tree.rs index 939fd2c13..b78d5a977 100644 --- a/crates/brk_computer/src/stateful/addresstype/typeindex_tree.rs +++ b/crates/brk_computer/src/stateful/addresstype/typeindex_tree.rs @@ -27,6 +27,10 @@ impl AddressTypeToTypeIndexTree { mem::swap(own, other); } } + + pub fn unwrap(self) -> ByAddressType> { + self.0 + } } impl Default for AddressTypeToTypeIndexTree { diff --git a/crates/brk_computer/src/stateful/addresstype/vec.rs b/crates/brk_computer/src/stateful/addresstype/vec.rs index 1693e5535..166a54c03 100644 --- a/crates/brk_computer/src/stateful/addresstype/vec.rs +++ b/crates/brk_computer/src/stateful/addresstype/vec.rs @@ -38,6 +38,10 @@ impl AddressTypeToVec { mem::swap(own, other); } } + + pub fn unwrap(self) -> ByAddressType> { + self.0 + } } impl Default for AddressTypeToVec { diff --git a/crates/brk_computer/src/stateful/common.rs b/crates/brk_computer/src/stateful/common.rs index aa57dbdf4..d98a4e231 100644 --- a/crates/brk_computer/src/stateful/common.rs +++ b/crates/brk_computer/src/stateful/common.rs @@ -3468,333 +3468,746 @@ impl Vecs { Ok(()) } - pub fn vecs(&self) -> Vec<&dyn AnyCollectableVec> { - [ - vec![ - &self.height_to_supply as &dyn AnyCollectableVec, - &self.height_to_utxo_count, - &self.height_to_satblocks_destroyed, + pub fn iter_any_collectable(&self) -> impl Iterator { + let mut iter: Box> = Box::new( + [ + &self.height_to_satblocks_destroyed as &dyn AnyCollectableVec, &self.height_to_satdays_destroyed, - ], - self.height_to_realized_cap - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.height_to_supply_value.vecs(), - self.height_to_supply_half_value.vecs(), - self.indexes_to_supply.vecs(), - self.indexes_to_utxo_count.vecs(), - self.indexes_to_realized_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_realized_price - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_realized_value - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_realized_price_extra - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_realized_profit - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.indexes_to_realized_profit - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_realized_loss - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.indexes_to_realized_loss - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_neg_realized_loss - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_value_created - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.indexes_to_value_created - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_adjusted_value_created - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.indexes_to_adjusted_value_created - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_value_destroyed - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.dateindex_to_sopr - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.dateindex_to_sopr_7d_ema - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.dateindex_to_sopr_30d_ema - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.dateindex_to_adjusted_sopr - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.dateindex_to_adjusted_sopr_7d_ema - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.dateindex_to_adjusted_sopr_30d_ema - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.indexes_to_value_destroyed - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_adjusted_value_destroyed - .as_ref() - .map_or(vec![], |v| vec![v as &dyn AnyCollectableVec]), - self.indexes_to_adjusted_value_destroyed - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_realized_cap_30d_delta - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_net_realized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.dateindex_to_sell_side_risk_ratio - .as_ref() - .map_or(vec![], |v| vec![v]), - self.dateindex_to_sell_side_risk_ratio_7d_ema - .as_ref() - .map_or(vec![], |v| vec![v]), - self.dateindex_to_sell_side_risk_ratio_30d_ema - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_supply_in_profit - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_supply_in_loss - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_supply_breakeven - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_unrealized_profit - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_unrealized_loss - .as_ref() - .map_or(vec![], |v| vec![v]), - self.dateindex_to_supply_in_profit - .as_ref() - .map_or(vec![], |v| vec![v]), - self.dateindex_to_supply_in_loss - .as_ref() - .map_or(vec![], |v| vec![v]), - self.dateindex_to_supply_breakeven - .as_ref() - .map_or(vec![], |v| vec![v]), - self.dateindex_to_unrealized_profit - .as_ref() - .map_or(vec![], |v| vec![v]), - self.dateindex_to_unrealized_loss - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_min_price_paid - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_max_price_paid - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_supply_in_profit - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_in_loss - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_breakeven - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_unrealized_profit - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_unrealized_loss - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_total_realized_pnl - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_total_realized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_min_price_paid - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_max_price_paid - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_half.vecs(), - self.height_to_unrealized_profit_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_unrealized_loss_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_neg_unrealized_loss_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_net_unrealized_pnl_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_unrealized_profit_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_unrealized_loss_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_neg_unrealized_loss_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_net_unrealized_pnl_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_unrealized_profit_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_unrealized_loss_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_neg_unrealized_loss_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_net_unrealized_pnl_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_unrealized_profit_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_unrealized_loss_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_neg_unrealized_loss_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_net_unrealized_pnl_rel_to_own_total_unrealized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_neg_unrealized_loss - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_neg_unrealized_loss - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_net_unrealized_pnl - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_net_unrealized_pnl - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_unrealized_profit_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_unrealized_loss_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_neg_unrealized_loss_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_net_unrealized_pnl_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_unrealized_profit_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_unrealized_loss_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_neg_unrealized_loss_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_net_unrealized_pnl_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_realized_profit_rel_to_realized_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_realized_loss_rel_to_realized_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_net_realized_pnl_rel_to_realized_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_supply_breakeven_value - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_supply_in_loss_value - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_supply_in_profit_value - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_supply_breakeven_rel_to_own_supply - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_supply_in_loss_rel_to_own_supply - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_supply_in_profit_rel_to_own_supply - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_supply_breakeven_rel_to_own_supply - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_in_loss_rel_to_own_supply - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_in_profit_rel_to_own_supply - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_rel_to_circulating_supply - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.height_to_supply_breakeven_rel_to_circulating_supply - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_supply_in_loss_rel_to_circulating_supply - .as_ref() - .map_or(vec![], |v| vec![v]), - self.height_to_supply_in_profit_rel_to_circulating_supply - .as_ref() - .map_or(vec![], |v| vec![v]), - self.indexes_to_supply_breakeven_rel_to_circulating_supply - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_in_loss_rel_to_circulating_supply - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_supply_in_profit_rel_to_circulating_supply - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_coinblocks_destroyed.vecs(), - self.indexes_to_coindays_destroyed.vecs(), - self.indexes_to_net_realized_pnl_cumulative_30d_delta - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_realized_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - self.indexes_to_realized_cap_rel_to_own_market_cap - .as_ref() - .map_or(vec![], |v| v.vecs()), - ] - .into_iter() - .flatten() - .collect::>() + &self.height_to_supply, + &self.height_to_utxo_count, + ] + .into_iter(), + ); + + iter = Box::new( + iter.chain( + self.dateindex_to_adjusted_sopr + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_adjusted_sopr_30d_ema + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_adjusted_sopr_7d_ema + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_sell_side_risk_ratio + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_sell_side_risk_ratio_30d_ema + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_sell_side_risk_ratio_7d_ema + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_sopr + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_sopr_30d_ema + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_sopr_7d_ema + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_supply_breakeven + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_supply_in_loss + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_supply_in_profit + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_unrealized_loss + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.dateindex_to_unrealized_profit + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_adjusted_value_created + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_adjusted_value_destroyed + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_max_price_paid + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_min_price_paid + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_neg_unrealized_loss + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_neg_unrealized_loss_rel_to_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_neg_unrealized_loss_rel_to_own_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_neg_unrealized_loss_rel_to_own_total_unrealized_pnl + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_net_unrealized_pnl + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_net_unrealized_pnl_rel_to_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_net_unrealized_pnl_rel_to_own_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_net_unrealized_pnl_rel_to_own_total_unrealized_pnl + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_realized_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_realized_loss + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_realized_profit + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_breakeven + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_breakeven_rel_to_circulating_supply + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_breakeven_rel_to_own_supply + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_breakeven_value + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new(iter.chain(self.height_to_supply_half_value.iter_any_collectable())); + iter = Box::new( + iter.chain( + self.height_to_supply_in_loss + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_in_loss_rel_to_circulating_supply + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_in_loss_rel_to_own_supply + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_in_loss_value + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_in_profit + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_in_profit_rel_to_circulating_supply + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_in_profit_rel_to_own_supply + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_supply_in_profit_value + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new(iter.chain(self.height_to_supply_value.iter_any_collectable())); + iter = Box::new( + iter.chain( + self.height_to_total_realized_pnl + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_total_unrealized_pnl + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_loss + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_loss_rel_to_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_loss_rel_to_own_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_loss_rel_to_own_total_unrealized_pnl + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_profit + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_profit_rel_to_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_profit_rel_to_own_market_cap + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_unrealized_profit_rel_to_own_total_unrealized_pnl + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_value_created + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.height_to_value_destroyed + .iter() + .map(|v| v as &dyn AnyCollectableVec), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_adjusted_value_created + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_adjusted_value_destroyed + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new(iter.chain(self.indexes_to_coinblocks_destroyed.iter_any_collectable())); + iter = Box::new(iter.chain(self.indexes_to_coindays_destroyed.iter_any_collectable())); + iter = Box::new( + iter.chain( + self.indexes_to_max_price_paid + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_min_price_paid + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_neg_realized_loss + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_neg_unrealized_loss + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_neg_unrealized_loss_rel_to_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_neg_unrealized_loss_rel_to_own_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_neg_unrealized_loss_rel_to_own_total_unrealized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_realized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_realized_pnl_cumulative_30d_delta + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_realized_pnl_cumulative_30d_delta_rel_to_realized_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_realized_pnl_rel_to_realized_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_unrealized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_unrealized_pnl_rel_to_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_unrealized_pnl_rel_to_own_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_net_unrealized_pnl_rel_to_own_total_unrealized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_cap_30d_delta + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_cap_rel_to_own_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_loss + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_loss_rel_to_realized_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_price + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_price_extra + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_profit + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_profit_rel_to_realized_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_realized_value + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new(iter.chain(self.indexes_to_supply.iter_any_collectable())); + iter = Box::new( + iter.chain( + self.indexes_to_supply_breakeven + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_breakeven_rel_to_circulating_supply + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_breakeven_rel_to_own_supply + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new(iter.chain(self.indexes_to_supply_half.iter_any_collectable())); + iter = Box::new( + iter.chain( + self.indexes_to_supply_in_loss + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_in_loss_rel_to_circulating_supply + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_in_loss_rel_to_own_supply + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_in_profit + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_in_profit_rel_to_circulating_supply + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_in_profit_rel_to_own_supply + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_supply_rel_to_circulating_supply + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_total_realized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_total_unrealized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_loss + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_loss_rel_to_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_loss_rel_to_own_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_loss_rel_to_own_total_unrealized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_profit + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_profit_rel_to_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_profit_rel_to_own_market_cap + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_unrealized_profit_rel_to_own_total_unrealized_pnl + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new(iter.chain(self.indexes_to_utxo_count.iter_any_collectable())); + iter = Box::new( + iter.chain( + self.indexes_to_value_created + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + iter = Box::new( + iter.chain( + self.indexes_to_value_destroyed + .iter() + .flat_map(|v| v.iter_any_collectable()), + ), + ); + + iter } } diff --git a/crates/brk_computer/src/stateful/mod.rs b/crates/brk_computer/src/stateful/mod.rs index d489ede98..c040d52f6 100644 --- a/crates/brk_computer/src/stateful/mod.rs +++ b/crates/brk_computer/src/stateful/mod.rs @@ -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::>(); + let mut separate_address_vecs = + self.address_cohorts.iter_separate_mut().collect::>(); 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::>(), 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::>(), 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, >, - mut addresstype_to_typeindex_to_emptyaddressdata: AddressTypeToTypeIndexTree< + addresstype_to_typeindex_to_emptyaddressdata: AddressTypeToTypeIndexTree< WithAddressDataSource, >, 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::>(), - self.address_cohorts - .vecs() - .into_iter() - .flat_map(|v| v.vecs()) - .collect::>(), - 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::>(), - self.addresstype_to_height_to_empty_addr_count - .as_typed_vec() - .into_iter() - .map(|(_, v)| v as &dyn AnyCollectableVec) - .collect::>(), - 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 { + let mut iter: Box> = 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::>() + ] + .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, @@ -1920,7 +1940,7 @@ impl AddressTypeToVec<(TypeIndex, Sats)> { WithAddressDataSource, >, ) { - 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, >, ) -> 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 diff --git a/crates/brk_computer/src/stateful/trait.rs b/crates/brk_computer/src/stateful/trait.rs index 5de507780..173f9f652 100644 --- a/crates/brk_computer/src/stateful/trait.rs +++ b/crates/brk_computer/src/stateful/trait.rs @@ -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 { diff --git a/crates/brk_computer/src/stateful/utxo_cohort.rs b/crates/brk_computer/src/stateful/utxo_cohort.rs index 204dd66a2..784f2ad41 100644 --- a/crates/brk_computer/src/stateful/utxo_cohort.rs +++ b/crates/brk_computer/src/stateful/utxo_cohort.rs @@ -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 { diff --git a/crates/brk_computer/src/stateful/utxo_cohorts.rs b/crates/brk_computer/src/stateful/utxo_cohorts.rs index 0eb453d2f..9770e4d32 100644 --- a/crates/brk_computer/src/stateful/utxo_cohorts.rs +++ b/crates/brk_computer/src/stateful/utxo_cohorts.rs @@ -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::>(); @@ -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::>(); 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::>(), + )] + .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::>(), - )], - 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::>(), - ) - }) - .collect::>(), - 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::>(), - ) - }) - .collect::>(), - 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::>(), - ) - }) - .collect::>(), - 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::>(), - ) - }) - .collect::>(), - 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::>(), - ) - }) - .collect::>(), - ] - .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::>(), + ) + })) + .chain(self.0.term.iter_mut().map(|(filter, vecs)| { + ( + vecs, + by_date_range + .iter() + .filter(|(other, _)| filter.includes(other)) + .map(|(_, v)| v) + .collect::>(), + ) + })) + .chain(self.0.ge_amount.iter_mut().map(|(filter, vecs)| { + ( + vecs, + by_size_range + .iter() + .filter(|(other, _)| filter.includes(other)) + .map(|(_, v)| v) + .collect::>(), + ) + })) + .chain(self.0.lt_amount.iter_mut().map(|(filter, vecs)| { + ( + vecs, + by_size_range + .iter() + .filter(|(other, _)| filter.includes(other)) + .map(|(_, v)| v) + .collect::>(), + ) + })) .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>, 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)) } } diff --git a/crates/brk_interface/src/vecs.rs b/crates/brk_interface/src/vecs.rs index d42810a39..58359a907 100644 --- a/crates/brk_interface/src/vecs.rs +++ b/crates/brk_interface/src/vecs.rs @@ -2,8 +2,8 @@ use std::collections::BTreeMap; use brk_computer::Computer; use brk_indexer::Indexer; -use vecdb::AnyCollectableVec; use derive_deref::{Deref, DerefMut}; +use vecdb::AnyCollectableVec; use crate::pagination::{PaginatedIndexParam, PaginationParam}; @@ -33,7 +33,9 @@ impl<'a> Vecs<'a> { .into_iter() .for_each(|vec| this.insert(vec)); - computer.vecs().into_iter().for_each(|vec| this.insert(vec)); + computer + .iter_any_collectable() + .for_each(|vec| this.insert(vec)); let mut ids = this.id_to_index_to_vec.keys().cloned().collect::>(); diff --git a/crates/brk_structs/src/groups/address.rs b/crates/brk_structs/src/groups/address.rs index 09896f12f..06bfb3132 100644 --- a/crates/brk_structs/src/groups/address.rs +++ b/crates/brk_structs/src/groups/address.rs @@ -8,47 +8,28 @@ pub struct AddressGroups { } impl AddressGroups { - pub fn as_boxed_mut_vecs(&mut self) -> Vec> { - vec![ - Box::new(self.ge_amount.as_mut_vec()), - Box::new(self.amount_range.as_mut_vec()), - Box::new(self.lt_amount.as_mut_vec()), - ] - } - - pub fn as_mut_vecs(&mut self) -> Vec<&mut T> { + pub fn iter_mut(&mut self) -> impl Iterator { self.ge_amount - .as_mut_vec() - .into_iter() - .chain(self.amount_range.as_mut_vec()) - .chain(self.lt_amount.as_mut_vec()) - .collect::>() + .iter_mut() + .chain(self.amount_range.iter_mut()) + .chain(self.lt_amount.iter_mut()) } - pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> { - self.amount_range - .as_mut_vec() - .into_iter() - .collect::>() + pub fn iter_separate_mut(&mut self) -> impl Iterator { + self.amount_range.iter_mut() } - pub fn as_mut_overlapping_vecs(&mut self) -> Vec<&mut T> { - self.lt_amount - .as_mut_vec() - .into_iter() - .chain(self.ge_amount.as_mut_vec()) - .collect::>() + pub fn iter_overlapping_mut(&mut self) -> impl Iterator { + self.lt_amount.iter_mut().chain(self.ge_amount.iter_mut()) } } impl AddressGroups<(GroupFilter, T)> { - pub fn vecs(&self) -> Vec<&T> { + pub fn iter_right(&self) -> impl Iterator { self.amount_range - .vecs() - .into_iter() - .chain(self.lt_amount.vecs()) - .chain(self.ge_amount.vecs()) - .collect::>() + .iter_right() + .chain(self.lt_amount.iter_right()) + .chain(self.ge_amount.iter_right()) } } diff --git a/crates/brk_structs/src/groups/by_address_type.rs b/crates/brk_structs/src/groups/by_address_type.rs index c157c1290..408112e67 100644 --- a/crates/brk_structs/src/groups/by_address_type.rs +++ b/crates/brk_structs/src/groups/by_address_type.rs @@ -1,7 +1,4 @@ -use std::{ - mem, - ops::{Add, AddAssign}, -}; +use std::ops::{Add, AddAssign}; use super::GroupFilter; use crate::OutputType; @@ -51,7 +48,21 @@ impl ByAddressType { } } - pub fn as_mut_vec(&mut self) -> [&mut T; 8] { + pub fn iter(&self) -> impl Iterator { + [ + &self.p2pk65, + &self.p2pk33, + &self.p2pkh, + &self.p2sh, + &self.p2wpkh, + &self.p2wsh, + &self.p2tr, + &self.p2a, + ] + .into_iter() + } + + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self.p2pk65, &mut self.p2pk33, @@ -62,9 +73,10 @@ impl ByAddressType { &mut self.p2tr, &mut self.p2a, ] + .into_iter() } - pub fn as_typed_vec(&self) -> [(OutputType, &T); 8] { + pub fn iter_typed(&self) -> impl Iterator { [ (OutputType::P2PK65, &self.p2pk65), (OutputType::P2PK33, &self.p2pk33), @@ -75,9 +87,24 @@ impl ByAddressType { (OutputType::P2TR, &self.p2tr), (OutputType::P2A, &self.p2a), ] + .into_iter() } - pub fn as_mut_typed_vec(&mut self) -> [(OutputType, &mut T); 8] { + pub fn into_iter_typed(self) -> impl Iterator { + [ + (OutputType::P2PK65, self.p2pk65), + (OutputType::P2PK33, self.p2pk33), + (OutputType::P2PKH, self.p2pkh), + (OutputType::P2SH, self.p2sh), + (OutputType::P2WPKH, self.p2wpkh), + (OutputType::P2WSH, self.p2wsh), + (OutputType::P2TR, self.p2tr), + (OutputType::P2A, self.p2a), + ] + .into_iter() + } + + pub fn iter_typed_mut(&mut self) -> impl Iterator { [ (OutputType::P2PK65, &mut self.p2pk65), (OutputType::P2PK33, &mut self.p2pk33), @@ -88,27 +115,12 @@ impl ByAddressType { (OutputType::P2TR, &mut self.p2tr), (OutputType::P2A, &mut self.p2a), ] - } - - pub fn into_typed_vec(&mut self) -> [(OutputType, T); 8] - where - T: Default, - { - [ - (OutputType::P2PK65, mem::take(&mut self.p2pk65)), - (OutputType::P2PK33, mem::take(&mut self.p2pk33)), - (OutputType::P2PKH, mem::take(&mut self.p2pkh)), - (OutputType::P2SH, mem::take(&mut self.p2sh)), - (OutputType::P2WPKH, mem::take(&mut self.p2wpkh)), - (OutputType::P2WSH, mem::take(&mut self.p2wsh)), - (OutputType::P2TR, mem::take(&mut self.p2tr)), - (OutputType::P2A, mem::take(&mut self.p2a)), - ] + .into_iter() } } impl ByAddressType<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 8] { + pub fn iter_right(&self) -> impl Iterator { [ &self.p2pk65.1, &self.p2pk33.1, @@ -119,6 +131,7 @@ impl ByAddressType<(GroupFilter, T)> { &self.p2tr.1, &self.p2a.1, ] + .into_iter() } } @@ -174,7 +187,7 @@ where impl ByAddressType> { pub fn take(&mut self) { - self.as_mut_vec().into_iter().for_each(|opt| { + self.iter_mut().for_each(|opt| { opt.take(); }); } diff --git a/crates/brk_structs/src/groups/by_age_range.rs b/crates/brk_structs/src/groups/by_age_range.rs index 676cffbbb..54d82afdf 100644 --- a/crates/brk_structs/src/groups/by_age_range.rs +++ b/crates/brk_structs/src/groups/by_age_range.rs @@ -52,7 +52,7 @@ impl From> for ByAgeRange<(GroupFilter, T)> { } impl ByAgeRange { - pub fn as_vec(&mut self) -> [&T; 20] { + pub fn iter(&self) -> impl Iterator { [ &self.up_to_1d, &self._1d_to_1w, @@ -75,9 +75,10 @@ impl ByAgeRange { &self._12y_to_15y, &self.from_15y, ] + .into_iter() } - pub fn as_mut_vec(&mut self) -> [&mut T; 20] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self.up_to_1d, &mut self._1d_to_1w, @@ -100,11 +101,12 @@ impl ByAgeRange { &mut self._12y_to_15y, &mut self.from_15y, ] + .into_iter() } } impl ByAgeRange<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 20] { + pub fn iter_right(&self) -> impl Iterator { [ &self.up_to_1d.1, &self._1d_to_1w.1, @@ -127,5 +129,6 @@ impl ByAgeRange<(GroupFilter, T)> { &self._12y_to_15y.1, &self.from_15y.1, ] + .into_iter() } } diff --git a/crates/brk_structs/src/groups/by_amount_range.rs b/crates/brk_structs/src/groups/by_amount_range.rs index 6fdd0594d..a62dae976 100644 --- a/crates/brk_structs/src/groups/by_amount_range.rs +++ b/crates/brk_structs/src/groups/by_amount_range.rs @@ -124,7 +124,7 @@ impl ByAmountRange { } } - pub fn as_vec(&self) -> [&T; 15] { + pub fn iter(&self) -> impl Iterator { [ &self._0sats, &self._1sat_to_10sats, @@ -142,9 +142,10 @@ impl ByAmountRange { &self._10k_btc_to_100k_btc, &self._100k_btc_or_more, ] + .into_iter() } - pub fn as_typed_vec(&self) -> [(Sats, &T); 15] { + pub fn iter_typed(&self) -> impl Iterator { [ (Sats::ZERO, &self._0sats), (Sats::_1, &self._1sat_to_10sats), @@ -162,9 +163,10 @@ impl ByAmountRange { (Sats::_10K_BTC, &self._10k_btc_to_100k_btc), (Sats::_100K_BTC, &self._100k_btc_or_more), ] + .into_iter() } - pub fn as_mut_vec(&mut self) -> [&mut T; 15] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self._0sats, &mut self._1sat_to_10sats, @@ -182,11 +184,12 @@ impl ByAmountRange { &mut self._10k_btc_to_100k_btc, &mut self._100k_btc_or_more, ] + .into_iter() } } impl ByAmountRange<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 15] { + pub fn iter_right(&self) -> impl Iterator { [ &self._0sats.1, &self._1sat_to_10sats.1, @@ -204,6 +207,7 @@ impl ByAmountRange<(GroupFilter, T)> { &self._10k_btc_to_100k_btc.1, &self._100k_btc_or_more.1, ] + .into_iter() } } diff --git a/crates/brk_structs/src/groups/by_epoch.rs b/crates/brk_structs/src/groups/by_epoch.rs index 4132fdace..2de66dc83 100644 --- a/crates/brk_structs/src/groups/by_epoch.rs +++ b/crates/brk_structs/src/groups/by_epoch.rs @@ -24,7 +24,7 @@ impl From> for ByEpoch<(GroupFilter, T)> { } impl ByEpoch { - pub fn as_mut_vec(&mut self) -> [&mut T; 5] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self._0, &mut self._1, @@ -32,6 +32,7 @@ impl ByEpoch { &mut self._3, &mut self._4, ] + .into_iter() } pub fn mut_vec_from_height(&mut self, height: Height) -> &mut T { @@ -53,7 +54,7 @@ impl ByEpoch { } impl ByEpoch<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 5] { - [&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1] + pub fn iter_right(&self) -> impl Iterator { + [&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1].into_iter() } } diff --git a/crates/brk_structs/src/groups/by_ge_amount.rs b/crates/brk_structs/src/groups/by_ge_amount.rs index d358dec17..670f02001 100644 --- a/crates/brk_structs/src/groups/by_ge_amount.rs +++ b/crates/brk_structs/src/groups/by_ge_amount.rs @@ -20,7 +20,7 @@ pub struct ByGreatEqualAmount { } impl ByGreatEqualAmount { - pub fn as_mut_vec(&mut self) -> [&mut T; 13] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self._1sat, &mut self._10sats, @@ -36,11 +36,12 @@ impl ByGreatEqualAmount { &mut self._1k_btc, &mut self._10k_btc, ] + .into_iter() } } impl ByGreatEqualAmount<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 13] { + pub fn iter_right(&self) -> impl Iterator { [ &self._1sat.1, &self._10sats.1, @@ -56,6 +57,7 @@ impl ByGreatEqualAmount<(GroupFilter, T)> { &self._1k_btc.1, &self._10k_btc.1, ] + .into_iter() } } diff --git a/crates/brk_structs/src/groups/by_lt_amount.rs b/crates/brk_structs/src/groups/by_lt_amount.rs index 8fc2191fe..31dd380f7 100644 --- a/crates/brk_structs/src/groups/by_lt_amount.rs +++ b/crates/brk_structs/src/groups/by_lt_amount.rs @@ -20,7 +20,7 @@ pub struct ByLowerThanAmount { } impl ByLowerThanAmount { - pub fn as_mut_vec(&mut self) -> [&mut T; 13] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self._10sats, &mut self._100sats, @@ -36,11 +36,12 @@ impl ByLowerThanAmount { &mut self._10k_btc, &mut self._100k_btc, ] + .into_iter() } } impl ByLowerThanAmount<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 13] { + pub fn iter_right(&self) -> impl Iterator { [ &self._10sats.1, &self._100sats.1, @@ -56,6 +57,7 @@ impl ByLowerThanAmount<(GroupFilter, T)> { &self._10k_btc.1, &self._100k_btc.1, ] + .into_iter() } } diff --git a/crates/brk_structs/src/groups/by_max_age.rs b/crates/brk_structs/src/groups/by_max_age.rs index 225844fc7..240ce1e1b 100644 --- a/crates/brk_structs/src/groups/by_max_age.rs +++ b/crates/brk_structs/src/groups/by_max_age.rs @@ -23,7 +23,7 @@ pub struct ByMaxAge { } impl ByMaxAge { - pub fn as_mut_vec(&mut self) -> [&mut T; 18] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self._1w, &mut self._1m, @@ -44,11 +44,12 @@ impl ByMaxAge { &mut self._12y, &mut self._15y, ] + .into_iter() } } impl ByMaxAge<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 18] { + pub fn iter_right(&self) -> impl Iterator { [ &self._1w.1, &self._1m.1, @@ -69,6 +70,7 @@ impl ByMaxAge<(GroupFilter, T)> { &self._12y.1, &self._15y.1, ] + .into_iter() } } diff --git a/crates/brk_structs/src/groups/by_min_age.rs b/crates/brk_structs/src/groups/by_min_age.rs index 6a02fb96f..017a75250 100644 --- a/crates/brk_structs/src/groups/by_min_age.rs +++ b/crates/brk_structs/src/groups/by_min_age.rs @@ -23,7 +23,7 @@ pub struct ByMinAge { } impl ByMinAge { - pub fn as_mut_vec(&mut self) -> [&mut T; 18] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self._1d, &mut self._1w, @@ -44,11 +44,12 @@ impl ByMinAge { &mut self._10y, &mut self._12y, ] + .into_iter() } } impl ByMinAge<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 18] { + pub fn iter_right(&self) -> impl Iterator { [ &self._1d.1, &self._1w.1, @@ -69,6 +70,7 @@ impl ByMinAge<(GroupFilter, T)> { &self._10y.1, &self._12y.1, ] + .into_iter() } } diff --git a/crates/brk_structs/src/groups/by_spendable_type.rs b/crates/brk_structs/src/groups/by_spendable_type.rs index c97042b19..4caf94540 100644 --- a/crates/brk_structs/src/groups/by_spendable_type.rs +++ b/crates/brk_structs/src/groups/by_spendable_type.rs @@ -37,7 +37,7 @@ impl BySpendableType { } } - pub fn as_mut_vec(&mut self) -> [&mut T; 11] { + pub fn iter_mut(&mut self) -> impl Iterator { [ &mut self.p2pk65, &mut self.p2pk33, @@ -51,9 +51,10 @@ impl BySpendableType { &mut self.unknown, &mut self.empty, ] + .into_iter() } - pub fn as_typed_vec(&self) -> [(OutputType, &T); 11] { + pub fn iter_typed(&self) -> impl Iterator { [ (OutputType::P2PK65, &self.p2pk65), (OutputType::P2PK33, &self.p2pk33), @@ -67,11 +68,12 @@ impl BySpendableType { (OutputType::Unknown, &self.unknown), (OutputType::Empty, &self.empty), ] + .into_iter() } } impl BySpendableType<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 11] { + pub fn iter_right(&self) -> impl Iterator { [ &self.p2pk65.1, &self.p2pk33.1, @@ -85,6 +87,7 @@ impl BySpendableType<(GroupFilter, T)> { &self.unknown.1, &self.empty.1, ] + .into_iter() } } diff --git a/crates/brk_structs/src/groups/by_term.rs b/crates/brk_structs/src/groups/by_term.rs index 9e3978f0b..7aacfae09 100644 --- a/crates/brk_structs/src/groups/by_term.rs +++ b/crates/brk_structs/src/groups/by_term.rs @@ -7,14 +7,14 @@ pub struct ByTerm { } impl ByTerm { - pub fn as_mut_vec(&mut self) -> [&mut T; 2] { - [&mut self.short, &mut self.long] + pub fn iter_mut(&mut self) -> impl Iterator { + [&mut self.short, &mut self.long].into_iter() } } impl ByTerm<(GroupFilter, T)> { - pub fn vecs(&self) -> [&T; 2] { - [&self.short.1, &self.long.1] + pub fn iter_right(&self) -> impl Iterator { + [&self.short.1, &self.long.1].into_iter() } } diff --git a/crates/brk_structs/src/groups/utxo.rs b/crates/brk_structs/src/groups/utxo.rs index 2d240dce2..4fac770ba 100644 --- a/crates/brk_structs/src/groups/utxo.rs +++ b/crates/brk_structs/src/groups/utxo.rs @@ -18,72 +18,52 @@ pub struct UTXOGroups { } impl UTXOGroups { - pub fn as_boxed_mut_vecs(&mut self) -> Vec> { - vec![ - Box::new([&mut self.all]), - Box::new(self.term.as_mut_vec()), - Box::new(self.max_age.as_mut_vec()), - Box::new(self.min_age.as_mut_vec()), - Box::new(self.ge_amount.as_mut_vec()), - Box::new(self.age_range.as_mut_vec()), - Box::new(self.epoch.as_mut_vec()), - Box::new(self.amount_range.as_mut_vec()), - Box::new(self.lt_amount.as_mut_vec()), - Box::new(self._type.as_mut_vec()), - ] - } - - pub fn as_mut_vecs(&mut self) -> Vec<&mut T> { + pub fn iter_mut(&mut self) -> impl Iterator { [&mut self.all] .into_iter() - .chain(self.term.as_mut_vec()) - .chain(self.max_age.as_mut_vec()) - .chain(self.min_age.as_mut_vec()) - .chain(self.ge_amount.as_mut_vec()) - .chain(self.age_range.as_mut_vec()) - .chain(self.epoch.as_mut_vec()) - .chain(self.amount_range.as_mut_vec()) - .chain(self.lt_amount.as_mut_vec()) - .chain(self._type.as_mut_vec()) - .collect::>() + .chain(self.term.iter_mut()) + .chain(self.max_age.iter_mut()) + .chain(self.min_age.iter_mut()) + .chain(self.ge_amount.iter_mut()) + .chain(self.age_range.iter_mut()) + .chain(self.epoch.iter_mut()) + .chain(self.amount_range.iter_mut()) + .chain(self.lt_amount.iter_mut()) + .chain(self._type.iter_mut()) } - pub fn as_mut_separate_vecs(&mut self) -> Vec<&mut T> { + pub fn iter_separate_mut(&mut self) -> impl Iterator { self.age_range - .as_mut_vec() - .into_iter() - .chain(self.epoch.as_mut_vec()) - .chain(self.amount_range.as_mut_vec()) - .chain(self._type.as_mut_vec()) - .collect::>() + .iter_mut() + .chain(self.epoch.iter_mut()) + .chain(self.amount_range.iter_mut()) + .chain(self._type.iter_mut()) } - pub fn as_mut_overlapping_vecs(&mut self) -> Vec<&mut T> { + pub fn iter_overlapping_mut(&mut self) -> impl Iterator { [&mut self.all] .into_iter() - .chain(self.term.as_mut_vec()) - .chain(self.max_age.as_mut_vec()) - .chain(self.min_age.as_mut_vec()) - .chain(self.lt_amount.as_mut_vec()) - .chain(self.ge_amount.as_mut_vec()) - .collect::>() + .chain(self.term.iter_mut()) + .chain(self.max_age.iter_mut()) + .chain(self.min_age.iter_mut()) + .chain(self.lt_amount.iter_mut()) + .chain(self.ge_amount.iter_mut()) } } impl UTXOGroups<(GroupFilter, T)> { - pub fn vecs(&self) -> Vec<&T> { + pub fn iter_right(&self) -> impl Iterator { [&self.all.1] .into_iter() - .chain(self.term.vecs()) - .chain(self.max_age.vecs()) - .chain(self.min_age.vecs()) - .chain(self.age_range.vecs()) - .chain(self.epoch.vecs()) - .chain(self.amount_range.vecs()) - .chain(self._type.vecs()) - .chain(self.lt_amount.vecs()) - .chain(self.ge_amount.vecs()) - .collect::>() + .chain(self.term.iter_right()) + .chain(self.max_age.iter_right()) + .chain(self.min_age.iter_right()) + .chain(self.age_range.iter_right()) + .chain(self.epoch.iter_right()) + .chain(self.amount_range.iter_right()) + .chain(self._type.iter_right()) + .chain(self.lt_amount.iter_right()) + .chain(self.ge_amount.iter_right()) } }