hex-patch 1.12.5

HexPatch is a binary patcher and editor with terminal user interface (TUI), it's capable of disassembling instructions and assembling patches. It supports a variety of architectures and file formats. Also, it can edit remote files via SSH.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#![allow(clippy::module_inception)]

use std::collections::VecDeque;

use super::change::Change;
#[derive(Debug, Clone, Default)]
pub struct History {
    limit: usize,
    changes: VecDeque<Change>,
    current: usize,
}

impl History {
    /// If limit is 0, there is no limit.
    pub fn with_limit(limit: usize) -> Self {
        Self {
            limit,
            changes: VecDeque::with_capacity(limit),
            current: 0,
        }
    }

    pub fn push(&mut self, change: Change) {
        self.changes.truncate(self.current);
        if self.changes.len() >= self.limit && self.limit > 0 {
            self.changes.remove(0);
            self.current = self.current.saturating_sub(1);
        }
        self.changes.push_back(change);
        self.current += 1;
    }

    /// Undo the last change.
    /// Returns the change that was undone, if any.
    pub fn undo(&mut self, data: &mut Vec<u8>) -> Option<&Change> {
        if self.current == 0 {
            None
        } else {
            self.current -= 1;
            self.changes[self.current].revert(data);
            Some(&self.changes[self.current])
        }
    }

    /// Redo the last change.
    /// Returns the change that was redone, if any.
    pub fn redo(&mut self, data: &mut Vec<u8>) -> Option<&Change> {
        if self.current == self.changes.len() {
            None
        } else {
            self.changes[self.current].apply(data);
            self.current += 1;
            Some(&self.changes[self.current - 1])
        }
    }

    pub fn change_limit(&mut self, limit: usize) {
        self.limit = limit;
        if self.changes.len() > limit && limit > 0 {
            self.changes.drain(0..self.changes.len() - limit);
            self.current = limit;
        }
        if let Some(additional) = limit.checked_sub(self.changes.capacity()) {
            self.changes.reserve(additional);
        } else {
            self.changes.shrink_to_fit();
        }
    }

    pub fn clear(&mut self) {
        self.changes.clear();
        self.current = 0;
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_history_with_limit() {
        let mut history = History::with_limit(2);
        assert_eq!(history.limit, 2);
        assert_eq!(history.changes.capacity(), 2);

        history.push(Change::new(0, &[0], &[1]));
        assert_eq!(history.current, 1);
        history.push(Change::new(0, &[1], &[0]));
        assert_eq!(history.current, 2);
        history.push(Change::new(0, &[0], &[1]));
        assert_eq!(history.current, 2);
        assert_eq!(history.changes.len(), 2);

        history.undo(&mut vec![0]);
        assert_eq!(history.current, 1);
        history.undo(&mut vec![0]);
        assert_eq!(history.current, 0);
        assert!(history.undo(&mut vec![0]).is_none());
        assert_eq!(history.current, 0);
    }

    #[test]
    fn test_history_change_limit() {
        let mut history = History::with_limit(2);
        history.push(Change::new(0, &[0], &[1]));
        history.push(Change::new(0, &[1], &[2]));
        history.push(Change::new(0, &[2], &[3]));
        assert_eq!(history.changes.len(), 2);
        assert_eq!(history.current, 2);

        history.change_limit(1);
        assert_eq!(history.changes.len(), 1);
        assert_eq!(history.current, 1);
        assert_eq!(history.changes[0], Change::new(0, &[2], &[3]));
    }
}