109 lines
2.9 KiB
Rust
109 lines
2.9 KiB
Rust
use std::sync::Arc;
|
|
|
|
use crate::io_engine::*;
|
|
use crate::pdata::array::*;
|
|
use crate::pdata::array_block::*;
|
|
use crate::pdata::btree::*;
|
|
use crate::pdata::btree_walker::*;
|
|
use crate::pdata::unpack::*;
|
|
|
|
//------------------------------------------
|
|
|
|
pub struct ArrayWalker {
|
|
engine: Arc<dyn IoEngine + Send + Sync>,
|
|
ignore_non_fatal: bool
|
|
}
|
|
|
|
// FIXME: define another Result type for array visiting?
|
|
pub trait ArrayBlockVisitor<V: Unpack> {
|
|
fn visit(
|
|
&self,
|
|
index: u64,
|
|
v: V,
|
|
) -> anyhow::Result<()>;
|
|
}
|
|
|
|
struct BlockValueVisitor<V> {
|
|
engine: Arc<dyn IoEngine + Send + Sync>,
|
|
array_block_visitor: Box<dyn ArrayBlockVisitor<V>>,
|
|
}
|
|
|
|
impl<V: Unpack + Copy> BlockValueVisitor<V> {
|
|
pub fn new<Visitor: 'static + ArrayBlockVisitor<V>>(
|
|
e: Arc<dyn IoEngine + Send + Sync>,
|
|
v: Box<Visitor>,
|
|
) -> BlockValueVisitor<V> {
|
|
BlockValueVisitor {
|
|
engine: e,
|
|
array_block_visitor: v,
|
|
}
|
|
}
|
|
|
|
pub fn visit_array_block(
|
|
&self,
|
|
index: u64,
|
|
array_block: ArrayBlock<V>,
|
|
) {
|
|
let begin = index * u64::from(array_block.header.nr_entries);
|
|
for i in 0..array_block.header.nr_entries {
|
|
self.array_block_visitor.visit(begin + u64::from(i), array_block.values[i as usize]).unwrap();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<V: Unpack + Copy> NodeVisitor<ArrayBlockEntry> for BlockValueVisitor<V> {
|
|
// FIXME: return errors
|
|
fn visit(
|
|
&self,
|
|
path: &[u64],
|
|
_kr: &KeyRange,
|
|
_h: &NodeHeader,
|
|
keys: &[u64],
|
|
values: &[ArrayBlockEntry],
|
|
) -> Result<()> {
|
|
for n in 0..keys.len() {
|
|
let index = keys[n];
|
|
let b = self.engine.read(values[n].block).map_err(|_| io_err(path))?;
|
|
let array_block = unpack_array_block::<V>(b.get_data()).map_err(|_| io_err(path))?;
|
|
self.visit_array_block(index, array_block);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
// FIXME: stub
|
|
fn visit_again(&self, _path: &[u64], _b: u64) -> Result<()> {
|
|
Ok(())
|
|
}
|
|
|
|
// FIXME: stub
|
|
fn end_walk(&self) -> Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl ArrayWalker {
|
|
pub fn new(engine: Arc<dyn IoEngine + Send + Sync>, ignore_non_fatal: bool) -> ArrayWalker {
|
|
let r: ArrayWalker = ArrayWalker {
|
|
engine,
|
|
ignore_non_fatal,
|
|
};
|
|
r
|
|
}
|
|
|
|
// FIXME: pass the visitor by reference?
|
|
// FIXME: redefine the Result type for array visiting?
|
|
pub fn walk<BV, V: Copy>(&self, visitor: Box<BV>, root: u64) -> Result<()>
|
|
where
|
|
BV: 'static + ArrayBlockVisitor<V>,
|
|
V: Unpack,
|
|
{
|
|
let w = BTreeWalker::new(self.engine.clone(), self.ignore_non_fatal);
|
|
let mut path = Vec::new(); // FIXME: eliminate this line?
|
|
path.push(0);
|
|
let v = BlockValueVisitor::<V>::new(self.engine.clone(), visitor);
|
|
w.walk(&mut path, &v, root)
|
|
}
|
|
}
|
|
|
|
//------------------------------------------
|