87 lines
2.4 KiB
Zig
87 lines
2.4 KiB
Zig
//! Effectively a stack of u1 values implemented using ArrayList(u8).
|
|
|
|
const BitStack = @This();
|
|
|
|
const std = @import("std");
|
|
const Allocator = std.mem.Allocator;
|
|
const ArrayList = std.ArrayList;
|
|
|
|
bytes: std.ArrayList(u8),
|
|
bit_len: usize = 0,
|
|
|
|
pub fn init(allocator: Allocator) @This() {
|
|
return .{
|
|
.bytes = std.ArrayList(u8).init(allocator),
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *@This()) void {
|
|
self.bytes.deinit();
|
|
self.* = undefined;
|
|
}
|
|
|
|
pub fn ensureTotalCapacity(self: *@This(), bit_capcity: usize) Allocator.Error!void {
|
|
const byte_capacity = (bit_capcity + 7) >> 3;
|
|
try self.bytes.ensureTotalCapacity(byte_capacity);
|
|
}
|
|
|
|
pub fn push(self: *@This(), b: u1) Allocator.Error!void {
|
|
const byte_index = self.bit_len >> 3;
|
|
if (self.bytes.items.len <= byte_index) {
|
|
try self.bytes.append(0);
|
|
}
|
|
|
|
pushWithStateAssumeCapacity(self.bytes.items, &self.bit_len, b);
|
|
}
|
|
|
|
pub fn peek(self: *const @This()) u1 {
|
|
return peekWithState(self.bytes.items, self.bit_len);
|
|
}
|
|
|
|
pub fn pop(self: *@This()) u1 {
|
|
return popWithState(self.bytes.items, &self.bit_len);
|
|
}
|
|
|
|
/// Standalone function for working with a fixed-size buffer.
|
|
pub fn pushWithStateAssumeCapacity(buf: []u8, bit_len: *usize, b: u1) void {
|
|
const byte_index = bit_len.* >> 3;
|
|
const bit_index = @as(u3, @intCast(bit_len.* & 7));
|
|
|
|
buf[byte_index] &= ~(@as(u8, 1) << bit_index);
|
|
buf[byte_index] |= @as(u8, b) << bit_index;
|
|
|
|
bit_len.* += 1;
|
|
}
|
|
|
|
/// Standalone function for working with a fixed-size buffer.
|
|
pub fn peekWithState(buf: []const u8, bit_len: usize) u1 {
|
|
const byte_index = (bit_len - 1) >> 3;
|
|
const bit_index = @as(u3, @intCast((bit_len - 1) & 7));
|
|
return @as(u1, @intCast((buf[byte_index] >> bit_index) & 1));
|
|
}
|
|
|
|
/// Standalone function for working with a fixed-size buffer.
|
|
pub fn popWithState(buf: []const u8, bit_len: *usize) u1 {
|
|
const b = peekWithState(buf, bit_len.*);
|
|
bit_len.* -= 1;
|
|
return b;
|
|
}
|
|
|
|
const testing = std.testing;
|
|
test BitStack {
|
|
var stack = BitStack.init(testing.allocator);
|
|
defer stack.deinit();
|
|
|
|
try stack.push(1);
|
|
try stack.push(0);
|
|
try stack.push(0);
|
|
try stack.push(1);
|
|
|
|
try testing.expectEqual(@as(u1, 1), stack.peek());
|
|
try testing.expectEqual(@as(u1, 1), stack.pop());
|
|
try testing.expectEqual(@as(u1, 0), stack.peek());
|
|
try testing.expectEqual(@as(u1, 0), stack.pop());
|
|
try testing.expectEqual(@as(u1, 0), stack.pop());
|
|
try testing.expectEqual(@as(u1, 1), stack.pop());
|
|
}
|