take owned vec in data

src/drive.rs

···
 
 pub async fn load_car<R: AsyncRead + Unpin, T: Processable>(
     reader: R,
-    process: fn(&[u8]) -> T,
+    process: fn(Vec<u8>) -> T,
     max_size: usize,
 ) -> Result<Vehicle<R, T>, DriveError> {
     let mut mem_blocks = HashMap::new();
···
         let maybe_processed = if Node::could_be(&data) {
             MaybeProcessedBlock::Raw(data)
         } else {
-            MaybeProcessedBlock::Processed(process(&data))
+            MaybeProcessedBlock::Processed(process(data))
         };
 
         // stash (maybe processed) blocks in memory as long as we have room
···
 pub struct BigCar<R: AsyncRead + Unpin, T: Processable> {
     car: CarReader<R>,
     root: Cid,
-    process: fn(&[u8]) -> T,
+    process: fn(Vec<u8>) -> T,
     max_size: usize,
     mem_blocks: HashMap<Cid, MaybeProcessedBlock<T>>,
     pub commit: Option<Commit>,
···
                 let maybe_processed = if Node::could_be(&data) {
                     MaybeProcessedBlock::Raw(data)
                 } else {
-                    MaybeProcessedBlock::Processed((self.process)(&data))
+                    MaybeProcessedBlock::Processed((self.process)(data))
                 };
                 mem_size += std::mem::size_of::<Cid>() + maybe_processed.get_size();
                 chunk.push((cid, maybe_processed));
···
 }
 
 pub struct BigCarReady<T: Clone, A: DiskAccess> {
-    process: fn(&[u8]) -> T,
+    process: fn(Vec<u8>) -> T,
     access: A,
     walker: Walker,
 }
···
 pub struct MemDriver<T: Processable> {
     blocks: HashMap<Cid, MaybeProcessedBlock<T>>,
     walker: Walker,
-    process: fn(&[u8]) -> T,
+    process: fn(Vec<u8>) -> T,
 }
 
 impl<T: Processable> MemDriver<T> {

src/walk.rs

···
     pub fn step<T: Processable>(
         &mut self,
         blocks: &mut HashMap<Cid, MaybeProcessedBlock<T>>,
-        process: impl Fn(&[u8]) -> T,
+        process: impl Fn(Vec<u8>) -> T,
     ) -> Result<Step<T>, Trip> {
         loop {
             let Some(mut need) = self.stack.last() else {
···
                     };
                     let rkey = rkey.clone();
                     let data = match data {
-                        MaybeProcessedBlock::Raw(data) => process(data),
+                        MaybeProcessedBlock::Raw(data) => process(data.to_vec()),
                         MaybeProcessedBlock::Processed(t) => t.clone(),
                     };
 
···
     pub fn disk_step<T: Processable, R: DiskReader>(
         &mut self,
         reader: &mut R,
-        process: impl Fn(&[u8]) -> T,
+        process: impl Fn(Vec<u8>) -> T,
     ) -> Result<Step<T>, DiskTrip<R::StorageError>> {
         loop {
             let Some(mut need) = self.stack.last() else {
···
                     let data: MaybeProcessedBlock<T> = crate::drive::decode(&data_bytes)?;
                     let rkey = rkey.clone();
                     let data = match data {
-                        MaybeProcessedBlock::Raw(data) => process(&data),
+                        MaybeProcessedBlock::Raw(data) => process(data),
                         MaybeProcessedBlock::Processed(t) => t.clone(),
                     };