Commit dd75cc214d087e0d3a68a76ced3a707aa456d887 | zig

author	daurnimator <quae@daurnimator.com> 2019-11-16 22:34:27+11:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-02-18 16:47:03-05:00
log	dd75cc214d087e0d3a68a76ced3a707aa456d887
tree	4721f5597a4fc5f595e0c9a51e05f1a14c091d7e
parent	38ad7daebb42d562946c092a59cfbbf94e75870a
signature	Commit is signed but in an unrecognized format.

std: let PeekStream have static/dynamic variants

This completes a TODO in the existing implementation

2 files changed, 32 insertions(+), 12 deletions(-)

lib
- std
  - io.zig
  - io
    test.zig

lib/std/io.zig+31-11

 @@ -196,7 +196,7 @@ test "io.BufferedInStream" {
 /// Creates a stream which supports 'un-reading' data, so that it can be read again.
 /// This makes look-ahead style parsing much easier.
-pub fn PeekStream(comptime buffer_type: usize, comptime InStreamError: type) type {
+pub fn PeekStream(comptime buffer_type: std.fifo.LinearFifoBufferType, comptime InStreamError: type) type {
     return struct {
         const Self = @This();
         pub const Error = InStreamError;
 @@ -205,18 +205,38 @@ pub fn PeekStream(comptime buffer_type: usize, comptime InStreamError: type) typ
         stream: Stream,
         base: *Stream,
-        // Right now the look-ahead space is statically allocated, but a version with dynamic allocation
+        const FifoType = std.fifo.LinearFifo(u8, buffer_type);
-        // is not too difficult to derive from this.
-        const FifoType = std.fifo.LinearFifo(u8, .{ .Static = buffer_size });
         fifo: FifoType,
-        pub fn init(base: *Stream) Self {
+        pub usingnamespace switch (buffer_type) {
-            return .{
+            .Static => struct {
-                .base = base,
+                pub fn init(base: *Stream) Self {
-                .fifo = FifoType.init(),
+                    return .{
-                .stream = Stream{ .readFn = readFn },
+                        .base = base,
-            };
+                        .fifo = FifoType.init(),
-        }
+                        .stream = Stream{ .readFn = readFn },
+                    };
+                }
+            },
+            .Slice => struct {
+                pub fn init(base: *Stream, buf: []u8) Self {
+                    return .{
+                        .base = base,
+                        .fifo = FifoType.init(buf),
+                        .stream = Stream{ .readFn = readFn },
+                    };
+                }
+            },
+            .Dynamic => struct {
+                pub fn init(base: *Stream, allocator: *mem.Allocator) Self {
+                    return .{
+                        .base = base,
+                        .fifo = FifoType.init(allocator),
+                        .stream = Stream{ .readFn = readFn },
+                    };
+                }
+            },
+        };
         pub fn putBackByte(self: *Self, byte: u8) !void {
             try self.putBack(@ptrCast([*]const u8, &byte)[0..1]);

lib/std/io/test.zig+1-1

...	@@ -93,7 +93,7 @@ test "SliceInStream" {	...	@@ -93,7 +93,7 @@ test "SliceInStream" {
93	test "PeekStream" {	93	test "PeekStream" {
94	const bytes = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };	94	const bytes = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
95	var ss = io.SliceInStream.init(&bytes);	95	var ss = io.SliceInStream.init(&bytes);
96	var ps = io.PeekStream(2, io.SliceInStream.Error).init(&ss.stream);	96	var ps = io.PeekStream(.{ .Static = 2 }, io.SliceInStream.Error).init(&ss.stream);
97		97
98	var dest: [4]u8 = undefined;	98	var dest: [4]u8 = undefined;
99		99