Struct Directory 

pub struct Directory { /* private fields */ }

Implementations

impl Directory

pub fn apply_attrs(&mut self, attrs: SetFileAttributes)

Examples found in repository

examples/memfs.rs (line 187)

    fn setattr(&mut self, ino: INode, attrs: SetFileAttributes) -> Result<FileAttributes> {
        let entry = self.inodes.get_mut(ino).ok_or(FSError::NoEntry)?;

        match entry.kind_mut() {
            INodeKind::Directory(dir) => dir.apply_attrs(attrs),
            INodeKind::File(file) => file.attrs.apply_attrs(attrs),
        };

        Ok(entry.getattrs())
    }

impl Directory

pub fn get(&self, name: &OsStr) -> Option<&INode>

Examples found in repository

examples/memfs.rs (line 95)

    fn lookup(&mut self, parent: INode, name: &OsStr) -> Result<Lookup> {
        let parent = self
            .inodes
            .get(parent)
            .ok_or(FSError::NoEntry)
            .and_then(|x| x.as_dir().ok_or(FSError::NotDirectory))?;

        let (child_ino, child) = parent
            .get(name)
            // get the inode entry and then map it into (inode, &entry)
            .and_then(|ino| self.inodes.get(*ino).map(|x| (*ino, x)))
            .ok_or(FSError::NoEntry)?;

        Ok(Lookup::builder()
            .attributes(child.getattrs())
            .inode(child_ino)
            .build())
    }

pub fn children(&self) -> DirIter<'_>

Examples found in repository

examples/memfs.rs (line 134)

    fn readdir(&mut self, dir_ino: INode, offset: u64) -> Result<Vec<DirEntry>> {
        let dir_main = self.inodes.get(dir_ino).ok_or(FSError::NoEntry)?;
        let dir = dir_main.as_dir().ok_or(FSError::NotDirectory)?;

        let dots = [
            DirEntry::builder()
                .name(".".into())
                .inode(dir_ino)
                .typ(FileType::Directory)
                .offset(1)
                .build(),
            DirEntry::builder()
                .name("..".into())
                .inode(dir_main.parent().unwrap_or(ROOT_INODE))
                .typ(FileType::Directory)
                .offset(2)
                .build(),
        ];

        Ok(dots
            .into_iter()
            .chain(
                dir.children()
                    .enumerate()
                    .map(
                        |(off, v)| (off + 3, v), // add 3 to skip 0 and the two dots
                    )
                    .map(|(offset, (name, inode))| {
                        DirEntry::builder()
                            .name(name.clone())
                            .offset(offset as u64)
                            .inode(inode)
                            .typ(self.inodes.get(inode).unwrap().file_type())
                            .build()
                    }),
            )
            .skip(offset as usize)
            .collect())
    }

Trait Implementations

impl Attributable for Directory

fn getattrs(&self) -> FileAttributes

impl Debug for Directory

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

Formats the value using the given formatter.

impl Default for Directory

fn default() -> Directory

Returns the “default value” for a type.

impl<F> IntoINodeEntry<F> for Directory

fn with_parent(self, parent: INode) -> INodeEntry<F>