Adapt to new jbk SmallVec (#103)

mgautierfr · web-flow · commit 783bffaf14db · 2025-02-02T00:22:14.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/arx/src/light_path.rs b/arx/src/light_path.rs
@@ -1,14 +1,14 @@
 use std::io::Write;
 
 #[derive(Clone, Debug)]
-pub struct LightPath(Vec<Vec<u8>>);
+pub struct LightPath(Vec<jbk::SmallBytes>);
 
 impl LightPath {
     pub fn new() -> Self {
         Self(Vec::with_capacity(10))
     }
 
-    pub fn push(&mut self, component: Vec<u8>) {
+    pub fn push(&mut self, component: jbk::SmallBytes) {
         self.0.push(component);
     }
 
@@ -44,8 +44,8 @@ impl Default for LightPath {
     }
 }
 
-impl From<Vec<u8>> for LightPath {
-    fn from(s: Vec<u8>) -> Self {
+impl From<jbk::SmallBytes> for LightPath {
+    fn from(s: jbk::SmallBytes) -> Self {
         let mut p = Self::new();
         p.push(s);
         p
diff --git a/arx/src/list.rs b/arx/src/list.rs
@@ -11,7 +11,7 @@ use std::path::PathBuf;
 use anyhow::{anyhow, Context, Result};
 use clap::{Parser, ValueHint};
 
-type Path = Vec<u8>;
+type Path = jbk::SmallBytes;
 
 struct PathBuilder {
     path_property: jbk::reader::builder::ArrayProperty,
@@ -28,7 +28,7 @@ impl arx::Builder for PathBuilder {
 
     fn create_entry(&self, _idx: jbk::EntryIdx, reader: &ByteSlice) -> jbk::Result<Self::Entry> {
         let path_prop = self.path_property.create(reader)?;
-        let mut path = vec![];
+        let mut path = jbk::SmallBytes::new();
         path_prop.resolve_to_vec(&mut path)?;
         Ok(path)
     }
diff --git a/libarx/src/arx_fs.rs b/libarx/src/arx_fs.rs
@@ -93,7 +93,7 @@ impl LightLinkBuilder {
 }
 
 impl jbk::reader::builder::BuilderTrait for LightLinkBuilder {
-    type Entry = Vec<u8>;
+    type Entry = jbk::SmallBytes;
     type Error = FsError;
 
     fn create_entry(&self, idx: jbk::EntryIdx) -> Result<Option<Self::Entry>, Self::Error> {
@@ -102,7 +102,7 @@ impl jbk::reader::builder::BuilderTrait for LightLinkBuilder {
             .map(|reader| match self.variant_id_property.create(&reader)? {
                 Some(EntryType::Link) => {
                     let target = self.link_property.create(&reader)?;
-                    let mut vec = Vec::new();
+                    let mut vec = jbk::SmallBytes::new();
                     target.resolve_to_vec(&mut vec)?;
                     Ok(vec)
                 }
@@ -199,7 +199,7 @@ impl jbk::reader::builder::BuilderTrait for LightDirBuilder {
 
 struct LightCommonPath {
     file_type: Option<EntryType>,
-    path: Vec<u8>,
+    path: jbk::SmallBytes,
 }
 
 struct LightCommonPathBuilder {
@@ -227,7 +227,7 @@ impl jbk::reader::builder::BuilderTrait for LightCommonPathBuilder {
             .get_entry_reader(idx)
             .map(|reader| {
                 let path_prop = self.path_property.create(&reader)?;
-                let mut path = vec![];
+                let mut path = jbk::SmallBytes::new();
                 path_prop.resolve_to_vec(&mut path)?;
                 let file_type = self.variant_id_property.create(&reader)?;
                 Ok(LightCommonPath { file_type, path })
@@ -326,7 +326,7 @@ impl jbk::reader::builder::BuilderTrait for AttrBuilder {
                         match link.size() {
                             Some(s) => s as u64,
                             None => {
-                                let mut vec = Vec::new();
+                                let mut vec = jbk::SmallBytes::new();
                                 link.resolve_to_vec(&mut vec)?;
                                 vec.len() as u64
                             }
@@ -779,7 +779,7 @@ impl<'a, S: Stats> fuser::Filesystem for ArxFs<'a, S> {
                         // We remove "." and ".."
                         let entry_idx = range.offset() + jbk::EntryIdx::from(i as u32 - 2);
                         let entry_ino = Ino::from(entry_idx);
-                        let entry_path = OsString::from_vec(entry.path);
+                        let entry_path = OsString::from_vec(entry.path.to_vec());
                         let should_break = reply.add(
                             entry_ino.get(),
                             /* offset =*/ i,
diff --git a/libarx/src/create/entry_store_creator.rs b/libarx/src/create/entry_store_creator.rs
@@ -234,7 +234,10 @@ impl DirEntry {
                     )
                     .into());
                 }
-                values.insert(Property::Target, jbk::Value::Array(target.into()));
+                values.insert(
+                    Property::Target,
+                    jbk::Value::Array(Vec::from(target).into()),
+                );
                 let entry = Box::new(jbk::creator::BasicEntry::new_from_schema(
                     &entry_store.schema,
                     Some(EntryType::Link),
diff --git a/libarx/src/entry.rs b/libarx/src/entry.rs
@@ -5,7 +5,7 @@ use jbk::reader::ByteSlice;
 #[derive(Clone)]
 pub struct CommonPart {
     idx: jbk::EntryIdx,
-    path: Vec<u8>,
+    path: jbk::SmallBytes,
     parent: Option<jbk::EntryIdx>,
     owner: u32,
     group: u32,
@@ -18,7 +18,7 @@ pub trait CommonEntry {
     fn idx(&self) -> jbk::EntryIdx {
         self.common().idx
     }
-    fn path(&self) -> &Vec<u8> {
+    fn path(&self) -> &[u8] {
         &self.common().path
     }
     fn parent(&self) -> Option<jbk::EntryIdx> {
@@ -63,7 +63,7 @@ impl FileEntry {
 #[derive(Clone)]
 pub struct Link {
     common: CommonPart,
-    target: Vec<u8>,
+    target: jbk::SmallBytes,
 }
 
 impl CommonEntry for Link {
@@ -73,7 +73,7 @@ impl CommonEntry for Link {
 }
 
 impl Link {
-    pub fn target(&self) -> &Vec<u8> {
+    pub fn target(&self) -> &[u8] {
         &self.target
     }
 }
@@ -121,7 +121,7 @@ mod private {
 
         fn create_entry(&self, idx: jbk::EntryIdx, reader: &ByteSlice) -> jbk::Result<CommonPart> {
             let path_prop = self.path_property.create(reader)?;
-            let mut path = vec![];
+            let mut path = jbk::SmallBytes::new();
             path_prop.resolve_to_vec(&mut path)?;
             let parent = self.parent_prorperty.create(reader)?;
             let parent = if parent == 0 {
@@ -185,7 +185,7 @@ mod private {
         fn create_entry(&self, idx: jbk::EntryIdx, reader: &ByteSlice) -> jbk::Result<Self::Entry> {
             let common = self.common.create_entry(idx, reader)?;
             let target_prop = self.link_property.create(reader)?;
-            let mut target = vec![];
+            let mut target = jbk::SmallBytes::new();
             target_prop.resolve_to_vec(&mut target)?;
             Ok(Link { common, target })
         }
diff --git a/libarx/src/tools.rs b/libarx/src/tools.rs
@@ -1,3 +1,4 @@
+use core::convert::TryInto;
 use std::collections::HashSet;
 use std::fs::{create_dir_all, OpenOptions};
 use std::io::{ErrorKind, Write};
@@ -16,14 +17,14 @@ use jbk::reader::MayMissPack;
 use std::sync::{Arc, OnceLock};
 
 struct FileEntry {
-    path: String,
+    path: jbk::SmallString,
     content: jbk::ContentAddress,
     mtime: u64,
 }
 
 struct Link {
-    path: String,
-    target: String,
+    path: jbk::SmallString,
+    target: jbk::SmallString,
     mtime: u64,
 }
 
@@ -46,12 +47,12 @@ impl Builder for FileBuilder {
 
     fn create_entry(&self, _idx: jbk::EntryIdx, reader: &ByteSlice) -> jbk::Result<Self::Entry> {
         let path_prop = self.path_property.create(reader)?;
-        let mut path = vec![];
+        let mut path = jbk::SmallBytes::new();
         path_prop.resolve_to_vec(&mut path)?;
         let content = self.content_address_property.create(reader)?;
         let mtime = self.mtime_property.create(reader)?;
         Ok(FileEntry {
-            path: String::from_utf8(path)?,
+            path: path.try_into()?,
             content,
             mtime,
         })
@@ -77,16 +78,16 @@ impl Builder for LinkBuilder {
 
     fn create_entry(&self, _idx: jbk::EntryIdx, reader: &ByteSlice) -> jbk::Result<Self::Entry> {
         let path_prop = self.path_property.create(reader)?;
-        let mut path = vec![];
+        let mut path = jbk::SmallBytes::new();
         path_prop.resolve_to_vec(&mut path)?;
 
         let target_prop = self.link_property.create(reader)?;
-        let mut target = vec![];
+        let mut target = jbk::SmallBytes::new();
         target_prop.resolve_to_vec(&mut target)?;
         let mtime = self.mtime_property.create(reader)?;
         Ok(Link {
-            path: String::from_utf8(path)?,
-            target: String::from_utf8(target)?,
+            path: path.try_into()?,
+            target: target.try_into()?,
             mtime,
         })
     }
@@ -97,7 +98,7 @@ struct DirBuilder {
 }
 
 impl Builder for DirBuilder {
-    type Entry = String;
+    type Entry = jbk::SmallString;
 
     fn new(properties: &AllProperties) -> Self {
         Self {
@@ -107,9 +108,9 @@ impl Builder for DirBuilder {
 
     fn create_entry(&self, _idx: jbk::EntryIdx, reader: &ByteSlice) -> jbk::Result<Self::Entry> {
         let path_prop = self.path_property.create(reader)?;
-        let mut path = vec![];
+        let mut path = jbk::SmallBytes::new();
         path_prop.resolve_to_vec(&mut path)?;
-        Ok(String::from_utf8(path)?)
+        Ok(path.try_into()?)
     }
 }
 
@@ -196,9 +197,9 @@ where
     fn on_directory_enter(
         &self,
         current_path: &mut crate::PathBuf,
-        path: &String,
+        path: &jbk::SmallString,
     ) -> Result<bool, ExtractError> {
-        current_path.push(path);
+        current_path.push(path.as_str());
         if !self.should_extract(current_path, true) {
             return Ok(false);
         }
@@ -212,7 +213,7 @@ where
     fn on_directory_exit(
         &self,
         current_path: &mut crate::PathBuf,
-        _path: &String,
+        _path: &jbk::SmallString,
     ) -> Result<(), ExtractError> {
         current_path.pop();
         Ok(())
@@ -224,7 +225,7 @@ where
         entry: &FileEntry,
     ) -> Result<(), ExtractError> {
         let mut current_path = current_path.clone();
-        current_path.push(&entry.path);
+        current_path.push(entry.path.as_str());
         let entry_content = entry.content;
         let abs_path = self.abs_path(&current_path);
         let print_progress = self.print_progress;
@@ -323,13 +324,16 @@ where
 
     fn on_link(&self, current_path: &mut crate::PathBuf, link: &Link) -> Result<(), ExtractError> {
         let mut current_path = current_path.clone();
-        current_path.push(&link.path);
+        current_path.push(link.path.as_str());
         if !self.should_extract(&current_path, false) {
             current_path.pop();
             return Ok(());
         }
         let abs_path = self.abs_path(&current_path);
-        if let Err(e) = symlink(PathBuf::from(&link.target), PathBuf::from(&abs_path)) {
+        if let Err(e) = symlink(
+            PathBuf::from(link.target.as_str()),
+            PathBuf::from(&abs_path),
+        ) {
             match e.kind() {
                 ErrorKind::AlreadyExists => match self.overwrite {
                     Overwrite::Skip => return Ok(()),
@@ -343,14 +347,20 @@ where
                         let new_time = SystemTime::UNIX_EPOCH + Duration::from_secs(link.mtime);
                         if new_time >= existing_time {
                             std::fs::remove_file(&abs_path)?;
-                            symlink(PathBuf::from(&link.target), PathBuf::from(&abs_path))?;
+                            symlink(
+                                PathBuf::from(link.target.as_str()),
+                                PathBuf::from(&abs_path),
+                            )?;
                         } else {
                             return Ok(());
                         }
                     }
                     Overwrite::Overwrite => {
                         std::fs::remove_file(&abs_path)?;
-                        symlink(PathBuf::from(&link.target), PathBuf::from(&abs_path))?;
+                        symlink(
+                            PathBuf::from(link.target.as_str()),
+                            PathBuf::from(&abs_path),
+                        )?;
                     }
                     Overwrite::Error => return Err(e.into()),
                 },
diff --git a/python/src/entry.rs b/python/src/entry.rs
@@ -28,13 +28,13 @@ impl Entry {
     fn __repr__(&self) -> String {
         match &self.entry {
             arx::Entry::File(e) => {
-                format!("File({})", String::from_utf8(e.path().clone()).unwrap())
+                format!("File({})", String::from_utf8(e.path().to_vec()).unwrap())
             }
             arx::Entry::Link(e) => {
-                format!("Link({})", String::from_utf8(e.path().clone()).unwrap())
+                format!("Link({})", String::from_utf8(e.path().to_vec()).unwrap())
             }
             arx::Entry::Dir(_, e) => {
-                format!("Dir({})", String::from_utf8(e.path().clone()).unwrap())
+                format!("Dir({})", String::from_utf8(e.path().to_vec()).unwrap())
             }
         }
     }
@@ -53,9 +53,9 @@ impl Entry {
     #[getter]
     fn path(&self) -> PyResult<String> {
         Ok(match &self.entry {
-            arx::Entry::File(e) => String::from_utf8(e.path().clone()).unwrap(),
-            arx::Entry::Link(e) => String::from_utf8(e.path().clone()).unwrap(),
-            arx::Entry::Dir(_, e) => String::from_utf8(e.path().clone()).unwrap(),
+            arx::Entry::File(e) => String::from_utf8(e.path().to_vec()).unwrap(),
+            arx::Entry::Link(e) => String::from_utf8(e.path().to_vec()).unwrap(),
+            arx::Entry::Dir(_, e) => String::from_utf8(e.path().to_vec()).unwrap(),
         })
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1,14 +1,14 @@`
`1`	`1`	`use std::io::Write;`
`2`	`2`
`3`	`3`	`#[derive(Clone, Debug)]`
`4`		`-pub struct LightPath(Vec<Vec<u8>>);`
	`4`	`+pub struct LightPath(Vec<jbk::SmallBytes>);`
`5`	`5`
`6`	`6`	`impl LightPath {`
`7`	`7`	`pub fn new() -> Self {`
`8`	`8`	`Self(Vec::with_capacity(10))`
`9`	`9`	`}`
`10`	`10`
`11`		`- pub fn push(&mut self, component: Vec<u8>) {`
	`11`	`+ pub fn push(&mut self, component: jbk::SmallBytes) {`
`12`	`12`	`self.0.push(component);`
`13`	`13`	`}`
`14`	`14`
`@@ -44,8 +44,8 @@ impl Default for LightPath {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`-impl From<Vec<u8>> for LightPath {`
`48`		`- fn from(s: Vec<u8>) -> Self {`
	`47`	`+impl From<jbk::SmallBytes> for LightPath {`
	`48`	`+ fn from(s: jbk::SmallBytes) -> Self {`
`49`	`49`	`let mut p = Self::new();`
`50`	`50`	`p.push(s);`
`51`	`51`	`p`
Original file line number	Diff line number	Diff line change
`@@ -234,7 +234,10 @@ impl DirEntry {`
`234`	`234`	`)`
`235`	`235`	`.into());`
`236`	`236`	`}`
`237`		`- values.insert(Property::Target, jbk::Value::Array(target.into()));`
	`237`	`+ values.insert(`
	`238`	`+ Property::Target,`
	`239`	`+ jbk::Value::Array(Vec::from(target).into()),`
	`240`	`+ );`
`238`	`241`	`let entry = Box::new(jbk::creator::BasicEntry::new_from_schema(`
`239`	`242`	`&entry_store.schema,`
`240`	`243`	`Some(EntryType::Link),`
Original file line number	Diff line number	Diff line change
`@@ -28,13 +28,13 @@ impl Entry {`
`28`	`28`	`fn __repr__(&self) -> String {`
`29`	`29`	`match &self.entry {`
`30`	`30`	`arx::Entry::File(e) => {`
`31`		`- format!("File({})", String::from_utf8(e.path().clone()).unwrap())`
	`31`	`+ format!("File({})", String::from_utf8(e.path().to_vec()).unwrap())`
`32`	`32`	`}`
`33`	`33`	`arx::Entry::Link(e) => {`
`34`		`- format!("Link({})", String::from_utf8(e.path().clone()).unwrap())`
	`34`	`+ format!("Link({})", String::from_utf8(e.path().to_vec()).unwrap())`
`35`	`35`	`}`
`36`	`36`	`arx::Entry::Dir(_, e) => {`
`37`		`- format!("Dir({})", String::from_utf8(e.path().clone()).unwrap())`
	`37`	`+ format!("Dir({})", String::from_utf8(e.path().to_vec()).unwrap())`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`	`}`
`@@ -53,9 +53,9 @@ impl Entry {`
`53`	`53`	`#[getter]`
`54`	`54`	`fn path(&self) -> PyResult<String> {`
`55`	`55`	`Ok(match &self.entry {`
`56`		`- arx::Entry::File(e) => String::from_utf8(e.path().clone()).unwrap(),`
`57`		`- arx::Entry::Link(e) => String::from_utf8(e.path().clone()).unwrap(),`
`58`		`- arx::Entry::Dir(_, e) => String::from_utf8(e.path().clone()).unwrap(),`
	`56`	`+ arx::Entry::File(e) => String::from_utf8(e.path().to_vec()).unwrap(),`
	`57`	`+ arx::Entry::Link(e) => String::from_utf8(e.path().to_vec()).unwrap(),`
	`58`	`+ arx::Entry::Dir(_, e) => String::from_utf8(e.path().to_vec()).unwrap(),`
`59`	`59`	`})`
`60`	`60`	`}`
`61`	`61`