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

global: ivecs

Browse Source
This commit is contained in:
nym21
2025-10-05 16:05:17 +02:00
parent 5fde0101bf
commit b622285999
59 changed files with 1106 additions and 2240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
Cargo.lock generated
View File

@@ -93,9 +93,9 @@ dependencies = [
[[package]]
name = "anstream"
version = "0.6.20"
version = "0.6.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
dependencies = [
"anstyle",
"anstyle-parse",
@@ -619,6 +619,7 @@ dependencies = [
"brk_parser",
"brk_store",
"brk_structs",
"brk_vecs",
"derive_deref",
"log",
"pco",
@@ -667,7 +668,6 @@ dependencies = [
"brk_store",
"brk_structs",
"brk_vecs",
"brk_vecs_derive",
"fjall",
"log",
"rayon",
@@ -728,15 +728,15 @@ dependencies = [
"brk_structs",
"crossbeam",
"derive_deref",
"parking_lot 0.12.4",
"parking_lot 0.12.5",
"rayon",
]
[[package]]
name = "brk_rmcp"
version = "0.7.1"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac54fb0335b049bce158a31900681dd6b328d5cd3640e76c478c1067eb50fc79"
checksum = "fe0eee22d5688b9b4bbd0071a8d8b540243a8df014eeff4bfe6f90e774e83755"
dependencies = [
"base64 0.22.1",
"brk_rmcp-macros",
@@ -764,9 +764,9 @@ dependencies = [
[[package]]
name = "brk_rmcp-macros"
version = "0.7.1"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "241b6c6ee464ae951e152122567e4fd5e4443ee1ed484bd575530de3afb72f99"
checksum = "aac2141d6358651fcdcabd43fa4dae4525cbba376bc9303a821cb170c2909f4b"
dependencies = [
"darling",
"proc-macro2",
@@ -1160,7 +1160,7 @@ dependencies = [
"byteview",
"fjall",
"log",
"parking_lot 0.12.4",
"parking_lot 0.12.5",
]
[[package]]
@@ -1184,6 +1184,7 @@ dependencies = [
"bitcoin",
"bitcoincore-rpc",
"brk_error",
"brk_vecs",
"byteview",
"derive_deref",
"itoa",
@@ -1203,6 +1204,7 @@ dependencies = [
name = "brk_vecs"
version = "0.0.111"
dependencies = [
"brk_vecs_derive",
"serde",
"vecdb",
]
@@ -1275,9 +1277,9 @@ dependencies = [
[[package]]
name = "cc"
version = "1.2.39"
version = "1.2.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1354349954c6fc9cb0deab020f27f783cf0b604e8bb754dc4658ecf0d29c35f"
checksum = "e1d05d92f4b1fd76aad469d46cdd858ca761576082cd37df81416691e50199fb"
dependencies = [
"find-msvc-tools",
"jobserver",
@@ -1648,7 +1650,7 @@ dependencies = [
"hashbrown 0.14.5",
"lock_api",
"once_cell",
"parking_lot_core 0.9.11",
"parking_lot_core 0.9.12",
]
[[package]]
@@ -1907,9 +1909,9 @@ dependencies = [
[[package]]
name = "find-msvc-tools"
version = "0.1.2"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ced73b1dacfc750a6db6c0a0c3a3853c8b41997e2e2c563dc90804ae6867959"
checksum = "0399f9d26e5191ce32c498bebd31e7a3ceabc2745f0ac54af3f335126c3f24b3"
[[package]]
name = "fixedbitset"
@@ -1936,9 +1938,9 @@ dependencies = [
[[package]]
name = "flate2"
version = "1.1.2"
version = "1.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"
checksum = "04bcaeafafdd3cd1cb5d986ff32096ad1136630207c49b9091e3ae541090d938"
dependencies = [
"crc32fast",
"libz-rs-sys",
@@ -2637,7 +2639,7 @@ checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
dependencies = [
"bitflags 2.9.4",
"libc",
"redox_syscall 0.5.17",
"redox_syscall 0.5.18",
]
[[package]]
@@ -2663,11 +2665,10 @@ checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
[[package]]
name = "lock_api"
version = "0.4.13"
version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
dependencies = [
"autocfg",
"scopeguard",
]
@@ -2741,6 +2742,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
dependencies = [
"adler2",
"simd-adler32",
]
[[package]]
@@ -3473,12 +3475,12 @@ dependencies = [
[[package]]
name = "parking_lot"
version = "0.12.4"
version = "0.12.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
dependencies = [
"lock_api",
"parking_lot_core 0.9.11",
"parking_lot_core 0.9.12",
]
[[package]]
@@ -3497,15 +3499,15 @@ dependencies = [
[[package]]
name = "parking_lot_core"
version = "0.9.11"
version = "0.9.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
dependencies = [
"cfg-if",
"libc",
"redox_syscall 0.5.17",
"redox_syscall 0.5.18",
"smallvec",
"windows-targets 0.52.6",
"windows-link",
]
[[package]]
@@ -3754,7 +3756,7 @@ dependencies = [
"ahash",
"equivalent",
"hashbrown 0.15.5",
"parking_lot 0.12.4",
"parking_lot 0.12.5",
]
[[package]]
@@ -3899,9 +3901,9 @@ dependencies = [
[[package]]
name = "redox_syscall"
version = "0.5.17"
version = "0.5.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5407465600fb0548f1442edf71dd20683c6ed326200ace4b1ef0763521bb3b77"
checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
dependencies = [
"bitflags 2.9.4",
]
@@ -4220,7 +4222,7 @@ dependencies = [
"libc",
"log",
"memmap2",
"parking_lot 0.12.4",
"parking_lot 0.12.5",
"rayon",
"zerocopy",
"zerocopy-derive",
@@ -4325,9 +4327,9 @@ dependencies = [
[[package]]
name = "serde_with"
version = "3.14.1"
version = "3.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c522100790450cf78eeac1507263d0a350d4d5b30df0c8e1fe051a10c22b376e"
checksum = "6093cd8c01b25262b84927e0f7151692158fab02d961e04c979d3903eba7ecc5"
dependencies = [
"base64 0.22.1",
"chrono",
@@ -4336,8 +4338,7 @@ dependencies = [
"indexmap 2.11.4",
"schemars 0.9.0",
"schemars 1.0.4",
"serde",
"serde_derive",
"serde_core",
"serde_json",
"serde_with_macros",
"time",
@@ -4345,9 +4346,9 @@ dependencies = [
[[package]]
name = "serde_with_macros"
version = "3.14.1"
version = "3.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "327ada00f7d64abaac1e55a6911e90cf665aa051b9a561c7006c157f4633135e"
checksum = "a7e6c180db0816026a61afa1cff5344fb7ebded7e4d3062772179f2501481c27"
dependencies = [
"darling",
"proc-macro2",
@@ -5141,7 +5142,7 @@ dependencies = [
"allocative",
"ctrlc",
"log",
"parking_lot 0.12.4",
"parking_lot 0.12.5",
"pco",
"seqdb",
"serde",

6
Cargo.toml
View File

@@ -59,7 +59,7 @@ brk_parser = { version = "0.0.111", path = "crates/brk_parser" }
brk_server = { version = "0.0.111", path = "crates/brk_server" }
brk_store = { version = "0.0.111", path = "crates/brk_store" }
brk_structs = { version = "0.0.111", path = "crates/brk_structs" }
brk_vecs = { version = "0.0.111", path = "crates/brk_vecs" }
brk_vecs = { version = "0.0.111", path = "crates/brk_vecs", features = ["derive"] }
brk_vecs_derive = { version = "0.0.111", path = "crates/brk_vecs_derive" }
byteview = "=0.6.1"
derive_deref = "1.1.1"
@@ -67,7 +67,7 @@ fjall = "2.11.2"
jiff = "0.2.15"
log = "0.4.28"
minreq = { version = "2.14.1", features = ["https", "serde_json"] }
parking_lot = "0.12.4"
parking_lot = "0.12.5"
quick_cache = "0.6.16"
rayon = "1.11.0"
schemars = "1.0.4"
@@ -77,7 +77,7 @@ serde_derive = "1.0.228"
serde_json = { version = "1.0.145", features = ["float_roundtrip"] }
sonic-rs = "0.5.5"
tokio = { version = "1.47.1", features = ["rt-multi-thread"] }
# vecdb = { path = "../seqdb/crates/vecdb", features = ["derive"]}
# vecdb = { path = "../seqdb/crates/vecdb", features = ["derive"] }
vecdb = { version = "0.2.16", features = ["derive"] }
zerocopy = "0.8.27"
zerocopy-derive = "0.8.27"

1
crates/brk_computer/Cargo.toml
View File

@@ -20,6 +20,7 @@ brk_indexer = { workspace = true }
brk_logger = { workspace = true }
brk_store = { workspace = true }
brk_parser = { workspace = true }
brk_vecs = { workspace = true }
vecdb = { workspace = true }
derive_deref = { workspace = true }
log = { workspace = true }

5
crates/brk_computer/examples/computer.rs
View File

@@ -42,6 +42,11 @@ pub fn main() -> Result<()> {
let mut computer = Computer::forced_import(&outputs_dir, &indexer, Some(fetcher))?;
// should be: 205937
dbg!(computer.iter_any_collectable().collect::<Vec<_>>().len());
std::process::exit(0);
loop {
let i = Instant::now();
let starting_indexes = indexer.index(&parser, rpc, &exit, true)?;

24
crates/brk_computer/src/blks.rs
View File

@@ -4,14 +4,15 @@ use brk_error::Result;
use brk_indexer::Indexer;
use brk_parser::Parser;
use brk_structs::{BlkPosition, Height, TxIndex, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CompressedVec, Database, Exit,
GenericStoredVec, PAGE_SIZE, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, CompressedVec, Database, Exit, GenericStoredVec,
PAGE_SIZE, VecIterator,
};
use super::{Indexes, indexes};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -41,11 +42,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -128,14 +126,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
Box::new(
[
&self.height_to_position as &dyn AnyCollectableVec,
&self.txindex_to_position,
]
.into_iter(),
)
}
}

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

@@ -9,9 +9,10 @@ use brk_structs::{
SemesterIndex, StoredBool, StoredF32, StoredF64, StoredU32, StoredU64, Timestamp, TxIndex,
TxVersion, Version, WeekIndex, Weight, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit,
LazyVecFrom1, LazyVecFrom2, LazyVecFrom3, PAGE_SIZE, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit, LazyVecFrom1, LazyVecFrom2,
LazyVecFrom3, PAGE_SIZE, StoredIndex, VecIterator,
};
use crate::grouped::{
@@ -32,7 +33,7 @@ const TARGET_BLOCKS_PER_YEAR: u64 = 2 * TARGET_BLOCKS_PER_SEMESTER;
const TARGET_BLOCKS_PER_DECADE: u64 = 10 * TARGET_BLOCKS_PER_YEAR;
const ONE_TERA_HASH: f64 = 1_000_000_000_000.0;
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct Vecs {
db: Database,
@@ -1151,11 +1152,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -2289,140 +2287,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_interval as &dyn AnyCollectableVec,
&self.height_to_vbytes,
&self.difficultyepoch_to_timestamp,
&self.halvingepoch_to_timestamp,
&self.inputindex_to_value,
&self.txindex_to_fee,
&self.txindex_to_fee_rate,
&self.txindex_to_input_value,
&self.txindex_to_is_coinbase,
&self.txindex_to_output_value,
&self.txindex_to_vsize,
&self.txindex_to_weight,
&self.dateindex_to_fee_dominance,
&self.dateindex_to_subsidy_dominance,
&self.dateindex_to_block_count_target,
&self.weekindex_to_block_count_target,
&self.monthindex_to_block_count_target,
&self.quarterindex_to_block_count_target,
&self.semesterindex_to_block_count_target,
&self.yearindex_to_block_count_target,
&self.decadeindex_to_block_count_target,
&self.height_to_24h_block_count,
&self.height_to_24h_coinbase_sum,
&self.height_to_24h_coinbase_usd_sum,
]
.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_inflation_rate.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficulty.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_difficulty_adjustment.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_blocks_before_next_difficulty_adjustment
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_days_before_next_difficulty_adjustment
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_blocks_before_next_halving
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_days_before_next_halving
.iter_any_collectable(),
),
);
iter = Box::new(iter.chain(self.indexes_to_sent.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_ths.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_phs.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_ths.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_phs.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_ths_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_phs_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_ths_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_phs_min.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_price_rebound.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_hash_value_rebound.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_annualized_volume.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_annualized_volume_btc.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_annualized_volume_usd.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_btc_velocity.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_usd_velocity.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_tx_per_sec.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_outputs_per_sec.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_inputs_per_sec.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
}
}

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

@@ -2,7 +2,8 @@ use std::path::Path;
use brk_error::Result;
use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF32, StoredF64, Version};
use vecdb::{AnyCollectableVec, Database, Exit, PAGE_SIZE, VecIterator};
use brk_vecs::IVecs;
use vecdb::{Database, Exit, PAGE_SIZE, VecIterator};
use crate::grouped::ComputedVecsFromDateIndex;
@@ -15,7 +16,7 @@ use super::{
indexes, price, stateful,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -277,11 +278,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -678,72 +676,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(
iter.chain(
self.indexes_to_cointime_adj_inflation_rate
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_cointime_adj_tx_btc_velocity
.iter_any_collectable(),
),
);
iter = Box::new(
iter.chain(
self.indexes_to_cointime_adj_tx_usd_velocity
.iter_any_collectable(),
),
);
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
}
}

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

@@ -2,7 +2,8 @@ use std::path::Path;
use brk_error::Result;
use brk_structs::{StoredF32, StoredI16, StoredU16, Version};
use vecdb::{AnyCollectableVec, AnyVec, Database, Exit};
use brk_vecs::IVecs;
use vecdb::{AnyVec, Database, Exit};
use crate::grouped::Source;
@@ -12,7 +13,7 @@ use super::{
indexes,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -159,11 +160,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -249,26 +247,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(iter.chain(self.constant_0.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_1.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_3.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_4.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_38_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_50.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_61_8.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_100.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_600.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_1.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_2.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_3.iter_any_collectable()));
iter = Box::new(iter.chain(self.constant_minus_4.iter_any_collectable()));
iter
}
}

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

@@ -4,14 +4,15 @@ use brk_error::Result;
use brk_fetcher::Fetcher;
use brk_indexer::Indexer;
use brk_structs::{DateIndex, Height, OHLCCents, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec,
RawVec, StoredIndex, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec, RawVec, StoredIndex,
VecIterator,
};
use super::{Indexes, indexes};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
fetcher: Fetcher,
@@ -41,11 +42,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -138,12 +136,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.dateindex_to_price_ohlc_in_cents as &dyn AnyCollectableVec,
&self.height_to_price_ohlc_in_cents,
]
.into_iter()
}
}

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

@@ -1,6 +1,7 @@
use allocative::Allocative;
use brk_error::{Error, Result};
use brk_structs::{CheckedSub, StoredU64, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
GenericStoredVec, StoredIndex, StoredRaw,
@@ -10,8 +11,8 @@ use crate::utils::get_percentile;
use super::ComputedType;
#[derive(Clone, Debug, Allocative)]
pub struct EagerVecBuilder<I, T>
#[derive(Clone, Debug, IVecs, Allocative)]
pub struct EagerVecsBuilder<I, T>
where
I: StoredIndex,
T: ComputedType,
@@ -32,7 +33,7 @@ where
const VERSION: Version = Version::ZERO;
impl<I, T> EagerVecBuilder<I, T>
impl<I, T> EagerVecsBuilder<I, T>
where
I: StoredIndex,
T: ComputedType,
@@ -394,7 +395,7 @@ where
pub fn from_aligned<I2>(
&mut self,
max_from: I,
source: &EagerVecBuilder<I2, T>,
source: &EagerVecsBuilder<I2, T>,
first_indexes: &impl AnyIterableVec<I, I2>,
count_indexes: &impl AnyIterableVec<I, StoredU64>,
exit: &Exit,
@@ -540,9 +541,7 @@ where
}
pub fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
))
max_from.min(I::from(self.iter().map(|v| v.len()).min().unwrap()))
}
pub fn unwrap_first(&self) -> &EagerVec<I, T> {
@@ -589,98 +588,6 @@ where
self.cumulative.as_ref().unwrap()
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(
iter.chain(
self.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),
),
);
iter
}
pub fn safe_flush(&mut self, exit: &Exit) -> Result<()> {
if let Some(first) = self.first.as_mut() {
first.safe_flush(exit)?;

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

@@ -1,20 +1,22 @@
use allocative::Allocative;
use brk_structs::Version;
use brk_vecs::IVecs;
use vecdb::{
AnyBoxedIterableVec, AnyCloneableIterableVec, AnyCollectableVec, FromCoarserIndex,
LazyVecFrom2, StoredIndex,
};
use crate::grouped::{EagerVecBuilder, VecBuilderOptions};
use crate::grouped::{EagerVecsBuilder, VecBuilderOptions};
use super::ComputedType;
#[allow(clippy::type_complexity)]
#[derive(Clone, Allocative)]
pub struct LazyVecBuilder<I, T, S1I, S2T>
#[derive(Clone, IVecs, Allocative)]
pub struct LazyVecsBuilder<I, T, S1I, S2T>
where
I: StoredIndex,
T: ComputedType,
S1I: StoredIndex,
S2T: ComputedType,
{
pub first: Option<Box<LazyVecFrom2<I, T, S1I, T, I, S2T>>>,
@@ -28,7 +30,7 @@ where
const VERSION: Version = Version::ZERO;
impl<I, T, S1I, S2T> LazyVecBuilder<I, T, S1I, S2T>
impl<I, T, S1I, S2T> LazyVecsBuilder<I, T, S1I, S2T>
where
I: StoredIndex,
T: ComputedType + 'static,
@@ -40,7 +42,7 @@ where
name: &str,
version: Version,
source: Option<AnyBoxedIterableVec<S1I, T>>,
source_extra: &EagerVecBuilder<S1I, T>,
source_extra: &EagerVecsBuilder<S1I, T>,
len_source: AnyBoxedIterableVec<I, S2T>,
options: LazyVecBuilderOptions,
) -> Self {
@@ -216,9 +218,7 @@ where
}
pub fn starting_index(&self, max_from: I) -> I {
max_from.min(I::from(
self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
))
max_from.min(I::from(self.iter().map(|v| v.len()).min().unwrap()))
}
pub fn unwrap_first(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
@@ -244,63 +244,6 @@ where
pub fn unwrap_cumulative(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {
self.cumulative.as_ref().unwrap()
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(
iter.chain(
self.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),
),
);
iter
}
}
#[derive(Default, Clone, Copy)]

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

@@ -4,25 +4,26 @@ use brk_error::Result;
use brk_structs::{
DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex,
};
use vecdb::{AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit};
use brk_vecs::IVecs;
use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
use crate::{Indexes, grouped::LazyVecBuilder, indexes};
use crate::{Indexes, grouped::LazyVecsBuilder, indexes};
use super::{ComputedType, EagerVecBuilder, Source, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, Source, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedVecsFromDateIndex<T>
where
T: ComputedType + PartialOrd,
{
pub dateindex: Option<EagerVec<DateIndex, T>>,
pub dateindex_extra: EagerVecBuilder<DateIndex, T>,
pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
pub dateindex_extra: EagerVecsBuilder<DateIndex, T>,
pub weekindex: LazyVecsBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub monthindex: LazyVecsBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecsBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecsBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecsBuilder<YearIndex, T, DateIndex, YearIndex>,
pub decadeindex: LazyVecsBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
}
const VERSION: Version = Version::ZERO;
@@ -44,7 +45,7 @@ where
EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO).unwrap()
});
let dateindex_extra = EagerVecBuilder::forced_import_compressed(
let dateindex_extra = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -56,7 +57,7 @@ where
let dateindex_source = source.vec().or(dateindex.as_ref().map(|v| v.boxed_clone()));
Ok(Self {
weekindex: LazyVecBuilder::forced_import(
weekindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -64,7 +65,7 @@ where
indexes.weekindex_to_weekindex.boxed_clone(),
options.into(),
),
monthindex: LazyVecBuilder::forced_import(
monthindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -72,7 +73,7 @@ where
indexes.monthindex_to_monthindex.boxed_clone(),
options.into(),
),
quarterindex: LazyVecBuilder::forced_import(
quarterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -80,7 +81,7 @@ where
indexes.quarterindex_to_quarterindex.boxed_clone(),
options.into(),
),
semesterindex: LazyVecBuilder::forced_import(
semesterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -88,7 +89,7 @@ where
indexes.semesterindex_to_semesterindex.boxed_clone(),
options.into(),
),
yearindex: LazyVecBuilder::forced_import(
yearindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -96,7 +97,7 @@ where
indexes.yearindex_to_yearindex.boxed_clone(),
options.into(),
),
decadeindex: LazyVecBuilder::forced_import(
decadeindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
dateindex_source.clone(),
@@ -142,23 +143,4 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.dateindex
.as_ref()
.map(|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
}
}

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

@@ -5,32 +5,33 @@ use brk_structs::{
DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex,
Version, WeekIndex, YearIndex,
};
use vecdb::{AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, Database, EagerVec, Exit};
use brk_vecs::IVecs;
use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
use crate::{
Indexes,
grouped::{LazyVecBuilder, Source},
grouped::{LazyVecsBuilder, Source},
indexes,
};
use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedVecsFromHeight<T>
where
T: ComputedType + PartialOrd,
{
pub height: Option<EagerVec<Height, T>>,
pub height_extra: EagerVecBuilder<Height, T>,
pub dateindex: EagerVecBuilder<DateIndex, T>,
pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
pub height_extra: EagerVecsBuilder<Height, T>,
pub dateindex: EagerVecsBuilder<DateIndex, T>,
pub weekindex: LazyVecsBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecsBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecsBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecsBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecsBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecsBuilder<YearIndex, T, DateIndex, YearIndex>,
// TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
pub decadeindex: LazyVecsBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
}
const VERSION: Version = Version::ZERO;
@@ -53,14 +54,14 @@ where
EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO).unwrap()
});
let height_extra = EagerVecBuilder::forced_import_compressed(
let height_extra = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
options.copy_self_extra(),
)?;
let dateindex = EagerVecBuilder::forced_import_compressed(
let dateindex = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -70,7 +71,7 @@ where
let options = options.remove_percentiles();
Ok(Self {
weekindex: LazyVecBuilder::forced_import(
weekindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -78,7 +79,7 @@ where
indexes.weekindex_to_weekindex.boxed_clone(),
options.into(),
),
monthindex: LazyVecBuilder::forced_import(
monthindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -86,7 +87,7 @@ where
indexes.monthindex_to_monthindex.boxed_clone(),
options.into(),
),
quarterindex: LazyVecBuilder::forced_import(
quarterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -94,7 +95,7 @@ where
indexes.quarterindex_to_quarterindex.boxed_clone(),
options.into(),
),
semesterindex: LazyVecBuilder::forced_import(
semesterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -102,7 +103,7 @@ where
indexes.semesterindex_to_semesterindex.boxed_clone(),
options.into(),
),
yearindex: LazyVecBuilder::forced_import(
yearindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -110,7 +111,7 @@ where
indexes.yearindex_to_yearindex.boxed_clone(),
options.into(),
),
decadeindex: LazyVecBuilder::forced_import(
decadeindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -122,7 +123,7 @@ where
height,
height_extra,
dateindex,
difficultyepoch: EagerVecBuilder::forced_import_compressed(
difficultyepoch: EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -198,25 +199,4 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.height
.as_ref()
.map(|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
}
}

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

@@ -1,20 +1,21 @@
use brk_error::Result;
use brk_structs::{DifficultyEpoch, Height, Version};
use vecdb::{AnyCollectableVec, Database, EagerVec, Exit};
use brk_vecs::IVecs;
use vecdb::{Database, EagerVec, Exit};
use crate::{Indexes, indexes};
use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedVecsFromHeightStrict<T>
where
T: ComputedType + PartialOrd,
{
pub height: EagerVec<Height, T>,
pub height_extra: EagerVecBuilder<Height, T>,
pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
pub height_extra: EagerVecsBuilder<Height, T>,
pub difficultyepoch: EagerVecsBuilder<DifficultyEpoch, T>,
// TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
}
@@ -34,7 +35,7 @@ where
let height =
EagerVec::forced_import_compressed(db, name, version + VERSION + Version::ZERO)?;
let height_extra = EagerVecBuilder::forced_import_compressed(
let height_extra = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -46,7 +47,7 @@ where
Ok(Self {
height,
height_extra,
difficultyepoch: EagerVecBuilder::forced_import_compressed(
difficultyepoch: EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -81,11 +82,4 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.height as &dyn AnyCollectableVec]
.into_iter()
.chain(self.height_extra.iter_any_collectable())
.chain(self.difficultyepoch.iter_any_collectable())
}
}

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

@@ -5,35 +5,36 @@ use brk_structs::{
Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
Sats, SemesterIndex, TxIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
GenericStoredVec, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyVec, CollectableVec, Database, EagerVec, Exit, GenericStoredVec,
StoredIndex, VecIterator,
};
use crate::{
Indexes,
grouped::{LazyVecBuilder, Source},
grouped::{LazyVecsBuilder, Source},
indexes, price,
};
use super::{ComputedType, EagerVecBuilder, VecBuilderOptions};
use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedVecsFromTxindex<T>
where
T: ComputedType + PartialOrd,
{
pub txindex: Option<Box<EagerVec<TxIndex, T>>>,
pub height: EagerVecBuilder<Height, T>,
pub dateindex: EagerVecBuilder<DateIndex, T>,
pub weekindex: LazyVecBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecBuilder<YearIndex, T, DateIndex, YearIndex>,
pub height: EagerVecsBuilder<Height, T>,
pub dateindex: EagerVecsBuilder<DateIndex, T>,
pub weekindex: LazyVecsBuilder<WeekIndex, T, DateIndex, WeekIndex>,
pub difficultyepoch: EagerVecsBuilder<DifficultyEpoch, T>,
pub monthindex: LazyVecsBuilder<MonthIndex, T, DateIndex, MonthIndex>,
pub quarterindex: LazyVecsBuilder<QuarterIndex, T, DateIndex, QuarterIndex>,
pub semesterindex: LazyVecsBuilder<SemesterIndex, T, DateIndex, SemesterIndex>,
pub yearindex: LazyVecsBuilder<YearIndex, T, DateIndex, YearIndex>,
// TODO: pub halvingepoch: StorableVecGeneator<Halvingepoch, T>,
pub decadeindex: LazyVecBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
pub decadeindex: LazyVecsBuilder<DecadeIndex, T, DateIndex, DecadeIndex>,
}
const VERSION: Version = Version::ZERO;
@@ -59,7 +60,7 @@ where
)
});
let height = EagerVecBuilder::forced_import_compressed(
let height = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -68,7 +69,7 @@ where
let options = options.remove_percentiles();
let dateindex = EagerVecBuilder::forced_import_compressed(
let dateindex = EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -76,7 +77,7 @@ where
)?;
Ok(Self {
weekindex: LazyVecBuilder::forced_import(
weekindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -84,7 +85,7 @@ where
indexes.weekindex_to_weekindex.boxed_clone(),
options.into(),
),
monthindex: LazyVecBuilder::forced_import(
monthindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -92,7 +93,7 @@ where
indexes.monthindex_to_monthindex.boxed_clone(),
options.into(),
),
quarterindex: LazyVecBuilder::forced_import(
quarterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -100,7 +101,7 @@ where
indexes.quarterindex_to_quarterindex.boxed_clone(),
options.into(),
),
semesterindex: LazyVecBuilder::forced_import(
semesterindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -108,7 +109,7 @@ where
indexes.semesterindex_to_semesterindex.boxed_clone(),
options.into(),
),
yearindex: LazyVecBuilder::forced_import(
yearindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -116,7 +117,7 @@ where
indexes.yearindex_to_yearindex.boxed_clone(),
options.into(),
),
decadeindex: LazyVecBuilder::forced_import(
decadeindex: LazyVecsBuilder::forced_import(
name,
version + VERSION + Version::ZERO,
None,
@@ -128,7 +129,7 @@ where
txindex,
height,
dateindex,
difficultyepoch: EagerVecBuilder::forced_import_compressed(
difficultyepoch: EagerVecsBuilder::forced_import_compressed(
db,
name,
version + VERSION + Version::ZERO,
@@ -225,27 +226,6 @@ where
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
self.txindex
.as_ref()
.map(|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
}
}
impl ComputedVecsFromTxindex<Bitcoin> {

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

@@ -1,8 +1,9 @@
use brk_error::Result;
use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec,
Exit, GenericStoredVec, StoredIndex, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
GenericStoredVec, StoredIndex, VecIterator,
};
use crate::{
@@ -16,7 +17,7 @@ use crate::{
use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedRatioVecsFromDateIndex {
pub price: Option<ComputedVecsFromDateIndex<Dollars>>,
@@ -631,133 +632,4 @@ impl ComputedRatioVecsFromDateIndex {
.flatten()
.collect::<Vec<_>>()
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.price.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.ratio.iter_any_collectable()));
iter = Box::new(
iter.chain(
self.ratio_1w_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_1m_sma
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.ratio_sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.ratio_1y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_2y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_4y_sd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct1
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct2
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct5
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct95
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct98
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct99
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct1_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct2_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct5_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct95_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct98_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(
iter.chain(
self.ratio_pct99_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter
}
}

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

@@ -1,15 +1,16 @@
use brk_error::Result;
use brk_structs::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec,
Database, EagerVec, Exit, GenericStoredVec, StoredIndex,
AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, Database, EagerVec,
Exit, GenericStoredVec, StoredIndex,
};
use crate::{Indexes, grouped::source::Source, indexes};
use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedStandardDeviationVecsFromDateIndex {
days: usize,
@@ -804,75 +805,4 @@ impl ComputedStandardDeviationVecsFromDateIndex {
self.mut_stateful_computed()
.map(|c| c.dateindex.as_mut().unwrap())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.sma.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.sd.iter_any_collectable()));
iter = Box::new(iter.chain(self.p0_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p1sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p1_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p2sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p2_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.p3sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m0_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m1sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m1_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m2sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m2_5sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.m3sd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self._0sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.p0_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.p1sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.p1_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.p2sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.p2_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.p3sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.m0_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.m1sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.m1_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.m2sd_usd.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(
iter.chain(
self.m2_5sd_usd
.iter()
.flat_map(|v| v.iter_any_collectable()),
),
);
iter = Box::new(iter.chain(self.m3sd_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
}
}

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

@@ -1,6 +1,7 @@
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
use brk_vecs::IVecs;
use vecdb::{CollectableVec, Database, EagerVec, Exit, StoredVec};
use crate::{
Indexes,
@@ -11,7 +12,7 @@ use crate::{
use super::{Source, VecBuilderOptions};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedValueVecsFromDateIndex {
pub sats: ComputedVecsFromDateIndex<Sats>,
pub bitcoin: ComputedVecsFromDateIndex<Bitcoin>,
@@ -130,11 +131,4 @@ impl ComputedValueVecsFromDateIndex {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
std::iter::empty()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}

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

@@ -1,7 +1,8 @@
use allocative::Allocative;
use brk_error::Result;
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, StoredVec};
use brk_vecs::IVecs;
use vecdb::{CollectableVec, Database, EagerVec, Exit, StoredVec};
use crate::{
Indexes,
@@ -12,7 +13,7 @@ use crate::{
use super::{ComputedVecsFromHeight, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedValueVecsFromHeight {
pub sats: ComputedVecsFromHeight<Sats>,
pub bitcoin: ComputedVecsFromHeight<Bitcoin>,
@@ -130,11 +131,4 @@ impl ComputedValueVecsFromHeight {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
std::iter::empty()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}

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

@@ -2,16 +2,17 @@ use allocative::Allocative;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_structs::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, CollectableVec, Database, Exit, LazyVecFrom1,
LazyVecFrom3, StoredIndex, StoredVec,
AnyCloneableIterableVec, CollectableVec, Database, Exit, LazyVecFrom1, LazyVecFrom3,
StoredIndex, StoredVec,
};
use crate::{Indexes, grouped::Source, indexes, price};
use super::{ComputedVecsFromTxindex, VecBuilderOptions};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct ComputedValueVecsFromTxindex {
pub sats: ComputedVecsFromTxindex<Sats>,
pub bitcoin_txindex: LazyVecFrom1<TxIndex, Bitcoin, TxIndex, Sats>,
@@ -201,17 +202,4 @@ impl ComputedValueVecsFromTxindex {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.bitcoin_txindex as &dyn AnyCollectableVec]
.into_iter()
.chain(self.sats.iter_any_collectable())
.chain(self.bitcoin.iter_any_collectable())
.chain(
self.dollars_txindex
.iter()
.map(|v| v as &dyn AnyCollectableVec),
)
.chain(self.dollars.iter().flat_map(|v| v.iter_any_collectable()))
}
}

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

@@ -1,6 +1,7 @@
use brk_error::Result;
use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
use vecdb::{AnyCollectableVec, CollectableVec, Database, EagerVec, Exit, Format, StoredVec};
use brk_vecs::IVecs;
use vecdb::{CollectableVec, Database, EagerVec, Exit, Format, StoredVec};
use crate::{
Indexes,
@@ -9,7 +10,7 @@ use crate::{
traits::{ComputeFromBitcoin, ComputeFromSats},
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct ComputedHeightValueVecs {
pub sats: Option<EagerVec<Height, Sats>>,
pub bitcoin: EagerVec<Height, Bitcoin>,
@@ -100,11 +101,4 @@ impl ComputedHeightValueVecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.bitcoin as &dyn AnyCollectableVec]
.into_iter()
.chain(self.sats.iter().map(|v| v as &dyn AnyCollectableVec))
.chain(self.dollars.iter().map(|v| v as &dyn AnyCollectableVec))
}
}

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

@@ -10,6 +10,7 @@ use brk_structs::{
P2WPKHBytes, P2WSHAddressIndex, P2WSHBytes, QuarterIndex, Sats, SemesterIndex, StoredU64,
Timestamp, TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, Database, EagerVec, Exit, LazyVecFrom1,
LazyVecFrom2, PAGE_SIZE, StoredIndex, VecIterator,
@@ -17,7 +18,7 @@ use vecdb::{
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -474,11 +475,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -932,72 +930,6 @@ impl Vecs {
halvingepoch: starting_halvingepoch,
})
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.dateindex_to_date as &dyn AnyCollectableVec,
&self.dateindex_to_dateindex,
&self.dateindex_to_first_height,
&self.dateindex_to_height_count,
&self.dateindex_to_monthindex,
&self.dateindex_to_weekindex,
&self.decadeindex_to_decadeindex,
&self.decadeindex_to_first_yearindex,
&self.decadeindex_to_yearindex_count,
&self.difficultyepoch_to_difficultyepoch,
&self.difficultyepoch_to_first_height,
&self.difficultyepoch_to_height_count,
&self.emptyoutputindex_to_emptyoutputindex,
&self.halvingepoch_to_first_height,
&self.halvingepoch_to_halvingepoch,
&self.height_to_date,
&self.height_to_date_fixed,
&self.height_to_dateindex,
&self.height_to_difficultyepoch,
&self.height_to_halvingepoch,
&self.height_to_height,
&self.height_to_timestamp_fixed,
&self.height_to_txindex_count,
&self.inputindex_to_inputindex,
&self.monthindex_to_dateindex_count,
&self.monthindex_to_first_dateindex,
&self.monthindex_to_monthindex,
&self.monthindex_to_quarterindex,
&self.monthindex_to_semesterindex,
&self.monthindex_to_yearindex,
&self.opreturnindex_to_opreturnindex,
&self.outputindex_to_outputindex,
&self.p2aaddressindex_to_p2aaddressindex,
&self.p2msoutputindex_to_p2msoutputindex,
&self.p2pk33addressindex_to_p2pk33addressindex,
&self.p2pk65addressindex_to_p2pk65addressindex,
&self.p2pkhaddressindex_to_p2pkhaddressindex,
&self.p2shaddressindex_to_p2shaddressindex,
&self.p2traddressindex_to_p2traddressindex,
&self.p2wpkhaddressindex_to_p2wpkhaddressindex,
&self.p2wshaddressindex_to_p2wshaddressindex,
&self.quarterindex_to_first_monthindex,
&self.quarterindex_to_monthindex_count,
&self.quarterindex_to_quarterindex,
&self.semesterindex_to_first_monthindex,
&self.semesterindex_to_monthindex_count,
&self.semesterindex_to_semesterindex,
&self.txindex_to_height,
&self.txindex_to_txindex,
&self.txindex_to_input_count,
&self.txindex_to_output_count,
&self.unknownoutputindex_to_unknownoutputindex,
&self.weekindex_to_dateindex_count,
&self.weekindex_to_first_dateindex,
&self.weekindex_to_weekindex,
&self.yearindex_to_decadeindex,
&self.yearindex_to_first_monthindex,
&self.yearindex_to_monthindex_count,
&self.yearindex_to_yearindex,
&self.outputindex_to_txindex,
]
.into_iter()
}
}
pub struct Indexes {

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

@@ -7,8 +7,9 @@ use brk_fetcher::Fetcher;
use brk_indexer::Indexer;
use brk_parser::Parser;
use brk_structs::Version;
use brk_vecs::IVecs;
use log::info;
use vecdb::{AnyCollectableVec, Exit, Format};
use vecdb::{Exit, Format};
mod blks;
mod chain;
@@ -31,7 +32,7 @@ pub use pools::*;
pub use states::PriceToAmount;
use states::*;
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Computer {
pub chain: chain::Vecs,
pub cointime: cointime::Vecs,
@@ -206,23 +207,6 @@ impl Computer {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.fetched.iter().flat_map(|v| v.iter_any_collectable()));
iter = Box::new(iter.chain(self.chain.iter_any_collectable()));
iter = Box::new(iter.chain(self.cointime.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.pools.iter_any_collectable()));
iter = Box::new(iter.chain(self.blks.iter_any_collectable()));
iter = Box::new(iter.chain(self.price.iter().flat_map(|v| v.iter_any_collectable())));
iter = Box::new(iter.chain(self.stateful.iter_any_collectable()));
iter
}
pub fn static_clone(&self) -> &'static Self {
Box::leak(Box::new(self.clone()))
}

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

@@ -2,7 +2,8 @@ use std::{path::Path, thread};
use brk_error::Result;
use brk_structs::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredU16, Version};
use vecdb::{AnyCollectableVec, Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator};
use brk_vecs::IVecs;
use vecdb::{Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator};
use crate::{
grouped::{ComputedStandardDeviationVecsFromDateIndex, Source, StandardDeviationVecsOptions},
@@ -16,7 +17,7 @@ use super::{
indexes,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -1515,11 +1516,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -2325,203 +2323,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_price_ath as &dyn AnyCollectableVec,
&self.height_to_price_drawdown,
&self.dateindex_to_price_true_range,
&self.dateindex_to_price_true_range_2w_sum,
]
.into_iter(),
);
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
}
}

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

@@ -5,10 +5,11 @@ use brk_error::Result;
use brk_indexer::Indexer;
use brk_store::AnyStore;
use brk_structs::{AddressBytes, Height, OutputIndex, OutputType, PoolId, Pools, pools};
use brk_vecs::IVecs;
use rayon::prelude::*;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec,
PAGE_SIZE, RawVec, StoredIndex, VecIterator, Version,
AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec, PAGE_SIZE, RawVec,
StoredIndex, VecIterator, Version,
};
mod vecs;
@@ -19,7 +20,7 @@ use crate::{
price,
};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct Vecs {
db: Database,
pools: &'static Pools,
@@ -61,11 +62,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -214,14 +212,4 @@ impl Vecs {
self.height_to_pool.safe_flush(exit)?;
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[&self.height_to_pool as &dyn AnyCollectableVec]
.into_iter()
.chain(
self.vecs
.iter()
.flat_map(|(_, vecs)| vecs.iter_any_collectable()),
)
}
}

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

@@ -1,7 +1,8 @@
use allocative::Allocative;
use brk_error::Result;
use brk_structs::{Height, PoolId, Pools, Sats, StoredF32, StoredU16, StoredU32};
use vecdb::{AnyCollectableVec, AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version};
use brk_vecs::IVecs;
use vecdb::{AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version};
use crate::{
chain,
@@ -13,7 +14,7 @@ use crate::{
price,
};
#[derive(Clone, Allocative)]
#[derive(Clone, IVecs, Allocative)]
pub struct Vecs {
id: PoolId,
@@ -373,25 +374,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(std::iter::empty());
iter = Box::new(iter.chain(self.indexes_to_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_blocks_mined.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_subsidy.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_fee.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_coinbase.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1d_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1w_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1m_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_1y_dominance.iter_any_collectable()));
iter = Box::new(iter.chain(self.indexes_to_days_since_block.iter_any_collectable()));
iter
}
}

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

@@ -5,9 +5,10 @@ use brk_structs::{
Cents, Close, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, High, Low, MonthIndex,
OHLCDollars, OHLCSats, Open, QuarterIndex, Sats, SemesterIndex, Version, WeekIndex, YearIndex,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit,
GenericStoredVec, PAGE_SIZE, RawVec,
AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, GenericStoredVec, PAGE_SIZE,
RawVec,
};
use crate::{fetched, grouped::Source};
@@ -18,7 +19,7 @@ use super::{
indexes,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -325,11 +326,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -1226,92 +1224,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.dateindex_to_price_close_in_cents as &dyn AnyCollectableVec,
&self.dateindex_to_price_high_in_cents,
&self.dateindex_to_price_low_in_cents,
&self.dateindex_to_price_ohlc,
&self.dateindex_to_price_open_in_cents,
&self.height_to_price_close_in_cents,
&self.height_to_price_high_in_cents,
&self.height_to_price_low_in_cents,
&self.height_to_price_ohlc,
&self.height_to_price_open_in_cents,
&self.weekindex_to_price_ohlc,
&self.difficultyepoch_to_price_ohlc,
&self.monthindex_to_price_ohlc,
&self.quarterindex_to_price_ohlc,
&self.semesterindex_to_price_ohlc,
&self.yearindex_to_price_ohlc,
&self.decadeindex_to_price_ohlc,
&self.height_to_price_ohlc_in_sats,
&self.dateindex_to_price_ohlc_in_sats,
&self.weekindex_to_price_ohlc_in_sats,
&self.difficultyepoch_to_price_ohlc_in_sats,
&self.monthindex_to_price_ohlc_in_sats,
&self.quarterindex_to_price_ohlc_in_sats,
&self.semesterindex_to_price_ohlc_in_sats,
&self.yearindex_to_price_ohlc_in_sats,
&self.decadeindex_to_price_ohlc_in_sats,
]
.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
}
}

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

@@ -2,9 +2,10 @@ use std::path::Path;
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
use brk_vecs::IVecs;
use vecdb::{
AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
GenericStoredVec, VecIterator,
AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, GenericStoredVec,
VecIterator,
};
use crate::{
@@ -20,10 +21,11 @@ use crate::{
const VERSION: Version = Version::ZERO;
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
starting_height: Option<Height>,
#[vecs(skip)]
pub state: Option<AddressCohortState>,
pub inner: common::Vecs,
@@ -84,13 +86,6 @@ impl Vecs {
)?,
})
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.inner
.iter_any_collectable()
.chain([&self.height_to_addr_count as &dyn AnyCollectableVec])
.chain(self.indexes_to_addr_count.iter_any_collectable())
}
}
impl DynCohortVecs for Vecs {

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

@@ -5,6 +5,7 @@ use brk_structs::{
AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex,
Dollars, GroupFilter, Height, Version,
};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{AnyIterableVec, Database, Exit, Format};
@@ -18,7 +19,7 @@ use crate::{
const VERSION: Version = Version::new(0);
#[derive(Clone, Deref, DerefMut)]
#[derive(Clone, Deref, DerefMut, IVecs)]
pub struct Vecs(AddressGroups<(GroupFilter, address_cohort::Vecs)>);
impl Vecs {

3
crates/brk_computer/src/stateful/addresstype/height_to_addresscount.rs
View File

@@ -1,11 +1,12 @@
use brk_error::Result;
use brk_structs::{ByAddressType, Height, StoredU64};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{EagerVec, Exit, GenericStoredVec};
use super::AddressTypeToAddressCount;
#[derive(Debug, Clone, Deref, DerefMut)]
#[derive(Debug, Clone, Deref, DerefMut, IVecs)]
pub struct AddressTypeToHeightToAddressCount(ByAddressType<EagerVec<Height, StoredU64>>);
impl From<ByAddressType<EagerVec<Height, StoredU64>>> for AddressTypeToHeightToAddressCount {

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

@@ -1,13 +1,14 @@
use brk_error::Result;
use brk_structs::{ByAddressType, StoredU64};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{AnyCollectableVec, Exit};
use vecdb::Exit;
use crate::{Indexes, grouped::ComputedVecsFromHeight, indexes};
use super::AddressTypeToHeightToAddressCount;
#[derive(Clone, Deref, DerefMut)]
#[derive(Clone, Deref, DerefMut, IVecs)]
pub struct AddressTypeToIndexesToAddressCount(ByAddressType<ComputedVecsFromHeight<StoredU64>>);
impl From<ByAddressType<ComputedVecsFromHeight<StoredU64>>> for AddressTypeToIndexesToAddressCount {
@@ -74,10 +75,4 @@ impl AddressTypeToIndexesToAddressCount {
)?;
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.0
.iter_typed()
.flat_map(|(_, v)| v.iter_any_collectable())
}
}

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

@@ -2,9 +2,10 @@ use brk_error::{Error, Result};
use brk_structs::{
Bitcoin, DateIndex, Dollars, Height, Sats, StoredF32, StoredF64, StoredU64, Version,
};
use brk_vecs::IVecs;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database,
EagerVec, Exit, Format, GenericStoredVec, VecIterator,
AnyCloneableIterableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit,
Format, GenericStoredVec, VecIterator,
};
use crate::{
@@ -17,7 +18,7 @@ use crate::{
states::CohortState,
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
// Cumulative
pub height_to_realized_cap: Option<EagerVec<Height, Dollars>>,
@@ -3240,698 +3241,4 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_satblocks_destroyed as &dyn AnyCollectableVec,
&self.height_to_satdays_destroyed,
&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_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_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_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 = Box::new(
iter.chain(
self.dateindex_to_realized_profit_to_loss_ratio
.iter()
.map(|v| v as &dyn AnyCollectableVec),
),
);
iter
}
}

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

@@ -15,12 +15,13 @@ use brk_structs::{
P2PK65AddressIndex, P2PKHAddressIndex, P2SHAddressIndex, P2TRAddressIndex, P2WPKHAddressIndex,
P2WSHAddressIndex, Sats, StoredU64, Timestamp, TypeIndex, Version,
};
use brk_vecs::IVecs;
use log::info;
use rayon::prelude::*;
use vecdb::{
AnyCloneableIterableVec, AnyCollectableVec, AnyStoredVec, AnyVec, CollectableVec, Database,
EagerVec, Exit, Format, GenericStoredVec, ImportOptions, LazyVecFrom1, PAGE_SIZE, RawVec,
Reader, Stamp, StoredIndex, VecIterator,
AnyCloneableIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
Format, GenericStoredVec, ImportOptions, LazyVecFrom1, PAGE_SIZE, RawVec, Reader, Stamp,
StoredIndex, VecIterator,
};
use crate::{
@@ -49,7 +50,7 @@ use withaddressdatasource::*;
const VERSION: Version = Version::new(21);
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
db: Database,
@@ -492,11 +493,8 @@ impl Vecs {
db,
};
this.db.retain_regions(
this.iter_any_collectable()
.flat_map(|v| v.region_names())
.collect(),
)?;
this.db
.retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
Ok(this)
}
@@ -1836,90 +1834,6 @@ impl Vecs {
Ok(())
}
pub fn iter_any_collectable(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(
[
&self.height_to_unspendable_supply as &dyn AnyCollectableVec,
&self.height_to_opreturn_supply,
&self.chain_state,
&self.p2pk33addressindex_to_anyaddressindex,
&self.p2pk65addressindex_to_anyaddressindex,
&self.p2pkhaddressindex_to_anyaddressindex,
&self.p2shaddressindex_to_anyaddressindex,
&self.p2traddressindex_to_anyaddressindex,
&self.p2wpkhaddressindex_to_anyaddressindex,
&self.p2wshaddressindex_to_anyaddressindex,
&self.p2aaddressindex_to_anyaddressindex,
&self.loadedaddressindex_to_loadedaddressdata,
&self.emptyaddressindex_to_emptyaddressdata,
&self.loadedaddressindex_to_loadedaddressindex,
&self.emptyaddressindex_to_emptyaddressindex,
]
.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)> {

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

@@ -2,6 +2,7 @@ use std::{ops::Deref, path::Path};
use brk_error::Result;
use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
use brk_vecs::IVecs;
use vecdb::{AnyIterableVec, Database, Exit, Format};
use crate::{
@@ -12,10 +13,11 @@ use crate::{
},
};
#[derive(Clone)]
#[derive(Clone, IVecs)]
pub struct Vecs {
state_starting_height: Option<Height>,
#[vecs(skip)]
pub state: Option<UTXOCohortState>,
inner: common::Vecs,

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

@@ -6,6 +6,7 @@ use brk_structs::{
ByMinAge, BySpendableType, ByTerm, CheckedSub, DateIndex, Dollars, GroupFilter, HalvingEpoch,
Height, Timestamp, UTXOGroups, Version,
};
use brk_vecs::IVecs;
use derive_deref::{Deref, DerefMut};
use vecdb::{AnyIterableVec, Database, Exit, Format, StoredIndex};
@@ -19,7 +20,7 @@ use super::{r#trait::CohortVecs, utxo_cohort};
const VERSION: Version = Version::new(0);
#[derive(Clone, Deref, DerefMut)]
#[derive(Clone, Deref, DerefMut, IVecs)]
pub struct Vecs(UTXOGroups<(GroupFilter, utxo_cohort::Vecs)>);
impl Vecs {

1
crates/brk_indexer/Cargo.toml
View File

@@ -18,7 +18,6 @@ brk_logger = { workspace = true }
brk_parser = { workspace = true }
brk_store = { workspace = true }
brk_vecs = { workspace = true }
brk_vecs_derive = { workspace = true }
vecdb = { workspace = true }
fjall = { workspace = true }
log = { workspace = true }

6
crates/brk_indexer/examples/indexer.rs
View File

@@ -8,6 +8,7 @@ use std::{
use brk_error::Result;
use brk_indexer::Indexer;
use brk_parser::Parser;
// use brk_vecs::IVecs;
use vecdb::Exit;
fn main() -> Result<()> {
@@ -39,6 +40,11 @@ fn main() -> Result<()> {
let mut indexer = Indexer::forced_import(&outputs_dir)?;
// let vecs = indexer.vecs.iter().collect::<Vec<_>>();
// dbg!(indexer.vecs.to_tree_node());
// dbg!(vecs.len());
// std::process::exit(0);
loop {
let i = Instant::now();
indexer.index(&parser, rpc, &exit, true)?;

101
crates/brk_indexer/src/vecs.rs
View File

@@ -9,8 +9,7 @@ use brk_structs::{
RawLockTime, Sats, StoredBool, StoredF64, StoredU32, StoredU64, Timestamp, TxIndex, TxVersion,
Txid, TypeIndex, UnknownOutputIndex, Version, Weight,
};
use brk_vecs::{IVecs, TreeNode};
use brk_vecs_derive::IVecs;
use brk_vecs::IVecs;
use rayon::prelude::*;
use vecdb::{
AnyCollectableVec, AnyStoredVec, CompressedVec, Database, GenericStoredVec, PAGE_SIZE, RawVec,
@@ -370,55 +369,55 @@ impl Vecs {
Ok(())
}
pub fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.emptyoutputindex_to_txindex as &dyn AnyCollectableVec,
&self.height_to_blockhash,
&self.height_to_difficulty,
&self.height_to_first_emptyoutputindex,
&self.height_to_first_inputindex,
&self.height_to_first_opreturnindex,
&self.height_to_first_outputindex,
&self.height_to_first_p2aaddressindex,
&self.height_to_first_p2msoutputindex,
&self.height_to_first_p2pk33addressindex,
&self.height_to_first_p2pk65addressindex,
&self.height_to_first_p2pkhaddressindex,
&self.height_to_first_p2shaddressindex,
&self.height_to_first_p2traddressindex,
&self.height_to_first_p2wpkhaddressindex,
&self.height_to_first_p2wshaddressindex,
&self.height_to_first_txindex,
&self.height_to_first_unknownoutputindex,
&self.height_to_timestamp,
&self.height_to_total_size,
&self.height_to_weight,
&self.inputindex_to_outputindex,
&self.opreturnindex_to_txindex,
&self.outputindex_to_outputtype,
&self.outputindex_to_typeindex,
&self.outputindex_to_value,
&self.p2aaddressindex_to_p2abytes,
&self.p2msoutputindex_to_txindex,
&self.p2pk33addressindex_to_p2pk33bytes,
&self.p2pk65addressindex_to_p2pk65bytes,
&self.p2pkhaddressindex_to_p2pkhbytes,
&self.p2shaddressindex_to_p2shbytes,
&self.p2traddressindex_to_p2trbytes,
&self.p2wpkhaddressindex_to_p2wpkhbytes,
&self.p2wshaddressindex_to_p2wshbytes,
&self.txindex_to_base_size,
&self.txindex_to_first_inputindex,
&self.txindex_to_first_outputindex,
&self.txindex_to_is_explicitly_rbf,
&self.txindex_to_rawlocktime,
&self.txindex_to_total_size,
&self.txindex_to_txid,
&self.txindex_to_txversion,
&self.unknownoutputindex_to_txindex,
]
.into_iter()
}
// pub fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
// [
// &self.emptyoutputindex_to_txindex as &dyn AnyCollectableVec,
// &self.height_to_blockhash,
// &self.height_to_difficulty,
// &self.height_to_first_emptyoutputindex,
// &self.height_to_first_inputindex,
// &self.height_to_first_opreturnindex,
// &self.height_to_first_outputindex,
// &self.height_to_first_p2aaddressindex,
// &self.height_to_first_p2msoutputindex,
// &self.height_to_first_p2pk33addressindex,
// &self.height_to_first_p2pk65addressindex,
// &self.height_to_first_p2pkhaddressindex,
// &self.height_to_first_p2shaddressindex,
// &self.height_to_first_p2traddressindex,
// &self.height_to_first_p2wpkhaddressindex,
// &self.height_to_first_p2wshaddressindex,
// &self.height_to_first_txindex,
// &self.height_to_first_unknownoutputindex,
// &self.height_to_timestamp,
// &self.height_to_total_size,
// &self.height_to_weight,
// &self.inputindex_to_outputindex,
// &self.opreturnindex_to_txindex,
// &self.outputindex_to_outputtype,
// &self.outputindex_to_typeindex,
// &self.outputindex_to_value,
// &self.p2aaddressindex_to_p2abytes,
// &self.p2msoutputindex_to_txindex,
// &self.p2pk33addressindex_to_p2pk33bytes,
// &self.p2pk65addressindex_to_p2pk65bytes,
// &self.p2pkhaddressindex_to_p2pkhbytes,
// &self.p2shaddressindex_to_p2shbytes,
// &self.p2traddressindex_to_p2trbytes,
// &self.p2wpkhaddressindex_to_p2wpkhbytes,
// &self.p2wshaddressindex_to_p2wshbytes,
// &self.txindex_to_base_size,
// &self.txindex_to_first_inputindex,
// &self.txindex_to_first_outputindex,
// &self.txindex_to_is_explicitly_rbf,
// &self.txindex_to_rawlocktime,
// &self.txindex_to_total_size,
// &self.txindex_to_txid,
// &self.txindex_to_txversion,
// &self.unknownoutputindex_to_txindex,
// ]
// .into_iter()
// }
fn iter_mut(&mut self) -> impl Iterator<Item = &mut dyn AnyStoredVec> {
[

2
crates/brk_interface/Cargo.toml
View File

@@ -23,5 +23,5 @@ schemars = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
sonic-rs = { workspace = true }
serde_with = "3.14.1"
serde_with = "3.15.0"
nucleo-matcher = "0.3.1"

2
crates/brk_mcp/Cargo.toml
View File

@@ -12,7 +12,7 @@ build = "build.rs"
[dependencies]
axum = { workspace = true }
brk_interface = { workspace = true }
brk_rmcp = { version = "0.7.1", features = [
brk_rmcp = { version = "0.8.0", features = [
"transport-worker",
"transport-streamable-http-server",
] }

3
crates/brk_structs/Cargo.toml
View File

@@ -13,7 +13,8 @@ build = "build.rs"
allocative = { workspace = true }
bitcoin = { workspace = true }
bitcoincore-rpc = { workspace = true }
brk_error = {workspace = true}
brk_error = { workspace = true }
brk_vecs = { workspace = true }
byteview = { workspace = true }
derive_deref = { workspace = true }
itoa = "1.0.15"

26
crates/brk_structs/src/groups/address.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use super::{ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, GroupFilter};
#[derive(Default, Clone)]
@@ -42,3 +45,26 @@ impl<T> From<AddressGroups<T>> for AddressGroups<(GroupFilter, T)> {
}
}
}
impl<T: IVecs> IVecs for AddressGroups<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("ge_amount", self.ge_amount.to_tree_node()),
("amount_range", self.amount_range.to_tree_node()),
("lt_amount", self.lt_amount.to_tree_node()),
]
.into_iter()
.map(|(name, node)| (name.to_string(), node))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.ge_amount.iter());
iter = Box::new(iter.chain(IVecs::iter(&self.amount_range)));
iter = Box::new(iter.chain(self.lt_amount.iter()));
iter
}
}

70
crates/brk_structs/src/groups/by_address_type.rs
View File

@@ -1,5 +1,8 @@
use std::ops::{Add, AddAssign};
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use super::GroupFilter;
use crate::OutputType;
@@ -192,3 +195,70 @@ impl<T> ByAddressType<Option<T>> {
});
}
}
impl<T: AnyCollectableVec + !IVecs> IVecs for ByAddressType<T> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("p2pk65", &self.p2pk65),
("p2pk33", &self.p2pk33),
("p2pkh", &self.p2pkh),
("p2sh", &self.p2sh),
("p2wpkh", &self.p2wpkh),
("p2wsh", &self.p2wsh),
("p2tr", &self.p2tr),
("p2a", &self.p2a),
]
.into_iter()
.map(|(name, field)| (name.to_string(), TreeNode::Leaf(field.name().to_string())))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
[
&self.p2pk65 as &dyn AnyCollectableVec,
&self.p2pk33,
&self.p2pkh,
&self.p2sh,
&self.p2wpkh,
&self.p2wsh,
&self.p2tr,
&self.p2a,
]
.into_iter()
}
}
impl<T: IVecs> IVecs for ByAddressType<T> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("p2pk65", &self.p2pk65),
("p2pk33", &self.p2pk33),
("p2pkh", &self.p2pkh),
("p2sh", &self.p2sh),
("p2wpkh", &self.p2wpkh),
("p2wsh", &self.p2wsh),
("p2tr", &self.p2tr),
("p2a", &self.p2a),
]
.into_iter()
.map(|(name, field)| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.p2pk65.iter());
iter = Box::new(iter.chain(self.p2pk33.iter()));
iter = Box::new(iter.chain(self.p2pkh.iter()));
iter = Box::new(iter.chain(self.p2sh.iter()));
iter = Box::new(iter.chain(self.p2wpkh.iter()));
iter = Box::new(iter.chain(self.p2wsh.iter()));
iter = Box::new(iter.chain(self.p2tr.iter()));
iter = Box::new(iter.chain(self.p2a.iter()));
iter
}
}

60
crates/brk_structs/src/groups/by_age_range.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use super::GroupFilter;
#[derive(Default, Clone)]
@@ -132,3 +135,60 @@ impl<T> ByAgeRange<(GroupFilter, T)> {
.into_iter()
}
}
impl<T: IVecs> IVecs for ByAgeRange<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("up_to_1d", &self.up_to_1d),
("1d_to_1w", &self._1d_to_1w),
("1w_to_1m", &self._1w_to_1m),
("1m_to_2m", &self._1m_to_2m),
("2m_to_3m", &self._2m_to_3m),
("3m_to_4m", &self._3m_to_4m),
("4m_to_5m", &self._4m_to_5m),
("5m_to_6m", &self._5m_to_6m),
("6m_to_1y", &self._6m_to_1y),
("1y_to_2y", &self._1y_to_2y),
("2y_to_3y", &self._2y_to_3y),
("3y_to_4y", &self._3y_to_4y),
("4y_to_5y", &self._4y_to_5y),
("5y_to_6y", &self._5y_to_6y),
("6y_to_7y", &self._6y_to_7y),
("7y_to_8y", &self._7y_to_8y),
("8y_to_10y", &self._8y_to_10y),
("10y_to_12y", &self._10y_to_12y),
("12y_to_15y", &self._12y_to_15y),
("from_15y", &self.from_15y),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.up_to_1d.1.iter());
iter = Box::new(iter.chain(self._1d_to_1w.1.iter()));
iter = Box::new(iter.chain(self._1w_to_1m.1.iter()));
iter = Box::new(iter.chain(self._1m_to_2m.1.iter()));
iter = Box::new(iter.chain(self._2m_to_3m.1.iter()));
iter = Box::new(iter.chain(self._3m_to_4m.1.iter()));
iter = Box::new(iter.chain(self._4m_to_5m.1.iter()));
iter = Box::new(iter.chain(self._5m_to_6m.1.iter()));
iter = Box::new(iter.chain(self._6m_to_1y.1.iter()));
iter = Box::new(iter.chain(self._1y_to_2y.1.iter()));
iter = Box::new(iter.chain(self._2y_to_3y.1.iter()));
iter = Box::new(iter.chain(self._3y_to_4y.1.iter()));
iter = Box::new(iter.chain(self._4y_to_5y.1.iter()));
iter = Box::new(iter.chain(self._5y_to_6y.1.iter()));
iter = Box::new(iter.chain(self._6y_to_7y.1.iter()));
iter = Box::new(iter.chain(self._7y_to_8y.1.iter()));
iter = Box::new(iter.chain(self._8y_to_10y.1.iter()));
iter = Box::new(iter.chain(self._10y_to_12y.1.iter()));
iter = Box::new(iter.chain(self._12y_to_15y.1.iter()));
iter = Box::new(iter.chain(self.from_15y.1.iter()));
iter
}
}

50
crates/brk_structs/src/groups/by_amount_range.rs
View File

@@ -1,5 +1,8 @@
use std::ops::{Add, AddAssign};
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use crate::Sats;
use super::GroupFilter;
@@ -259,3 +262,50 @@ where
self._100k_btc_or_more += rhs._100k_btc_or_more;
}
}
impl<T: IVecs> IVecs for ByAmountRange<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("0sats", &self._0sats),
("1sat_to_10sats", &self._1sat_to_10sats),
("10sats_to_100sats", &self._10sats_to_100sats),
("100sats_to_1k_sats", &self._100sats_to_1k_sats),
("1k_sats_to_10k_sats", &self._1k_sats_to_10k_sats),
("10k_sats_to_100k_sats", &self._10k_sats_to_100k_sats),
("100k_sats_to_1m_sats", &self._100k_sats_to_1m_sats),
("1m_sats_to_10m_sats", &self._1m_sats_to_10m_sats),
("10m_sats_to_1btc", &self._10m_sats_to_1btc),
("1btc_to_10btc", &self._1btc_to_10btc),
("10btc_to_100btc", &self._10btc_to_100btc),
("100btc_to_1k_btc", &self._100btc_to_1k_btc),
("1k_btc_to_10k_btc", &self._1k_btc_to_10k_btc),
("10k_btc_to_100k_btc", &self._10k_btc_to_100k_btc),
("100k_btc_or_more", &self._100k_btc_or_more),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self._0sats.1.iter());
iter = Box::new(iter.chain(self._1sat_to_10sats.1.iter()));
iter = Box::new(iter.chain(self._10sats_to_100sats.1.iter()));
iter = Box::new(iter.chain(self._100sats_to_1k_sats.1.iter()));
iter = Box::new(iter.chain(self._1k_sats_to_10k_sats.1.iter()));
iter = Box::new(iter.chain(self._10k_sats_to_100k_sats.1.iter()));
iter = Box::new(iter.chain(self._100k_sats_to_1m_sats.1.iter()));
iter = Box::new(iter.chain(self._1m_sats_to_10m_sats.1.iter()));
iter = Box::new(iter.chain(self._10m_sats_to_1btc.1.iter()));
iter = Box::new(iter.chain(self._1btc_to_10btc.1.iter()));
iter = Box::new(iter.chain(self._10btc_to_100btc.1.iter()));
iter = Box::new(iter.chain(self._100btc_to_1k_btc.1.iter()));
iter = Box::new(iter.chain(self._1k_btc_to_10k_btc.1.iter()));
iter = Box::new(iter.chain(self._10k_btc_to_100k_btc.1.iter()));
iter = Box::new(iter.chain(self._100k_btc_or_more.1.iter()));
iter
}
}

21
crates/brk_structs/src/groups/by_any_address.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
#[derive(Debug, Default)]
pub struct ByAnyAddress<T> {
pub loaded: T,
@@ -10,3 +13,21 @@ impl<T> ByAnyAddress<Option<T>> {
self.empty.take();
}
}
impl<T: IVecs> IVecs for ByAnyAddress<T> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[("loaded", &self.loaded), ("empty", &self.empty)]
.into_iter()
.map(|(name, field)| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.loaded.iter());
iter = Box::new(iter.chain(self.empty.iter()));
iter
}
}

29
crates/brk_structs/src/groups/by_epoch.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use crate::{HalvingEpoch, Height};
use super::GroupFilter;
@@ -58,3 +61,29 @@ impl<T> ByEpoch<(GroupFilter, T)> {
[&self._0.1, &self._1.1, &self._2.1, &self._3.1, &self._4.1].into_iter()
}
}
impl<T: IVecs> IVecs for ByEpoch<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("0", &self._0),
("1", &self._1),
("2", &self._2),
("3", &self._3),
("4", &self._4),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> = Box::new(self._0.1.iter());
iter = Box::new(iter.chain(self._1.1.iter()));
iter = Box::new(iter.chain(self._2.1.iter()));
iter = Box::new(iter.chain(self._3.1.iter()));
iter = Box::new(iter.chain(self._4.1.iter()));
iter
}
}

46
crates/brk_structs/src/groups/by_ge_amount.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use crate::Sats;
use super::GroupFilter;
@@ -110,3 +113,46 @@ impl<T> From<ByGreatEqualAmount<T>> for ByGreatEqualAmount<(GroupFilter, T)> {
}
}
}
impl<T: IVecs> IVecs for ByGreatEqualAmount<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("_1sat", &self._1sat),
("_10sats", &self._10sats),
("_100sats", &self._100sats),
("_1k_sats", &self._1k_sats),
("_10k_sats", &self._10k_sats),
("_100k_sats", &self._100k_sats),
("_1m_sats", &self._1m_sats),
("_10m_sats", &self._10m_sats),
("_1btc", &self._1btc),
("_10btc", &self._10btc),
("_100btc", &self._100btc),
("_1k_btc", &self._1k_btc),
("_10k_btc", &self._10k_btc),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self._1sat.1.iter());
iter = Box::new(iter.chain(self._10sats.1.iter()));
iter = Box::new(iter.chain(self._100sats.1.iter()));
iter = Box::new(iter.chain(self._1k_sats.1.iter()));
iter = Box::new(iter.chain(self._10k_sats.1.iter()));
iter = Box::new(iter.chain(self._100k_sats.1.iter()));
iter = Box::new(iter.chain(self._1m_sats.1.iter()));
iter = Box::new(iter.chain(self._10m_sats.1.iter()));
iter = Box::new(iter.chain(self._1btc.1.iter()));
iter = Box::new(iter.chain(self._10btc.1.iter()));
iter = Box::new(iter.chain(self._100btc.1.iter()));
iter = Box::new(iter.chain(self._1k_btc.1.iter()));
iter = Box::new(iter.chain(self._10k_btc.1.iter()));
iter
}
}

46
crates/brk_structs/src/groups/by_lt_amount.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use crate::Sats;
use super::GroupFilter;
@@ -86,3 +89,46 @@ impl<T> From<ByLowerThanAmount<T>> for ByLowerThanAmount<(GroupFilter, T)> {
}
}
}
impl<T: IVecs> IVecs for ByLowerThanAmount<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("10sats", &self._10sats),
("100sats", &self._100sats),
("1k_sats", &self._1k_sats),
("10k_sats", &self._10k_sats),
("100k_sats", &self._100k_sats),
("1m_sats", &self._1m_sats),
("10m_sats", &self._10m_sats),
("1btc", &self._1btc),
("10btc", &self._10btc),
("100btc", &self._100btc),
("1k_btc", &self._1k_btc),
("10k_btc", &self._10k_btc),
("100k_btc", &self._100k_btc),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self._10sats.1.iter());
iter = Box::new(iter.chain(self._100sats.1.iter()));
iter = Box::new(iter.chain(self._1k_sats.1.iter()));
iter = Box::new(iter.chain(self._10k_sats.1.iter()));
iter = Box::new(iter.chain(self._100k_sats.1.iter()));
iter = Box::new(iter.chain(self._1m_sats.1.iter()));
iter = Box::new(iter.chain(self._10m_sats.1.iter()));
iter = Box::new(iter.chain(self._1btc.1.iter()));
iter = Box::new(iter.chain(self._10btc.1.iter()));
iter = Box::new(iter.chain(self._100btc.1.iter()));
iter = Box::new(iter.chain(self._1k_btc.1.iter()));
iter = Box::new(iter.chain(self._10k_btc.1.iter()));
iter = Box::new(iter.chain(self._100k_btc.1.iter()));
iter
}
}

56
crates/brk_structs/src/groups/by_max_age.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use super::GroupFilter;
#[derive(Default, Clone)]
@@ -98,3 +101,56 @@ impl<T> From<ByMaxAge<T>> for ByMaxAge<(GroupFilter, T)> {
}
}
}
impl<T: IVecs> IVecs for ByMaxAge<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("1w", &self._1w),
("1m", &self._1m),
("2m", &self._2m),
("3m", &self._3m),
("4m", &self._4m),
("5m", &self._5m),
("6m", &self._6m),
("1y", &self._1y),
("2y", &self._2y),
("3y", &self._3y),
("4y", &self._4y),
("5y", &self._5y),
("6y", &self._6y),
("7y", &self._7y),
("8y", &self._8y),
("10y", &self._10y),
("12y", &self._12y),
("15y", &self._15y),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self._1w.1.iter());
iter = Box::new(iter.chain(self._1m.1.iter()));
iter = Box::new(iter.chain(self._2m.1.iter()));
iter = Box::new(iter.chain(self._3m.1.iter()));
iter = Box::new(iter.chain(self._4m.1.iter()));
iter = Box::new(iter.chain(self._5m.1.iter()));
iter = Box::new(iter.chain(self._6m.1.iter()));
iter = Box::new(iter.chain(self._1y.1.iter()));
iter = Box::new(iter.chain(self._2y.1.iter()));
iter = Box::new(iter.chain(self._3y.1.iter()));
iter = Box::new(iter.chain(self._4y.1.iter()));
iter = Box::new(iter.chain(self._5y.1.iter()));
iter = Box::new(iter.chain(self._6y.1.iter()));
iter = Box::new(iter.chain(self._7y.1.iter()));
iter = Box::new(iter.chain(self._8y.1.iter()));
iter = Box::new(iter.chain(self._10y.1.iter()));
iter = Box::new(iter.chain(self._12y.1.iter()));
iter = Box::new(iter.chain(self._15y.1.iter()));
iter
}
}

56
crates/brk_structs/src/groups/by_min_age.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use super::GroupFilter;
#[derive(Default, Clone)]
@@ -98,3 +101,56 @@ impl<T> From<ByMinAge<T>> for ByMinAge<(GroupFilter, T)> {
}
}
}
impl<T: IVecs> IVecs for ByMinAge<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("1d", &self._1d),
("1w", &self._1w),
("1m", &self._1m),
("2m", &self._2m),
("3m", &self._3m),
("4m", &self._4m),
("5m", &self._5m),
("6m", &self._6m),
("1y", &self._1y),
("2y", &self._2y),
("3y", &self._3y),
("4y", &self._4y),
("5y", &self._5y),
("6y", &self._6y),
("7y", &self._7y),
("8y", &self._8y),
("10y", &self._10y),
("12y", &self._12y),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self._1d.1.iter());
iter = Box::new(iter.chain(self._1w.1.iter()));
iter = Box::new(iter.chain(self._1m.1.iter()));
iter = Box::new(iter.chain(self._2m.1.iter()));
iter = Box::new(iter.chain(self._3m.1.iter()));
iter = Box::new(iter.chain(self._4m.1.iter()));
iter = Box::new(iter.chain(self._5m.1.iter()));
iter = Box::new(iter.chain(self._6m.1.iter()));
iter = Box::new(iter.chain(self._1y.1.iter()));
iter = Box::new(iter.chain(self._2y.1.iter()));
iter = Box::new(iter.chain(self._3y.1.iter()));
iter = Box::new(iter.chain(self._4y.1.iter()));
iter = Box::new(iter.chain(self._5y.1.iter()));
iter = Box::new(iter.chain(self._6y.1.iter()));
iter = Box::new(iter.chain(self._7y.1.iter()));
iter = Box::new(iter.chain(self._8y.1.iter()));
iter = Box::new(iter.chain(self._10y.1.iter()));
iter = Box::new(iter.chain(self._12y.1.iter()));
iter
}
}

42
crates/brk_structs/src/groups/by_spendable_type.rs
View File

@@ -1,5 +1,8 @@
use std::ops::{Add, AddAssign};
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use crate::OutputType;
use super::GroupFilter;
@@ -149,3 +152,42 @@ where
self.empty += rhs.empty;
}
}
impl<T: IVecs> IVecs for BySpendableType<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("p2pk65", &self.p2pk65),
("p2pk33", &self.p2pk33),
("p2pkh", &self.p2pkh),
("p2ms", &self.p2ms),
("p2sh", &self.p2sh),
("p2wpkh", &self.p2wpkh),
("p2wsh", &self.p2wsh),
("p2tr", &self.p2tr),
("p2a", &self.p2a),
("unknown", &self.unknown),
("empty", &self.empty),
]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.p2pk65.1.iter());
iter = Box::new(iter.chain(self.p2pk33.1.iter()));
iter = Box::new(iter.chain(self.p2pkh.1.iter()));
iter = Box::new(iter.chain(self.p2ms.1.iter()));
iter = Box::new(iter.chain(self.p2sh.1.iter()));
iter = Box::new(iter.chain(self.p2wpkh.1.iter()));
iter = Box::new(iter.chain(self.p2wsh.1.iter()));
iter = Box::new(iter.chain(self.p2tr.1.iter()));
iter = Box::new(iter.chain(self.p2a.1.iter()));
iter = Box::new(iter.chain(self.unknown.1.iter()));
iter = Box::new(iter.chain(self.empty.1.iter()));
iter
}
}

21
crates/brk_structs/src/groups/by_term.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use super::GroupFilter;
#[derive(Default, Clone)]
@@ -26,3 +29,21 @@ impl<T> From<ByTerm<T>> for ByTerm<(GroupFilter, T)> {
}
}
}
impl<T: IVecs> IVecs for ByTerm<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[("short", &self.short), ("long", &self.long)]
.into_iter()
.map(|(name, (_, field))| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.short.1.iter());
iter = Box::new(iter.chain(self.long.1.iter()));
iter
}
}

26
crates/brk_structs/src/groups/by_type.rs
View File

@@ -1,6 +1,9 @@
use std::ops::{Add, AddAssign};
use crate::OutputType;
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use crate::{GroupFilter, OutputType};
use super::{BySpendableType, ByUnspendableType};
@@ -70,3 +73,24 @@ where
self.unspendable += rhs.unspendable;
}
}
// impl<T: IVecs> IVecs for GroupedByType<(GroupFilter, T)> {
// fn to_tree_node(&self) -> TreeNode {
// TreeNode::Branch(
// [
// ("spendable", self.spendable.to_tree_node()),
// ("unspendable", self.unspendable.to_tree_node()),
// ]
// .into_iter()
// .map(|(name, node)| (name.to_string(), node))
// .collect(),
// )
// }
// fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
// let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
// Box::new(self.spendable.iter());
// iter = Box::new(iter.chain(self.unspendable.iter()));
// iter
// }
// }

18
crates/brk_structs/src/groups/by_unspendable_type.rs
View File

@@ -1,5 +1,8 @@
use std::ops::{Add, AddAssign};
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
#[derive(Default, Clone, Debug)]
pub struct ByUnspendableType<T> {
pub opreturn: T,
@@ -31,3 +34,18 @@ where
self.opreturn += rhs.opreturn;
}
}
impl<T: IVecs> IVecs for ByUnspendableType<T> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[("opreturn", &self.opreturn)]
.into_iter()
.map(|(name, field)| (name.to_string(), field.to_tree_node()))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
self.opreturn.iter()
}
}

40
crates/brk_structs/src/groups/utxo.rs
View File

@@ -1,3 +1,6 @@
use brk_vecs::{IVecs, TreeNode};
use vecdb::AnyCollectableVec;
use crate::{
ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge, ByMinAge,
BySpendableType, ByTerm, GroupFilter,
@@ -83,3 +86,40 @@ impl<T> From<UTXOGroups<T>> for UTXOGroups<(GroupFilter, T)> {
}
}
}
impl<T: IVecs> IVecs for UTXOGroups<(GroupFilter, T)> {
fn to_tree_node(&self) -> TreeNode {
TreeNode::Branch(
[
("all", self.all.1.to_tree_node()),
("age_range", self.age_range.to_tree_node()),
("epoch", self.epoch.to_tree_node()),
("min_age", self.min_age.to_tree_node()),
("ge_amount", self.ge_amount.to_tree_node()),
("amount_range", self.amount_range.to_tree_node()),
("term", self.term.to_tree_node()),
("type", self._type.to_tree_node()),
("max_age", self.max_age.to_tree_node()),
("lt_amount", self.lt_amount.to_tree_node()),
]
.into_iter()
.map(|(name, node)| (name.to_string(), node))
.collect(),
)
}
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec> {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec>> =
Box::new(self.all.1.iter());
iter = Box::new(iter.chain(IVecs::iter(&self.age_range)));
iter = Box::new(iter.chain(self.epoch.iter()));
iter = Box::new(iter.chain(self.min_age.iter()));
iter = Box::new(iter.chain(IVecs::iter(&self.ge_amount)));
iter = Box::new(iter.chain(IVecs::iter(&self.amount_range)));
iter = Box::new(iter.chain(self.term.iter()));
iter = Box::new(iter.chain(self._type.iter()));
iter = Box::new(iter.chain(self.max_age.iter()));
iter = Box::new(iter.chain(self.lt_amount.iter()));
iter
}
}

4
crates/brk_vecs/Cargo.toml
View File

@@ -9,6 +9,10 @@ repository.workspace = true
rust-version.workspace = true
build = "build.rs"
[features]
derive = ["brk_vecs_derive"]
[dependencies]
brk_vecs_derive = { workspace = true, optional = true }
serde = { workspace = true }
vecdb = { workspace = true }

16
crates/brk_vecs/src/lib.rs
View File

@@ -1,13 +1,13 @@
use std::collections::HashMap;
#[cfg(feature = "derive")]
pub use brk_vecs_derive::IVecs;
use serde::Serialize;
use vecdb::AnyCollectableVec;
pub trait IVecs {
fn to_tree_node(&self) -> TreeNode;
fn iter_any_collectable<'a>(
&'a self,
) -> Box<dyn Iterator<Item = &'a dyn AnyCollectableVec> + 'a>;
fn iter(&self) -> impl Iterator<Item = &dyn AnyCollectableVec>;
}
// Terminal implementation for any type that implements AnyCollectableVec
@@ -16,7 +16,7 @@ pub trait IVecs {
// TreeNode::Leaf(self.name().to_string())
// }
// fn iter_any_collectable<'a>(
// fn iter<'a>(
// &'a self,
// ) -> Box<dyn Iterator<Item = &'a dyn AnyCollectableVec> + 'a> {
// Box::new(std::iter::once(self as &dyn AnyCollectableVec))
@@ -32,11 +32,11 @@ pub trait IVecs {
// }
// }
// fn iter_any_collectable<'a>(
// fn iter<'a>(
// &'a self,
// ) -> Box<dyn Iterator<Item = &'a dyn AnyCollectableVec> + 'a> {
// match self {
// Some(inner) => inner.iter_any_collectable(),
// Some(inner) => inner.iter(),
// None => Box::new(std::iter::empty()),
// }
// }
@@ -48,10 +48,10 @@ pub trait IVecs {
// (**self).to_tree_node()
// }
// fn iter_any_collectable<'a>(
// fn iter<'a>(
// &'a self,
// ) -> Box<dyn Iterator<Item = &'a dyn AnyCollectableVec> + 'a> {
// (**self).iter_any_collectable()
// (**self).iter()
// }
// }

244
crates/brk_vecs_derive/src/lib.rs
View File

@@ -6,21 +6,60 @@ use syn::{Data, DeriveInput, Fields, Type, parse_macro_input};
pub fn derive_ivecs(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeriveInput);
let name = &input.ident;
let generics = &input.generics;
let (impl_generics, ty_generics, _) = generics.split_for_impl();
// Build extended where clause with Send + Sync bounds
let generic_params = generics.type_params().map(|p| &p.ident);
let original_predicates = &generics.where_clause.as_ref().map(|w| &w.predicates);
let where_clause = if original_predicates.is_some() || generics.type_params().count() > 0 {
quote! {
where
#(#generic_params: Send + Sync + std::fmt::Debug,)*
#original_predicates
}
} else {
quote! {}
};
let traverse_impl = match &input.data {
Data::Struct(data) => {
let field_traversals = generate_field_traversals(&data.fields);
let iterator_impl = generate_iterator_impl(&data.fields);
match &data.fields {
Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
// Special case for single-field tuple structs - just delegate
quote! {
impl #impl_generics IVecs for #name #ty_generics
#where_clause
{
fn to_tree_node(&self) -> brk_vecs::TreeNode {
self.0.to_tree_node()
}
quote! {
impl IVecs for #name {
fn to_tree_node(&self) -> TreeNode {
let mut children = std::collections::HashMap::new();
#field_traversals
TreeNode::Branch(children)
fn iter(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
IVecs::iter(&self.0)
}
}
}
}
_ => {
// Normal struct with named fields
let field_traversals = generate_field_traversals(&data.fields);
let iterator_impl = generate_iterator_impl(&data.fields);
#iterator_impl
quote! {
impl #impl_generics IVecs for #name #ty_generics
#where_clause
{
fn to_tree_node(&self) -> brk_vecs::TreeNode {
let mut children = std::collections::HashMap::new();
#field_traversals
brk_vecs::TreeNode::Branch(children)
}
#iterator_impl
}
}
}
}
}
@@ -36,9 +75,7 @@ fn is_vec_type(ty: &Type) -> bool {
&& let Some(segment) = type_path.path.segments.last()
{
let ident = segment.ident.to_string();
// Heuristic: if it ends with "Vec", it's likely a direct vec type
// This is more maintainable than hardcoding all vec types
return ident.ends_with("Vec");
return ident.ends_with("Vec") || ident.starts_with("LazyVecFrom");
}
false
}
@@ -58,12 +95,60 @@ fn generate_field_traversals(fields: &Fields) -> proc_macro2::TokenStream {
return None;
}
Some(quote! {
children.insert(
String::from(#field_name_str),
self.#field_name.to_tree_node()
);
})
// Check for Option<inner> types
if let Some(inner_ty) = get_option_inner_type(&f.ty) {
if is_vec_like(inner_ty) {
// Option<Vec> or Option<Box<Vec>>
let vec_access = if get_box_inner_type(inner_ty).is_some() {
quote! { vec.as_ref() }
} else {
quote! { vec }
};
return Some(quote! {
if let Some(ref vec) = self.#field_name {
children.insert(
String::from(#field_name_str),
brk_vecs::TreeNode::Leaf(vecdb::AnyVec::name(#vec_access).to_string())
);
}
});
} else {
// Option<nested_struct>
return Some(quote! {
if let Some(ref nested) = self.#field_name {
children.insert(
String::from(#field_name_str),
nested.to_tree_node()
);
}
});
}
}
// Check for direct vec or Box<vec>
if is_vec_like(&f.ty) {
let vec_access = if get_box_inner_type(&f.ty).is_some() {
quote! { self.#field_name.as_ref() }
} else {
quote! { &self.#field_name }
};
Some(quote! {
children.insert(
String::from(#field_name_str),
brk_vecs::TreeNode::Leaf(vecdb::AnyVec::name(#vec_access).to_string())
);
})
} else {
// Direct nested struct
Some(quote! {
children.insert(
String::from(#field_name_str),
self.#field_name.to_tree_node()
);
})
}
});
quote! { #(#traversals)* }
@@ -74,7 +159,7 @@ fn generate_field_traversals(fields: &Fields) -> proc_macro2::TokenStream {
fn has_skip_attribute(field: &syn::Field) -> bool {
field.attrs.iter().any(|attr| {
attr.path().is_ident("vec_tree")
attr.path().is_ident("vecs")
&& attr
.parse_args::<syn::Ident>()
.map(|ident| ident == "skip")
@@ -82,13 +167,22 @@ fn has_skip_attribute(field: &syn::Field) -> bool {
})
}
fn is_vec_like(ty: &Type) -> bool {
if is_vec_type(ty) {
return true;
}
if let Some(inner) = get_box_inner_type(ty) {
return is_vec_type(inner);
}
false
}
fn generate_iterator_impl(fields: &Fields) -> proc_macro2::TokenStream {
match fields {
Fields::Named(fields) => {
let mut direct_vecs = Vec::new();
let mut option_vecs = Vec::new();
let mut option_nested = Vec::new();
let mut nested_fields = Vec::new();
let mut option_box_vecs = Vec::new();
for field in fields.named.iter() {
if let Some(field_name) = &field.ident {
@@ -98,61 +192,99 @@ fn generate_iterator_impl(fields: &Fields) -> proc_macro2::TokenStream {
if let Some(inner_ty) = get_option_inner_type(&field.ty) {
if is_vec_type(inner_ty) {
// Option<Vec> - use as_ref()
option_vecs.push(field_name);
} else {
option_nested.push(field_name);
} else if let Some(box_inner) = get_box_inner_type(inner_ty)
&& is_vec_type(box_inner)
{
// Option<Box<Vec>> - use as_deref()
option_box_vecs.push(field_name);
}
} else if is_vec_type(&field.ty) {
} else if is_vec_like(&field.ty) {
// Direct Vec or Box<Vec>
direct_vecs.push(field_name);
} else {
nested_fields.push(field_name);
}
}
}
let base = if !direct_vecs.is_empty() {
if direct_vecs.is_empty() && option_vecs.is_empty() && option_box_vecs.is_empty() {
quote! {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec> + '_> = Box::new(
[#(&self.#direct_vecs as &dyn AnyCollectableVec,)*].into_iter()
);
fn iter(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
std::iter::empty()
}
}
} else {
let direct_part = if !direct_vecs.is_empty() {
quote! {
let direct_iter = [
#(&self.#direct_vecs as &dyn vecdb::AnyCollectableVec,)*
].into_iter();
}
} else {
quote! {
let direct_iter = std::iter::empty();
}
};
let option_part = if !option_vecs.is_empty() {
quote! {
let option_iter = [
#((&self.#option_vecs).as_ref().map(|x| x as &dyn vecdb::AnyCollectableVec),)*
]
.into_iter()
.flatten();
}
} else {
quote! {
let option_iter = std::iter::empty();
}
};
let option_box_part = if !option_box_vecs.is_empty() {
quote! {
let option_box_iter = [
#(self.#option_box_vecs.as_deref(),)*
]
.into_iter()
.flatten()
.map(|x| x as &dyn vecdb::AnyCollectableVec);
}
} else {
quote! {
let option_box_iter = std::iter::empty();
}
};
quote! {
let mut iter: Box<dyn Iterator<Item = &dyn AnyCollectableVec> + '_> =
Box::new(std::iter::empty());
}
};
let option_vec_chains = option_vecs.iter().map(|f| {
quote! { iter = Box::new(iter.chain(self.#f.iter())); }
});
let option_nested_chains = option_nested.iter().map(|f| {
quote! { iter = Box::new(iter.chain(self.#f.iter().flat_map(|v| v.iter_any_collectable()))); }
});
let nested_chains = nested_fields.iter().map(|f| {
quote! { iter = Box::new(iter.chain(self.#f.iter_any_collectable())); }
});
quote! {
fn iter_any_collectable<'a>(&'a self) -> Box<dyn Iterator<Item = &'a dyn AnyCollectableVec> + 'a> {
#base
#(#option_vec_chains)*
#(#option_nested_chains)*
#(#nested_chains)*
iter
fn iter(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
#direct_part
#option_part
#option_box_part
direct_iter.chain(option_iter).chain(option_box_iter)
}
}
}
}
_ => quote! {
fn iter_any_collectable<'a>(&'a self) -> Box<dyn Iterator<Item = &'a dyn AnyCollectableVec> + 'a> {
Box::new(std::iter::empty())
fn iter(&self) -> impl Iterator<Item = &dyn vecdb::AnyCollectableVec> {
std::iter::empty()
}
},
}
}
fn get_box_inner_type(ty: &Type) -> Option<&Type> {
if let Type::Path(type_path) = ty
&& let Some(segment) = type_path.path.segments.last()
&& segment.ident == "Box"
&& let syn::PathArguments::AngleBracketed(args) = &segment.arguments
&& let Some(syn::GenericArgument::Type(inner_ty)) = args.args.first()
{
return Some(inner_ty);
}
None
}
fn get_option_inner_type(ty: &Type) -> Option<&Type> {
if let Type::Path(type_path) = ty
&& let Some(segment) = type_path.path.segments.last()