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

global: replace Value enum with Cow

Browse Source
This commit is contained in:
nym21
2025-06-27 20:39:19 +02:00
parent 8ea13544de
commit 663092b501
25 changed files with 239 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -66,7 +66,12 @@ impl Computer {
exit: &Exit,
) -> color_eyre::Result<()> {
info!("Computing...");
self.vecs
.compute(indexer, starting_indexes, self.fetcher.as_mut(), exit)
self.vecs.compute(
indexer,
starting_indexes,
self.fetcher.as_mut(),
exit,
&mut self.stores,
)
}
}

18
crates/brk_computer/src/vecs/grouped/builder.rs
View File

@@ -221,7 +221,7 @@ where
cumulative_vec.iter().unwrap_get_inner(index)
});
source.iter_at(index).try_for_each(|(i, v)| -> Result<()> {
cumulative = cumulative.clone() + v.into_inner();
cumulative = cumulative.clone() + v.into_owned();
cumulative_vec.forced_push_at(i, cumulative.clone(), exit)
})?;
@@ -261,7 +261,7 @@ where
first_indexes
.iter_at(index)
.try_for_each(|(i, first_index)| -> Result<()> {
let first_index = first_index.into_inner();
let first_index = first_index.into_owned();
let count_index = count_indexes_iter.unwrap_get_inner(i);
@@ -284,7 +284,7 @@ where
// dbg!(first_index, count_index, last_index);
// })
// .unwrap()
// .into_inner();
// .into_owned();
last.forced_push_at(index, v, exit)?;
}
@@ -304,7 +304,7 @@ where
source_iter.set(first_index);
let mut values = (&mut source_iter)
.take(*count_index)
.map(|(_, v)| v.into_inner())
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
if needs_sorted {
@@ -435,7 +435,7 @@ where
first_indexes
.iter_at(index)
.try_for_each(|(i, first_index, ..)| -> Result<()> {
let first_index = first_index.into_inner();
let first_index = first_index.into_owned();
let count_index = count_indexes_iter.unwrap_get_inner(i);
@@ -473,7 +473,7 @@ where
source_max_iter.set(first_index);
let mut values = source_max_iter
.take(*count_index)
.map(|(_, v)| v.into_inner())
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
values.sort_unstable();
max.forced_push_at(i, values.last().unwrap().clone(), exit)?;
@@ -484,7 +484,7 @@ where
source_min_iter.set(first_index);
let mut values = source_min_iter
.take(*count_index)
.map(|(_, v)| v.into_inner())
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
values.sort_unstable();
min.forced_push_at(i, values.first().unwrap().clone(), exit)?;
@@ -497,7 +497,7 @@ where
source_average_iter.set(first_index);
let values = source_average_iter
.take(*count_index)
.map(|(_, v)| v.into_inner())
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
let len = values.len();
@@ -513,7 +513,7 @@ where
source_sum_iter.set(first_index);
let values = source_sum_iter
.take(*count_index)
.map(|(_, v)| v.into_inner())
.map(|(_, v)| v.into_owned())
.collect::<Vec<_>>();
let sum = values.into_iter().fold(T::from(0), |a, b| a + b);

2
crates/brk_computer/src/vecs/grouped/ratio_from_dateindex.rs
View File

@@ -677,7 +677,7 @@ impl ComputedRatioVecsFromDateIndex {
.unwrap()
.forced_push_at(index, nan, exit)?;
} else {
let ratio = ratio.into_inner();
let ratio = ratio.into_owned();
let pos = sorted.binary_search(&ratio).unwrap_or_else(|pos| pos);
sorted.insert(pos, ratio);
self.ratio_p0_1.dateindex.as_mut().unwrap().forced_push_at(

8
crates/brk_computer/src/vecs/grouped/value_from_txindex.rs
View File

@@ -69,7 +69,7 @@ impl ComputedValueVecsFromTxindex {
source.map_or_else(|| sats.txindex.as_ref().unwrap().boxed_clone(), |s| s),
|txindex: TxIndex, iter| {
iter.next_at(txindex.unwrap_to_usize()).map(|(_, value)| {
let sats = value.into_inner();
let sats = value.into_owned();
Bitcoin::from(sats)
})
},
@@ -100,14 +100,14 @@ impl ComputedValueVecsFromTxindex {
height_to_close_iter| {
let txindex = txindex.unwrap_to_usize();
txindex_to_btc_iter.next_at(txindex).and_then(|(_, value)| {
let btc = value.into_inner();
let btc = value.into_owned();
txindex_to_height_iter
.next_at(txindex)
.and_then(|(_, value)| {
let height = value.into_inner();
let height = value.into_owned();
height_to_close_iter
.next_at(height.unwrap_to_usize())
.map(|(_, close)| *close.into_inner() * btc)
.map(|(_, close)| *close.into_owned() * btc)
})
})
},

8
crates/brk_computer/src/vecs/indexes.rs
View File

@@ -144,10 +144,10 @@ impl Vecs {
txindex_to_first_inputindex_iter
.next_at(txindex)
.map(|(_, start)| {
let start = usize::from(start.into_inner());
let start = usize::from(start.into_owned());
let end = txindex_to_first_inputindex_iter
.next_at(txindex + 1)
.map(|(_, v)| usize::from(v.into_inner()))
.map(|(_, v)| usize::from(v.into_owned()))
.unwrap_or_else(|| inputindex_to_outputindex_iter.len());
StoredUsize::from((start..end).count())
})
@@ -167,10 +167,10 @@ impl Vecs {
txindex_to_first_outputindex_iter
.next_at(txindex)
.map(|(_, start)| {
let start = usize::from(start.into_inner());
let start = usize::from(start.into_owned());
let end = txindex_to_first_outputindex_iter
.next_at(txindex + 1)
.map(|(_, v)| usize::from(v.into_inner()))
.map(|(_, v)| usize::from(v.into_owned()))
.unwrap_or_else(|| outputindex_to_value_iter.len());
StoredUsize::from((start..end).count())
})

4
crates/brk_computer/src/vecs/mod.rs
View File

@@ -20,6 +20,8 @@ pub mod transactions;
pub use indexes::Indexes;
use log::info;
use crate::stores::Stores;
const VERSION: Version = Version::ONE;
#[derive(Clone)]
@@ -121,6 +123,7 @@ impl Vecs {
starting_indexes: brk_indexer::Indexes,
fetcher: Option<&mut Fetcher>,
exit: &Exit,
stores: &mut Stores,
) -> color_eyre::Result<()> {
info!("Computing indexes...");
let mut starting_indexes = self.indexes.compute(indexer, starting_indexes, exit)?;
@@ -178,6 +181,7 @@ impl Vecs {
&self.market,
&mut starting_indexes,
exit,
stores,
)?;
self.cointime.compute(

20
crates/brk_computer/src/vecs/stateful/mod.rs
View File

@@ -15,7 +15,10 @@ use rayon::prelude::*;
use brk_state::{BlockState, CohortStateTrait, SupplyState, Transacted};
use crate::vecs::{market, stateful::r#trait::CohortVecs};
use crate::{
stores::Stores,
vecs::{market, stateful::r#trait::CohortVecs},
};
use super::{
Indexes, fetched,
@@ -185,6 +188,7 @@ impl Vecs {
// Must take ownership as its indexes will be updated for this specific function
starting_indexes: &mut Indexes,
exit: &Exit,
stores: &mut Stores,
) -> color_eyre::Result<()> {
let height_to_first_outputindex = &indexer.vecs.height_to_first_outputindex;
let height_to_first_inputindex = &indexer.vecs.height_to_first_inputindex;
@@ -389,19 +393,19 @@ impl Vecs {
.get_or_read(inputindex, &inputindex_to_outputindex_mmap)
.unwrap()
.unwrap()
.into_inner();
.into_owned();
let value = outputindex_to_value
.get_or_read(outputindex, &outputindex_to_value_mmap)
.unwrap()
.unwrap()
.into_inner();
.into_owned();
let input_type = outputindex_to_outputtype
.get_or_read(outputindex, &outputindex_to_outputtype_mmap)
.unwrap()
.unwrap()
.into_inner();
.into_owned();
// dbg!(input_type);
@@ -413,13 +417,13 @@ impl Vecs {
.get_or_read(outputindex, &outputindex_to_txindex_mmap)
.unwrap()
.unwrap()
.into_inner();
.into_owned();
let height = txindex_to_height
.get_or_read(input_txindex, &txindex_to_height_mmap)
.unwrap()
.unwrap()
.into_inner();
.into_owned();
(height, value, input_type)
})
@@ -452,13 +456,13 @@ impl Vecs {
.get_or_read(outputindex, &outputindex_to_value_mmap)
.unwrap()
.unwrap()
.into_inner();
.into_owned();
let output_type = outputindex_to_outputtype
.get_or_read(outputindex, &outputindex_to_outputtype_mmap)
.unwrap()
.unwrap()
.into_inner();
.into_owned();
(value, output_type)
})

34
crates/brk_computer/src/vecs/transactions.rs
View File

@@ -110,13 +110,13 @@ impl Vecs {
inputindex_to_outputindex_iter
.next_at(index.unwrap_to_usize())
.map(|(inputindex, outputindex)| {
let outputindex = outputindex.into_inner();
let outputindex = outputindex.into_owned();
if outputindex == OutputIndex::COINBASE {
Sats::ZERO
} else if let Some((_, value)) =
outputindex_to_value_iter.next_at(outputindex.unwrap_to_usize())
{
value.into_inner()
value.into_owned()
} else {
dbg!(inputindex, outputindex);
panic!()
@@ -138,12 +138,12 @@ impl Vecs {
txindex_to_base_size_iter
.next_at(index)
.map(|(_, base_size)| {
let base_size = base_size.into_inner();
let base_size = base_size.into_owned();
let total_size = txindex_to_total_size_iter
.next_at(index)
.unwrap()
.1
.into_inner();
.into_owned();
// This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
let wu = usize::from(base_size) * 3 + usize::from(total_size);
@@ -164,7 +164,7 @@ impl Vecs {
let index = index.unwrap_to_usize();
iter.next_at(index).map(|(_, weight)| {
StoredUsize::from(
bitcoin::Weight::from(weight.into_inner()).to_vbytes_ceil() as usize
bitcoin::Weight::from(weight.into_owned()).to_vbytes_ceil() as usize
)
})
},
@@ -182,12 +182,12 @@ impl Vecs {
txindex_to_height_iter
.next_at(index.unwrap_to_usize())
.map(|(_, height)| {
let height = height.into_inner();
let height = height.into_owned();
let txindex = height_to_first_txindex_iter
.next_at(height.unwrap_to_usize())
.unwrap()
.1
.into_inner();
.into_owned();
index == txindex
})
@@ -211,12 +211,12 @@ impl Vecs {
txindex_to_first_inputindex_iter
.next_at(txindex)
.map(|(_, first_index)| {
let first_index = usize::from(first_index.into_inner());
let first_index = usize::from(first_index.into_owned());
let count = *txindex_to_input_count_iter
.next_at(txindex)
.unwrap()
.1
.into_inner();
.into_owned();
let range = first_index..first_index + count;
range.into_iter().fold(Sats::ZERO, |total, inputindex| {
total
@@ -224,7 +224,7 @@ impl Vecs {
.next_at(inputindex)
.unwrap()
.1
.into_inner()
.into_owned()
})
})
},
@@ -260,12 +260,12 @@ impl Vecs {
txindex_to_first_outputindex_iter
.next_at(txindex)
.map(|(_, first_index)| {
let first_index = usize::from(first_index.into_inner());
let first_index = usize::from(first_index.into_owned());
let count = *txindex_to_output_count_iter
.next_at(txindex)
.unwrap()
.1
.into_inner();
.into_owned();
let range = first_index..first_index + count;
range.into_iter().fold(Sats::ZERO, |total, outputindex| {
total
@@ -273,7 +273,7 @@ impl Vecs {
.next_at(outputindex)
.unwrap()
.1
.into_inner()
.into_owned()
})
})
},
@@ -303,12 +303,12 @@ impl Vecs {
|txindex: TxIndex, input_iter, output_iter| {
let txindex = txindex.unwrap_to_usize();
input_iter.next_at(txindex).and_then(|(_, value)| {
let input = value.into_inner();
let input = value.into_owned();
if input.is_zero() {
return Some(Sats::ZERO);
}
output_iter.next_at(txindex).map(|(_, value)| {
let output = value.into_inner();
let output = value.into_owned();
input.checked_sub(output).unwrap()
})
})
@@ -326,9 +326,9 @@ impl Vecs {
|txindex: TxIndex, fee_iter, vsize_iter| {
let txindex = txindex.unwrap_to_usize();
fee_iter.next_at(txindex).and_then(|(_, value)| {
let fee = value.into_inner();
let fee = value.into_owned();
vsize_iter.next_at(txindex).map(|(_, value)| {
let vsize = value.into_inner();
let vsize = value.into_owned();
Feerate::from((fee, vsize))
})
})