Struct INodeTable 

pub struct INodeTable<F> { /* private fields */ }

A generic INodeTable which allows indexing by paths and inodes

Maps F as a “File” type

Implementations

impl<F> INodeTable<F>

pub fn push_entry<E: IntoINodeEntry<F>>( &mut self, parent: INode, name: OsString, entry: E, ) -> Option<INode>

Examples found in repository

examples/memfs.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mount = &Path::new("./memfs-mount/");
    let _ = std::fs::create_dir(mount);

    let mut fs = MemFS::new();
    fs.inodes
        .push_entry(ROOT_INODE, "test".into(), Directory::default());

    fs.inodes
        .push_entry(2u64.into(), "test2".into(), Directory::default());

    fs.inodes
        .push_entry(3u64.into(), "test3".into(), Directory::default());

    fs.inodes
        .push_entry(1u64.into(), "root2".into(), Directory::default());

    fs.inodes.push_entry(
        ROOT_INODE,
        "file".into(),
        File::new(TEST_MSG.as_bytes().into()),
    );

    let mut r = Runner::new(fs, mount);
    println!("{:#?}", r);
    r.run_block()?;

    Ok(())
}

pub fn get<T: Into<INode>>(&self, ino: T) -> Option<&INodeEntry<F>>

Examples found in repository

examples/memfs.rs (line 90)

    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())
    }

    fn getattr(&mut self, inode: INode) -> Result<FileAttributes> {
        let entry = self.inodes.get(inode).ok_or(FSError::NoEntry)?;

        Ok(entry.getattrs())
    }

    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())
    }

    fn read(&mut self, ino: INode, offset: u64, size: u32) -> Result<&[u8]> {
        let file = self.inodes.get(ino).ok_or(FSError::NoEntry)?;
        let file = file.as_file().ok_or(FSError::NotFile)?;

        let offset = offset as usize;
        let size = size as usize;

        let content = file.data.get(offset..).unwrap_or(&[]);
        let content = &content[..std::cmp::min(file.size(), size)];

        Ok(content)
    }

pub fn get_mut<T: Into<INode>>(&mut self, ino: T) -> Option<&mut INodeEntry<F>>

Examples found in repository

examples/memfs.rs (line 166)

    fn write<T: BufRead>(&mut self, ino: INode, offset: u64, size: u32, mut buf: T) -> Result<u32> {
        let file = self.inodes.get_mut(ino).ok_or(FSError::NoEntry)?;
        let file = file.as_file_mut().ok_or(FSError::NotFile)?;

        let offset = offset as usize;
        let size = size as usize;

        file.data
            .resize(std::cmp::max(file.size(), offset + size), 0);

        buf.read_exact(&mut file.data[offset..offset + size])
            .unwrap();

        file.attrs.set_size((offset + size) as u64);

        Ok(size as u32)
    }

    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())
    }

pub fn lookup<T: AsRef<Path>>(&self, path: T) -> Option<(INode, &INodeEntry<F>)>

Looks up a path. Will function with or without a leading slash

let mut tbl = INodeTable::<()>::default();
let test_dir_inode = tbl.push_entry(ROOT_INODE, "example directory".into(),
Directory::default()).unwrap();

let root = tbl.lookup("/").unwrap();
let test_dir = tbl.lookup("example directory").unwrap();

assert_eq!(root.0, ROOT_INODE);
assert_eq!(test_dir.0, test_dir_inode);

pub fn lookup_mut<T: AsRef<Path>>( &mut self, path: T, ) -> Option<(INode, &mut INodeEntry<F>)>

See lookup for details

Trait Implementations

impl<F: Debug> Debug for INodeTable<F>

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

Formats the value using the given formatter.

impl<F> Default for INodeTable<F>

fn default() -> INodeTable<F>

Returns the “default value” for a type.