pub fn get_files(&mut self) -> Result<Vec<File>, Box<dyn Error>> {

    pub fn get_files(&mut self) -> Result<FileSet, Box<dyn Error>> {

            files: Arc::new(Mutex::new(Vec::new())),

            operations: Arc::new(Mutex::new(Vec::new())),

        let mut files: Vec<File> = Vec::new();
        let mut file_writers = match fs.files.lock() {
            Ok(fw) => fw,
            Err(err) => panic!("mutex error: {}", err),
        };
        for f in file_writers.drain(..) {
            files.push(File {
                name: f.name,
                content: Arc::try_unwrap(f.content).unwrap().into_inner()?,
            });
        }
        return Ok(files);

        return Ok(fs);

pub struct File {
    pub name: String,
    pub content: Vec<u8>,
}

pub enum FileOp {
    Modify { fw: FileWriter },
    Delete { path: String },
    Rename { old: String, new: String },
}

struct FileSet {
    pub files: Arc<Mutex<Vec<FileWriter>>>,

pub struct FileSet {
    pub operations: Arc<Mutex<Vec<FileOp>>>,

enum FileSetError {

pub enum FileSetError {

    MutexPoison,

            FileSetError::MutexPoison => write!(f, "poisoned mutex"),

    fn remove_path(&self, _path: &str, _rec: bool) -> Result<(), Self::Error> {

    fn remove_path(&self, path: &str, _rec: bool) -> Result<(), Self::Error> {
        self.operations.lock().unwrap().push(FileOp::Delete {
            path: path.to_owned(),
        });

        let mut with_slash = old.to_owned();
        with_slash.push_str("/");
        let mut files = self.files.lock().unwrap();
        for f in files.iter_mut() {
            if f.name == old {
                f.name = new.to_owned();
            } else if f.name.starts_with(&with_slash) {
                let (_, remainder) = f.name.split_at(old.len());
                let mut new_name = new.to_owned();
                new_name.push_str(remainder);
                f.name = new_name;
            }
        }

        self.operations.lock().unwrap().push(FileOp::Rename {
            old: old.to_owned(),
            new: new.to_owned(),
        });

        match self.files.lock() {
            Ok(mut v) => v.push(f.clone()),
            Err(_err) => return Err(FileSetError::MutexPoison),
        }

        self.operations
            .lock()
            .unwrap()
            .push(FileOp::Modify { fw: f.clone() });

use crate::repo::File;

use crate::repo::FileOp;
use crate::repo::FileSet;

    pub fn write_commit(
        &mut self,
        c: &Change,
        parent: Option<libpijul::Merkle>,
        files: &Vec<File>,
    ) {
        let mut file_marks = Vec::new();
        for f in files {
            let content: &[u8] = &f.content;
            let h = sha256::digest(content);
            let mut new_blob = false;
            let blob_mark = *self.blob_marks.entry(h).or_insert_with(|| {
                new_blob = true;
                self.max_blob_mark += 1;
                self.max_blob_mark
            });
            file_marks.push(blob_mark);
            if new_blob {
                println!("blob");
                println!("mark :{}", blob_mark);
                println!("data {}", f.content.len());
                std::io::stdout().write_all(&f.content).unwrap();
                println!("");

    pub fn write_commit(&mut self, c: &Change, parent: Option<libpijul::Merkle>, files: &FileSet) {
        let mut file_marks = HashMap::new();
        for op in &*files.operations.lock().unwrap() {
            match &op {
                FileOp::Modify { fw } => {
                    let ct = fw.content.lock().unwrap();
                    let content: &[u8] = &*ct;
                    let h = sha256::digest(content);
                    let mut new_blob = false;
                    let blob_mark = *self.blob_marks.entry(h).or_insert_with(|| {
                        new_blob = true;
                        self.max_blob_mark += 1;
                        self.max_blob_mark
                    });
                    file_marks.insert(fw.name.clone(), blob_mark);
                    if new_blob {
                        println!("blob");
                        println!("mark :{}", blob_mark);
                        println!("data {}", content.len());
                        std::io::stdout().write_all(content).unwrap();
                        println!("");
                    }
                }
                _ => (),

        println!("deleteall");
        for i in 0..files.len() {
            println!(
                "M 644 :{} \"{}\"",
                file_marks[i],
                escape_string(&files[i].name)
            );

        for op in &*files.operations.lock().unwrap() {
            match &op {
                FileOp::Modify { fw } => println!(
                    "M 644 :{} \"{}\"",
                    file_marks.get(&fw.name).unwrap(),
                    escape_string(&fw.name)
                ),
                FileOp::Delete { path } => println!("D \"{}\"", escape_string(&path)),
                FileOp::Rename { old, new } => {
                    println!("R \"{}\" \"{}\"", escape_string(&old), escape_string(&new))
                }
            };