opts.optopt(
        "m",
        "marks",
        "file to import and export marks",
        "MARKS-FILE",
    );

    match matches.opt_str("m") {
        Some(filename) => stream.load_marks(&filename).unwrap(),
        None => (),
    }

        let files = sandbox.get_files().unwrap();
        let parent = if i == 0 {
            None
        } else {
            Some(changes[i - 1].state)
        };
        stream.write_commit(&changes[i], parent, &files);

        if !stream.already_exported(&changes[i].state) {
            let files = sandbox.get_files().unwrap();
            let parent = if i == 0 {
                None
            } else {
                Some(changes[i - 1].state)
            };
            stream.write_commit(&changes[i], parent, &files);
        }
    }
    match matches.opt_str("m") {
        Some(filename) => stream.save_marks(&filename).unwrap(),
        None => (),

use std::error::Error;
use std::io::BufRead;
use std::io::BufReader;

use libpijul::Base32;
use regex::Regex;
use simple_error::SimpleError;

    mark_file: Vec<u8>,

            mark_file: Vec::new(),

            writeln!(
                &mut self.mark_file,
                ":{} {}",
                self.max_commit_mark,
                c.state.to_base32()
            )
            .unwrap();

    }
    fn parse_line(re: &Regex, line: &str) -> Option<(i32, libpijul::Merkle)> {
        let caps = re.captures(line)?;
        let mark: i32 = caps[1].parse().ok()?;
        let state = libpijul::Merkle::from_base32(&caps[2].as_bytes())?;
        Some((mark, state))

    pub fn load_marks(&mut self, filename: &str) -> Result<(), Box<dyn Error>> {
        self.mark_file = std::fs::read(filename)?;
        let re = Regex::new(r"^:(\d+) (\w+)$")?;
        let mark_file_content: &[u8] = &self.mark_file;
        for line in BufReader::new(mark_file_content).lines() {
            let line = line?.to_string();
            match Self::parse_line(&re, &line) {
                Some((mark, state)) => {
                    self.commit_marks.insert(state, mark);
                    if mark > self.max_commit_mark {
                        self.max_commit_mark = mark;
                    }
                }
                None => {
                    return Err(
                        SimpleError::new(format!("syntax error in mark file: {}", line)).into(),
                    )
                }
            }
        }
        return Ok(());
    }
    pub fn save_marks(&self, filename: &str) -> Result<(), Box<dyn Error>> {
        std::fs::write(&filename, &self.mark_file)?;
        Ok(())
    }
    pub fn already_exported(&self, state: &libpijul::Merkle) -> bool {
        self.commit_marks.contains_key(state)
    }

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[profile.release]
debug = true

regex = "1.7.2"
simple-error = "0.1.9"

 "regex",

 "simple-error",

version = "1.7.1"

version = "1.7.2"

checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"

checksum = "cce168fea28d3e05f158bda4576cf0c844d5045bc2cc3620fa0292ed5bb5814c"

version = "0.6.28"

version = "0.6.29"

checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"

checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"

[[package]]
name = "simple-error"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01c1c2ededd95f93b1d65e7f8b5b17670e926bf9cbb55f8b91b26b0bd40d3259"