fluxfox 0.1.0

A library crate for working with floppy disk images for the IBM PC and compatibles.
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

//! Ring buffer for LZ type compression windows

pub struct RingBuffer {
    buf: Vec<u8>,
    pos: usize,
    n: usize,
}

impl RingBuffer {
    pub fn create(n: usize) -> Self {
        Self {
            buf: vec![0; n],
            pos: 0,
            n,
        }
    }
    pub fn get_pos(&self, offset: i64) -> usize {
        (self.pos as i64 + offset).rem_euclid(self.n as i64) as usize
    }
    pub fn set_pos(&mut self, pos: usize) {
        self.pos = pos % self.n;
    }
    /// use absolute index
    pub fn get_abs(&self, abs: usize) -> u8 {
        self.buf[abs % self.n]
    }
    /// use absolute index
    #[allow(dead_code)]
    pub fn set_abs(&mut self, abs: usize, val: u8) {
        self.buf[abs % self.n] = val;
    }
    pub fn get(&self, offset: i64) -> u8 {
        self.buf[(self.pos as i64 + offset).rem_euclid(self.n as i64) as usize]
    }
    pub fn set(&mut self, offset: i64, val: u8) {
        self.buf[(self.pos as i64 + offset).rem_euclid(self.n as i64) as usize] = val;
    }
    pub fn advance(&mut self) {
        self.pos = (self.pos + 1) % self.n;
    }
    pub fn retreat(&mut self) {
        self.pos = (self.pos - 1) % self.n;
    }
    /// Distance to another position, assuming it is behind us.
    /// Correctly handles positions that are "ahead" in memory order.
    pub fn distance_behind(&self, other: usize) -> usize {
        (self.pos as i64 - other as i64).rem_euclid(self.n as i64) as usize
    }
}

#[test]
fn offset() {
    let mut ring = RingBuffer::create(4);
    ring.set_pos(5);
    assert_eq!(ring.get_pos(0), 1);
    assert_eq!(ring.get_pos(4), 1);
    assert_eq!(ring.get_pos(3), 0);
    assert_eq!(ring.get_pos(-4), 1);
}

#[test]
fn distance() {
    // four positions 0 1 2 3
    // set position     ^       (wraps once)
    let mut ring = RingBuffer::create(4);
    ring.set_pos(5);
    assert_eq!(ring.get_pos(0), 1);
    assert_eq!(ring.distance_behind(0), 1);
    assert_eq!(ring.distance_behind(1), 0);
    assert_eq!(ring.distance_behind(3), 2);
}