chore: add some #[inline]

KSXGitHub · KSXGitHub · commit 40f9d79cf9f5 · 2025-07-26T16:49:39.000+07:00
Resolves #300
diff --git a/src/app.rs b/src/app.rs
@@ -155,6 +155,7 @@ impl App {
         impl GetSizeUtils for GetApparentSize {
             const INSTANCE: Self = GetApparentSize;
             const QUANTITY: Quantity = Quantity::ApparentSize;
+            #[inline]
             fn formatter(bytes_format: BytesFormat) -> BytesFormat {
                 bytes_format
             }
@@ -164,6 +165,7 @@ impl App {
         impl GetSizeUtils for GetBlockSize {
             const INSTANCE: Self = GetBlockSize;
             const QUANTITY: Quantity = Quantity::BlockSize;
+            #[inline]
             fn formatter(bytes_format: BytesFormat) -> BytesFormat {
                 bytes_format
             }
@@ -173,6 +175,7 @@ impl App {
         impl GetSizeUtils for GetBlockCount {
             const INSTANCE: Self = GetBlockCount;
             const QUANTITY: Quantity = Quantity::BlockCount;
+            #[inline]
             fn formatter(_: BytesFormat) {}
         }
 
@@ -186,6 +189,7 @@ impl App {
             Self: GetSizeUtils,
         {
             type Reporter = ErrorOnlyReporter<fn(ErrorReport)>;
+            #[inline]
             fn create_reporter(report_error: fn(ErrorReport)) -> Self::Reporter {
                 ErrorOnlyReporter::new(report_error)
             }
@@ -199,6 +203,7 @@ impl App {
             u64: Into<Self::Size>,
         {
             type Reporter = ProgressAndErrorReporter<Self::Size, fn(ErrorReport)>;
+            #[inline]
             fn create_reporter(report_error: fn(ErrorReport)) -> Self::Reporter {
                 ProgressAndErrorReporter::new(
                     ProgressReport::TEXT,
@@ -223,6 +228,7 @@ impl App {
             Self::Size: Send + Sync,
         {
             type HardlinksHandler = hardlink::HardlinkIgnorant;
+            #[inline]
             fn create_hardlinks_handler() -> Self::HardlinksHandler {
                 hardlink::HardlinkIgnorant
             }
@@ -237,6 +243,7 @@ impl App {
             Self::Reporter: crate::reporter::Reporter<Self::Size>,
         {
             type HardlinksHandler = hardlink::HardlinkAware<Self::Size>;
+            #[inline]
             fn create_hardlinks_handler() -> Self::HardlinksHandler {
                 hardlink::HardlinkAware::new()
             }
diff --git a/src/app/hdd.rs b/src/app/hdd.rs
@@ -19,14 +19,17 @@ pub struct RealApi;
 impl Api for RealApi {
     type Disk = Disk;
 
+    #[inline]
     fn get_disk_kind(disk: &Self::Disk) -> DiskKind {
         disk.kind()
     }
 
+    #[inline]
     fn get_mount_point(disk: &Self::Disk) -> &Path {
         disk.mount_point()
     }
 
+    #[inline]
     fn canonicalize(path: &Path) -> io::Result<PathBuf> {
         canonicalize(path)
     }
diff --git a/src/app/overlapping_arguments.rs b/src/app/overlapping_arguments.rs
@@ -24,15 +24,18 @@ impl Api for RealApi {
     type RealPath = PathBuf;
     type RealPathError = io::Error;
 
+    #[inline]
     fn canonicalize(path: &Self::Argument) -> Result<Self::RealPath, Self::RealPathError> {
         canonicalize(path)
     }
 
+    #[inline]
     fn is_real_dir(path: &Self::Argument) -> bool {
         path.pipe(symlink_metadata)
             .is_ok_and(|metadata| !metadata.is_symlink() && metadata.is_dir())
     }
 
+    #[inline]
     fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool {
         a.starts_with(b)
     }
diff --git a/src/app/sub.rs b/src/app/sub.rs
@@ -246,14 +246,17 @@ where
     DataTree<OsStringDisplay, Size>: Send,
     Size: size::Size + Sync,
 {
+    #[inline]
     fn convert_error(error: Self::Error) -> RuntimeError {
         match error {}
     }
 
+    #[inline]
     fn print_report((): Self::Report, _: Size::DisplayFormat) -> Result<(), RuntimeError> {
         Ok(())
     }
 
+    #[inline]
     fn json_report((): Self::Report) -> Result<Option<JsonShared<Size>>, RuntimeError> {
         Ok(None)
     }
diff --git a/src/bytes_format/formatter.rs b/src/bytes_format/formatter.rs
@@ -9,16 +9,19 @@ pub struct Formatter {
 
 impl Formatter {
     /// Create a new formatter.
+    #[inline]
     pub const fn new(scale_base: u64) -> Self {
         Formatter { scale_base }
     }
 
     /// Multiplication factor.
+    #[inline]
     pub const fn scale_base(self) -> u64 {
         self.scale_base
     }
 
     /// Get scale in number.
+    #[inline]
     pub const fn scale(self, exp: u32) -> u64 {
         self.scale_base().pow(exp)
     }
diff --git a/src/data_tree/constructors.rs b/src/data_tree/constructors.rs
@@ -3,6 +3,7 @@ use crate::size;
 
 impl<Name, Size: size::Size> DataTree<Name, Size> {
     /// Create a tree representation of a directory.
+    #[inline]
     pub fn dir(name: Name, inode_size: Size, children: Vec<Self>) -> Self {
         let size = inode_size + children.iter().map(DataTree::size).sum();
         DataTree {
@@ -13,6 +14,7 @@ impl<Name, Size: size::Size> DataTree<Name, Size> {
     }
 
     /// Create a tree representation of a file.
+    #[inline]
     pub fn file(name: Name, size: Size) -> Self {
         DataTree {
             name,
@@ -22,6 +24,7 @@ impl<Name, Size: size::Size> DataTree<Name, Size> {
     }
 
     /// Create a directory constructor of fixed inode size.
+    #[inline]
     pub fn fixed_size_dir_constructor(inode_size: Size) -> impl Fn(Name, Vec<Self>) -> Self
     where
         Size: Copy,
diff --git a/src/data_tree/getters.rs b/src/data_tree/getters.rs
@@ -3,21 +3,25 @@ use crate::size;
 
 impl<Name, Size: size::Size> DataTree<Name, Size> {
     /// Extract name
+    #[inline]
     pub fn name(&self) -> &Name {
         &self.name
     }
 
     /// Get mutable reference to name.
+    #[inline]
     pub fn name_mut(&mut self) -> &mut Name {
         &mut self.name
     }
 
     /// Extract total disk usage
+    #[inline]
     pub fn size(&self) -> Size {
         self.size
     }
 
     /// Extract children
+    #[inline]
     pub fn children(&self) -> &Vec<Self> {
         &self.children
     }
diff --git a/src/data_tree/reflection/convert.rs b/src/data_tree/reflection/convert.rs
@@ -19,6 +19,7 @@ impl<Name, Size: size::Size> From<DataTree<Name, Size>> for Reflection<Name, Siz
 
 impl<Name, Size: size::Size> DataTree<Name, Size> {
     /// Create reflection.
+    #[inline]
     pub fn into_reflection(self) -> Reflection<Name, Size> {
         self.into()
     }
diff --git a/src/data_tree/sort.rs b/src/data_tree/sort.rs
@@ -17,6 +17,7 @@ where
     }
 
     /// Process the tree via [`par_sort_by`](Self::par_sort_by) method.
+    #[inline]
     pub fn into_par_sorted(
         mut self,
         compare: impl Fn(&Self, &Self) -> Ordering + Copy + Sync,
diff --git a/src/get_size.rs b/src/get_size.rs
@@ -17,6 +17,7 @@ pub trait GetSize {
 pub struct GetApparentSize;
 impl GetSize for GetApparentSize {
     type Size = Bytes;
+    #[inline]
     fn get_size(&self, metadata: &Metadata) -> Self::Size {
         metadata.len().into()
     }
@@ -29,6 +30,7 @@ pub struct GetBlockSize;
 #[cfg(unix)]
 impl GetSize for GetBlockSize {
     type Size = Bytes;
+    #[inline]
     fn get_size(&self, metadata: &Metadata) -> Self::Size {
         (metadata.blocks() * 512).into()
     }
@@ -41,6 +43,7 @@ pub struct GetBlockCount;
 #[cfg(unix)]
 impl GetSize for GetBlockCount {
     type Size = Blocks;
+    #[inline]
     fn get_size(&self, metadata: &Metadata) -> Self::Size {
         metadata.blocks().into()
     }
diff --git a/src/hardlink/hardlink_list/iter.rs b/src/hardlink/hardlink_list/iter.rs
@@ -31,21 +31,25 @@ impl<'a, Size> Iterator for Iter<'a, Size> {
 
 impl<'a, Size> Item<'a, Size> {
     /// The inode number of the file.
+    #[inline]
     pub fn ino(&self) -> InodeNumber {
         *self.0.key()
     }
 
     /// Size of the file.
+    #[inline]
     pub fn size(&self) -> &Size {
         &self.0.value().size
     }
 
     /// Total number of links of the file, both listed (in [`Self::paths`]) and unlisted.
+    #[inline]
     pub fn links(&self) -> u64 {
         self.0.value().links
     }
 
     /// Paths to the detected links of the file.
+    #[inline]
     pub fn paths(&self) -> &LinkPathList {
         &self.0.value().paths
     }
diff --git a/src/hardlink/hardlink_list/summary.rs b/src/hardlink/hardlink_list/summary.rs
@@ -182,6 +182,7 @@ impl<Size: size::Size> Display for SummaryDisplay<'_, Size> {
 
 impl<Size: size::Size> Summary<Size> {
     /// Turns this [`Summary`] into something [displayable](Display).
+    #[inline]
     pub fn display(&self, format: Size::DisplayFormat) -> SummaryDisplay<Size> {
         SummaryDisplay {
             format,
diff --git a/src/hardlink/ignorant.rs b/src/hardlink/ignorant.rs
@@ -16,6 +16,7 @@ impl<Size, Reporter> RecordHardlinks<Size, Reporter> for Ignorant {
     type Error = Infallible;
 
     /// Do nothing.
+    #[inline]
     fn record_hardlinks(
         &self,
         _: RecordHardlinksArgument<Size, Reporter>,
@@ -35,6 +36,7 @@ where
     type Error = Infallible;
 
     /// Do nothing.
+    #[inline]
     fn deduplicate(
         self,
         _: &mut DataTree<OsStringDisplay, Size>,
diff --git a/src/hardlink/link_path_list.rs b/src/hardlink/link_path_list.rs
@@ -20,6 +20,7 @@ pub struct LinkPathList(Vec<PathBuf>);
 impl LinkPathList {
     /// Create a list of a single path.
     #[cfg(any(unix, test))]
+    #[inline]
     pub(crate) fn single(path: PathBuf) -> Self {
         LinkPathList(vec![path])
     }
@@ -34,21 +35,25 @@ impl LinkPathList {
 
     /// Add a path to the list.
     #[cfg(any(unix, test))]
+    #[inline]
     pub(crate) fn add(&mut self, path: PathBuf) {
         self.0.push(path)
     }
 
     /// Get the number of paths inside the list.
+    #[inline]
     pub fn len(&self) -> usize {
         self.0.len()
     }
 
     /// Check whether the list is empty.
+    #[inline]
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
 
     /// Create reflection.
+    #[inline]
     pub fn into_reflection(self) -> Reflection {
         self.into()
     }
diff --git a/src/json_data/binary_version.rs b/src/json_data/binary_version.rs
@@ -13,6 +13,7 @@ pub struct BinaryVersion(String);
 
 impl BinaryVersion {
     /// Get version of the current `pdu` program as a `BinaryVersion`.
+    #[inline]
     pub fn current() -> Self {
         CURRENT_VERSION.to_string().into()
     }
diff --git a/src/size.rs b/src/size.rs
@@ -103,6 +103,7 @@ macro_rules! newtype {
             type Inner = $inner;
             type DisplayFormat = $display_format;
             type DisplayOutput = $display_output;
+            #[inline]
             fn display(self, format: Self::DisplayFormat) -> Self::DisplayOutput {
                 let display: fn(Self, Self::DisplayFormat) -> Self::DisplayOutput = $display_impl;
                 display(self, format)
diff --git a/src/status_board.rs b/src/status_board.rs
@@ -13,18 +13,21 @@ pub struct StatusBoard {
 
 impl StatusBoard {
     /// Create a new [`StatusBoard`].
+    #[inline]
     const fn new() -> Self {
         StatusBoard {
             line_width: AtomicUsize::new(0),
         }
     }
 
     /// Get the number of characters of the current line.
+    #[inline]
     fn get_line_width(&self) -> usize {
         self.line_width.load(Ordering::Relaxed)
     }
 
     /// Set the number of characters of the current line.
+    #[inline]
     fn set_line_width(&self, value: usize) {
         self.line_width.store(value, Ordering::Relaxed);
     }
diff --git a/src/visualizer/direction.rs b/src/visualizer/direction.rs
@@ -9,6 +9,7 @@ pub enum Direction {
 
 impl Direction {
     #[cfg(feature = "cli")]
+    #[inline]
     pub(crate) const fn from_top_down(top_down: bool) -> Self {
         if top_down {
             Direction::TopDown
diff --git a/src/visualizer/parenthood.rs b/src/visualizer/parenthood.rs
@@ -9,6 +9,7 @@ pub enum Parenthood {
 
 impl Parenthood {
     /// Deduce parenthood from the number of children.
+    #[inline]
     pub const fn from_children_count(children_count: usize) -> Self {
         if children_count == 0 {
             Parenthood::Childless
diff --git a/src/visualizer/proportion_bar.rs b/src/visualizer/proportion_bar.rs
@@ -30,27 +30,33 @@ pub struct ProportionBar {
 }
 
 impl ProportionBar {
+    #[inline]
     fn display_level0(self) -> impl Display {
         repeat(LEVEL0_BLOCK, self.level0)
     }
 
+    #[inline]
     fn display_level1(self) -> impl Display {
         repeat(LEVEL1_BLOCK, self.level1)
     }
 
+    #[inline]
     fn display_level2(self) -> impl Display {
         repeat(LEVEL2_BLOCK, self.level2)
     }
 
+    #[inline]
     fn display_level3(self) -> impl Display {
         repeat(LEVEL3_BLOCK, self.level3)
     }
 
+    #[inline]
     fn display_level4(self) -> impl Display {
         repeat(LEVEL4_BLOCK, self.level4)
     }
 
     /// Create a [displayable](Display) value.
+    #[inline]
     pub fn display(self, align: BarAlignment) -> ProportionBarDisplay {
         ProportionBarDisplay { bar: self, align }
     }
diff --git a/src/visualizer/tree.rs b/src/visualizer/tree.rs

Original file line number	Diff line number	Diff line change
`@@ -155,6 +155,7 @@ impl App {`
`155`	`155`	`impl GetSizeUtils for GetApparentSize {`
`156`	`156`	`const INSTANCE: Self = GetApparentSize;`
`157`	`157`	`const QUANTITY: Quantity = Quantity::ApparentSize;`
	`158`	`+ #[inline]`
`158`	`159`	`fn formatter(bytes_format: BytesFormat) -> BytesFormat {`
`159`	`160`	`bytes_format`
`160`	`161`	`}`
`@@ -164,6 +165,7 @@ impl App {`
`164`	`165`	`impl GetSizeUtils for GetBlockSize {`
`165`	`166`	`const INSTANCE: Self = GetBlockSize;`
`166`	`167`	`const QUANTITY: Quantity = Quantity::BlockSize;`
	`168`	`+ #[inline]`
`167`	`169`	`fn formatter(bytes_format: BytesFormat) -> BytesFormat {`
`168`	`170`	`bytes_format`
`169`	`171`	`}`
`@@ -173,6 +175,7 @@ impl App {`
`173`	`175`	`impl GetSizeUtils for GetBlockCount {`
`174`	`176`	`const INSTANCE: Self = GetBlockCount;`
`175`	`177`	`const QUANTITY: Quantity = Quantity::BlockCount;`
	`178`	`+ #[inline]`
`176`	`179`	`fn formatter(_: BytesFormat) {}`
`177`	`180`	`}`
`178`	`181`
`@@ -186,6 +189,7 @@ impl App {`
`186`	`189`	`Self: GetSizeUtils,`
`187`	`190`	`{`
`188`	`191`	`type Reporter = ErrorOnlyReporter<fn(ErrorReport)>;`
	`192`	`+ #[inline]`
`189`	`193`	`fn create_reporter(report_error: fn(ErrorReport)) -> Self::Reporter {`
`190`	`194`	`ErrorOnlyReporter::new(report_error)`
`191`	`195`	`}`
`@@ -199,6 +203,7 @@ impl App {`
`199`	`203`	`u64: Into<Self::Size>,`
`200`	`204`	`{`
`201`	`205`	`type Reporter = ProgressAndErrorReporter<Self::Size, fn(ErrorReport)>;`
	`206`	`+ #[inline]`
`202`	`207`	`fn create_reporter(report_error: fn(ErrorReport)) -> Self::Reporter {`
`203`	`208`	`ProgressAndErrorReporter::new(`
`204`	`209`	`ProgressReport::TEXT,`
`@@ -223,6 +228,7 @@ impl App {`
`223`	`228`	`Self::Size: Send + Sync,`
`224`	`229`	`{`
`225`	`230`	`type HardlinksHandler = hardlink::HardlinkIgnorant;`
	`231`	`+ #[inline]`
`226`	`232`	`fn create_hardlinks_handler() -> Self::HardlinksHandler {`
`227`	`233`	`hardlink::HardlinkIgnorant`
`228`	`234`	`}`
`@@ -237,6 +243,7 @@ impl App {`
`237`	`243`	`Self::Reporter: crate::reporter::Reporter<Self::Size>,`
`238`	`244`	`{`
`239`	`245`	`type HardlinksHandler = hardlink::HardlinkAware<Self::Size>;`
	`246`	`+ #[inline]`
`240`	`247`	`fn create_hardlinks_handler() -> Self::HardlinksHandler {`
`241`	`248`	`hardlink::HardlinkAware::new()`
`242`	`249`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,14 +19,17 @@ pub struct RealApi;`
`19`	`19`	`impl Api for RealApi {`
`20`	`20`	`type Disk = Disk;`
`21`	`21`
	`22`	`+ #[inline]`
`22`	`23`	`fn get_disk_kind(disk: &Self::Disk) -> DiskKind {`
`23`	`24`	`disk.kind()`
`24`	`25`	`}`
`25`	`26`
	`27`	`+ #[inline]`
`26`	`28`	`fn get_mount_point(disk: &Self::Disk) -> &Path {`
`27`	`29`	`disk.mount_point()`
`28`	`30`	`}`
`29`	`31`
	`32`	`+ #[inline]`
`30`	`33`	`fn canonicalize(path: &Path) -> io::Result<PathBuf> {`
`31`	`34`	`canonicalize(path)`
`32`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,15 +24,18 @@ impl Api for RealApi {`
`24`	`24`	`type RealPath = PathBuf;`
`25`	`25`	`type RealPathError = io::Error;`
`26`	`26`
	`27`	`+ #[inline]`
`27`	`28`	`fn canonicalize(path: &Self::Argument) -> Result<Self::RealPath, Self::RealPathError> {`
`28`	`29`	`canonicalize(path)`
`29`	`30`	`}`
`30`	`31`
	`32`	`+ #[inline]`
`31`	`33`	`fn is_real_dir(path: &Self::Argument) -> bool {`
`32`	`34`	`path.pipe(symlink_metadata)`
`33`	`35`	`.is_ok_and(\|metadata\| !metadata.is_symlink() && metadata.is_dir())`
`34`	`36`	`}`
`35`	`37`
	`38`	`+ #[inline]`
`36`	`39`	`fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool {`
`37`	`40`	`a.starts_with(b)`
`38`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -246,14 +246,17 @@ where`
`246`	`246`	`DataTree<OsStringDisplay, Size>: Send,`
`247`	`247`	`Size: size::Size + Sync,`
`248`	`248`	`{`
	`249`	`+ #[inline]`
`249`	`250`	`fn convert_error(error: Self::Error) -> RuntimeError {`
`250`	`251`	`match error {}`
`251`	`252`	`}`
`252`	`253`
	`254`	`+ #[inline]`
`253`	`255`	`fn print_report((): Self::Report, _: Size::DisplayFormat) -> Result<(), RuntimeError> {`
`254`	`256`	`Ok(())`
`255`	`257`	`}`
`256`	`258`
	`259`	`+ #[inline]`
`257`	`260`	`fn json_report((): Self::Report) -> Result<Option<JsonShared<Size>>, RuntimeError> {`
`258`	`261`	`Ok(None)`
`259`	`262`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,16 +9,19 @@ pub struct Formatter {`
`9`	`9`
`10`	`10`	`impl Formatter {`
`11`	`11`	`/// Create a new formatter.`
	`12`	`+ #[inline]`
`12`	`13`	`pub const fn new(scale_base: u64) -> Self {`
`13`	`14`	`Formatter { scale_base }`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`/// Multiplication factor.`
	`18`	`+ #[inline]`
`17`	`19`	`pub const fn scale_base(self) -> u64 {`
`18`	`20`	`self.scale_base`
`19`	`21`	`}`
`20`	`22`
`21`	`23`	`/// Get scale in number.`
	`24`	`+ #[inline]`
`22`	`25`	`pub const fn scale(self, exp: u32) -> u64 {`
`23`	`26`	`self.scale_base().pow(exp)`
`24`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,21 +3,25 @@ use crate::size;`
`3`	`3`
`4`	`4`	`impl<Name, Size: size::Size> DataTree<Name, Size> {`
`5`	`5`	`/// Extract name`
	`6`	`+ #[inline]`
`6`	`7`	`pub fn name(&self) -> &Name {`
`7`	`8`	`&self.name`
`8`	`9`	`}`
`9`	`10`
`10`	`11`	`/// Get mutable reference to name.`
	`12`	`+ #[inline]`
`11`	`13`	`pub fn name_mut(&mut self) -> &mut Name {`
`12`	`14`	`&mut self.name`
`13`	`15`	`}`
`14`	`16`
`15`	`17`	`/// Extract total disk usage`
	`18`	`+ #[inline]`
`16`	`19`	`pub fn size(&self) -> Size {`
`17`	`20`	`self.size`
`18`	`21`	`}`
`19`	`22`
`20`	`23`	`/// Extract children`
	`24`	`+ #[inline]`
`21`	`25`	`pub fn children(&self) -> &Vec<Self> {`
`22`	`26`	`&self.children`
`23`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ impl<Name, Size: size::Size> From<DataTree<Name, Size>> for Reflection<Name, Siz`
`19`	`19`
`20`	`20`	`impl<Name, Size: size::Size> DataTree<Name, Size> {`
`21`	`21`	`/// Create reflection.`
	`22`	`+ #[inline]`
`22`	`23`	`pub fn into_reflection(self) -> Reflection<Name, Size> {`
`23`	`24`	`self.into()`
`24`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ where`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	/// Process the tree via [`par_sort_by`](Self::par_sort_by) method.
	`20`	`+ #[inline]`
`20`	`21`	`pub fn into_par_sorted(`
`21`	`22`	`mut self,`
`22`	`23`	`compare: impl Fn(&Self, &Self) -> Ordering + Copy + Sync,`