588. Design In-Memory File System

Design an in-memory file system to simulate the following functions:

ls: Given a path in string format. If it is a file path, return a list that only contains this file's name. If it is a directory path, return the list of file and directory names in this directory. Your output (file and directory names together) should in lexicographic order.

mkdir: Given a directory path that does not exist, you should make a new directory according to the path. If the middle directories in the path don't exist either, you should create them as well. This function has void return type.

addContentToFile: Given a file path and file content in string format. If the file doesn't exist, you need to create that file containing given content. If the file already exists, you need to append given content to original content. This function has void return type.

readContentFromFile: Given a file path, return its content in string format.

 

Example:

Input: 
["FileSystem","ls","mkdir","addContentToFile","ls","readContentFromFile"]
[[],["/"],["/a/b/c"],["/a/b/c/d","hello"],["/"],["/a/b/c/d"]]

Output:
[null,[],null,null,["a"],"hello"]

Explanation:
filesystem

 

Note:

  1. You can assume all file or directory paths are absolute paths which begin with / and do not end with / except that the path is just "/".
  2. You can assume that all operations will be passed valid parameters and users will not attempt to retrieve file content or list a directory or file that does not exist.
  3. You can assume that all directory names and file names only contain lower-case letters, and same names won't exist in the same directory.

Rust Solution

use std::collections::BTreeMap;

#[derive(Debug)]
enum Entry {
    D(Dir),
    F(File),
}

#[derive(Debug)]
struct File {
    name: String,
    content: String,
}

impl File {
    fn new(name: String, content: String) -> Self {
        File { name, content }
    }

    fn name(&self) -> String {
        self.name.to_string()
    }

    fn append(&mut self, content: String) {
        self.content += &content;
    }

    fn content(&self) -> String {
        self.content.to_string()
    }
}

#[derive(Debug)]
struct Dir {
    name: String,
    entries: BTreeMap<String, Entry>,
}

impl Dir {
    fn new(name: String) -> Self {
        let entries = BTreeMap::new();
        Dir { name, entries }
    }

    fn list(&self) -> Vec<String> {
        self.entries.keys().map(|s| s.to_string()).collect()
    }
}

#[derive(Debug)]
struct FileSystem {
    root: Entry,
}

impl FileSystem {
    fn new() -> Self {
        let root = Entry::D(Dir::new("".to_string()));
        FileSystem { root }
    }

    fn ls(&self, path: String) -> Vec<String> {
        let mut e: &Entry = &self.root;
        for name in path.split('/').filter(|s| !s.is_empty()) {
            if let Entry::D(dir) = e {
                e = &dir.entries[name];
            } else {
                panic!();
            }
        }
        match e {
            Entry::D(d) => d.list(),
            Entry::F(f) => vec![f.name()],
        }
    }

    fn mkdir(&mut self, path: String) {
        let mut e: &mut Entry = &mut self.root;
        for name in path.split('/').filter(|s| !s.is_empty()) {
            if let Entry::D(dir) = e {
                e = dir
                    .entries
                    .entry(name.to_string())
                    .or_insert_with(|| Entry::D(Dir::new(name.to_string())))
            } else {
                panic!();
            }
        }
    }

    fn add_content_to_file(&mut self, path: String, content: String) {
        let mut e: &mut Entry = &mut self.root;
        for name in path.split('/').filter(|s| !s.is_empty()) {
            if let Entry::D(dir) = e {
                e = dir
                    .entries
                    .entry(name.to_string())
                    .or_insert_with(|| Entry::F(File::new(name.to_string(), "".to_string())))
            } else {
                panic!();
            }
        }
        if let Entry::F(file) = e {
            file.append(content);
        } else {
            panic!();
        }
    }

    fn read_content_from_file(&mut self, path: String) -> String {
        let mut e: &mut Entry = &mut self.root;
        for name in path.split('/').filter(|s| !s.is_empty()) {
            if let Entry::D(dir) = e {
                e = dir.entries.get_mut(name).unwrap();
            } else {
                panic!();
            }
        }
        if let Entry::F(file) = e {
            file.content()
        } else {
            panic!()
        }
    }
}

#[test]
fn test() {
    let mut fs = FileSystem::new();
    assert_eq!(fs.ls("/".to_string()), vec_string![]);
    fs.mkdir("/a/b/c".to_string());
    fs.add_content_to_file("/a/b/c/d".to_string(), "hello".to_string());
    assert_eq!(fs.ls("/".to_string()), vec_string!["a"]);
    assert_eq!(
        fs.read_content_from_file("/a/b/c/d".to_string()),
        "hello".to_string()
    );

    let mut fs = FileSystem::new();
    fs.mkdir("/goowmfn".to_string());
    assert_eq!(fs.ls("/goowmfn".to_string()), vec_string![]);
    assert_eq!(fs.ls("/".to_string()), vec_string!["goowmfn"]);
    fs.mkdir("/z".to_string());
    assert_eq!(fs.ls("/".to_string()), vec_string!["goowmfn", "z"]);
    assert_eq!(fs.ls("/".to_string()), vec_string!["goowmfn", "z"]);
    fs.add_content_to_file("/goowmfn/c".to_string(), "shetopcy".to_string());
    assert_eq!(fs.ls("/z".to_string()), vec_string![]);
    assert_eq!(fs.ls("/goowmfn/c".to_string()), vec_string!["c"]);
}

Having problems with this solution? Click here to submit an issue on github.