Minimal circular buffer implementation. Allows overwriting data once the buffer is full. Only allows reading data once.
In this approach W and R are incremented indefinitely (until overflow), capacity is enforced by r = R % capacity and w = W % capacity.
W R
│ │
╔═══▼═══╦═══▼═══╦═══════╦═══════╦───────┬───────┐
║ ║ ║ ║ ║ │ │▐▌
║ ║ ║ ║ ║ │ │▐▌
╚═══▲═══╩═══════╩═══════╩═══╤═══╩───────┴───────┘▐▌
▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▘
└─── Capacity = 4 ──────┘
W < R // buffer has no unread values
read() -> panic("Nothing to read here")
W R
│ │
╔═══▼═══╦═══▼═══╦═══════╦═══════╦───────┬───────┐
║ ║ ║ ║ ║ │ │▐▌
║ ║ 5 ║ ║ ║ │ │▐▌
╚═══▲═══╩═══════╩═══════╩═══╤═══╩───────┴───────┘▐▌
▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▘
└───────────────────────┘
inc(W); write(5); // increment W before writing
w R W
│ │ │
╔═══▼═══╦═══▼═══╦═══════╦═══════╦───▼───┬───────┐
║ ║ ║ ║ ║ │ │▐▌
║ 8 ║ 5 ║ 2 ║ 4 ║ │ │▐▌
╚═══▲═══╩═══════╩═══════╩═══╤═══╩───────┴───────┘▐▌
▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▘
└───────────────────────┘
inc(W); write(2); inc(W); write(4); inc(W); write(8);
w = W % capacity // write with wrap-around
Depending on the sequence of operations there are two alternatives:
In this case the reader resumes, so no unread values were overwritten.
w r W R
│ │ │ │
╔═══▼═══╦═══▼═══╦═══════╦═══════╦───▼───┬───▼───┐
║ ║ ║ ║ ║ │ │▐▌
║ 8 ║ 5 ║ 2 ║ 4 ║ │ │▐▌
╚═══▲═══╩═══════╩═══════╩═══╤═══╩───────┴───────┘▐▌
▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
└───────────────────────┘
read() -> 2; inc(R);
read() -> 4; inc(R);
read() -> 8; inc(R);
r = R % capacity // read with wrap-around
w < R // buffer has no unread values
read() -> panic("Nothing to read here.")
In this case the reader is still busy and the writer overwrites unread values. The read pointer is then moved to the least recent values in the buffer.
╷
├───────╴capacity - 1╶────────┤
w R,r W
│ │ │
╔═══════╦═══════╦═▼═══▼═╦═══════╦───────┬───────┬───▼───┐
║ ║ ║ ║ ║ │ │ │▐▌
║ 8 ║ 7 ║ 10 ║ 4 ║ │ │ │▐▌
╚═══▲═══╩═══════╩═══════╩═══╤═══╩───────┴───────┴───────┘▐▌
▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
└───────────────────────┘
inc(W); write(7); inc(W); write(10);
W - R = capacity - 1
// unread values at capacity,
// next write overwrites unread values
inc(R) // move to least recent value in the buffer
w R,r W
│ │ │
╔═══════╦═══════╦═══▼═══╦═══▼═══╦───────┬───────┬───▼───┐
║ ║ ║ ║ ║ │ │ │▐▌
║ 8 ║ 7 ║ 10 ║ 4 ║ │ │ │▐▌
╚═══▲═══╩═══════╩═══════╩═══╤═══╩───────┴───────┴───────┘▐▌
▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀│▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
└───────────────────────┘
FINAL CONFIGURATION