Struct FileNode 

pub struct FileNode {
    pub name: CompactString,
    pub native_name: Option<Box<OsString>>,
    pub kind: NodeKind,
    pub size: u64,
    pub len: u64,
    pub blocks: u64,
    pub timestamps: Timestamps,
    pub inode: Option<InodeInfo>,
    pub git_status: Option<GitStatus>,
    pub children: Vec<FileNode>,
}

A single file or directory in the tree.

Debug formatting includes this node’s metadata and direct child count, not descendant contents, so logging a node does not walk the entire tree.

Fields

name: CompactString

File/directory name (not full path).

native_name: Option<Box<OsString>>

Exact platform filename when the display name cannot represent it.

kind: NodeKind

Node type and associated metadata.

size: u64

Size in bytes: disk usage, or apparent length when the scan used apparent sizes. Directories aggregate their contents and their own allocation; additional hard links to a counted file contribute zero. Derived from len and blocks; see FileNode::remeasure.

len: u64

Apparent length of this entry itself (st_size), not aggregated.

blocks: u64

512-byte blocks allocated to this entry itself (not aggregated).

timestamps: Timestamps

File metadata timestamps.

inode: Option<InodeInfo>

Identity of multiply-linked files, for hard-link aware analysis.

git_status: Option<GitStatus>

Git status for this file/directory.

children: Vec<FileNode>

Children nodes (directories only), sorted by size descending.

Implementations

impl FileNode

pub fn compare_name(&self, other: &FileNode) -> Ordering

Compare compatibility labels with exact native identity as a tiebreak.

pub fn display_name(&self) -> Cow<'_, str>

Terminal-safe filename label that preserves visible byte distinctions.

pub fn file_name(&self) -> &OsStr

Filename component for filesystem access; name is display text only.

pub fn set_file_name(&mut self, name: &OsStr)

Preserve an exact component while retaining a Unicode display label.

pub fn new_file( name: impl Into<CompactString>, size: u64, blocks: u64, timestamps: Timestamps, executable: bool, ) -> FileNode

Create a new file node.

pub fn new_directory( name: impl Into<CompactString>, timestamps: Timestamps, ) -> FileNode

Create a new, empty directory node.

pub fn new_symlink( name: impl Into<CompactString>, target: impl Into<Box<str>>, broken: bool, timestamps: Timestamps, ) -> FileNode

Create a symbolic link node.

pub fn is_dir(&self) -> bool

Check if this node is a directory.

pub fn is_file(&self) -> bool

Check if this node is a file.

pub fn child_count(&self) -> usize

Get the number of direct children.

pub fn file_count(&self) -> u64

Get file count for directories (includes files, symlinks, and other entries), 1 for files/symlinks/other.

pub fn dir_count(&self) -> u64

Get directory count for directories.

pub fn sort_children_by_size(&mut self)

Sort children by size descending, breaking ties by name and native name.

Uses stored sizes without recomputing them. Traversal retains one child iterator per directory depth instead of using recursive calls.

pub fn update_counts(&mut self)

Update directory file/dir counts with an iterative post-order traversal.

Retains one traversal frame per directory depth. Symlinks and Other entries are counted in the file count; non-directory children are leaves.

pub fn finalize(&mut self)

Update counts and sort children in the correct order.

pub fn own_size(&self, apparent: bool) -> u64

This entry’s own size under apparent: its length, or its allocated blocks. Symbolic links count as zero, as in a scan.

pub fn remeasure(&mut self, apparent: bool, count_hard_links: bool)

Recompute every size below and including this node from the entries’ own lengths and blocks, then re-sort children by size.

A multiply linked file (one with an inode) counts once, at its first occurrence in the current child order, unless count_hard_links. Iterative, so deep trees cannot exhaust the stack.

Trait Implementations

impl Clone for FileNode

fn clone(&self) -> FileNode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FileNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FileNode

fn deserialize<__D>( __deserializer: __D, ) -> Result<FileNode, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drop for FileNode

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Serialize for FileNode

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.