Initial project import

tools/v/vlib/io/buffered_writer.v

@@ -0,0 +1,105 @@
+module io
+
+pub struct BufferedWriter {
+mut:
+	n  int
+	wr Writer
+pub mut:
+	buf []u8
+}
+
+@[params]
+pub struct BufferedWriterConfig {
+pub:
+	writer Writer
+	cap    int = 128 * 1024
+}
+
+// new_buffered_writer creates a new BufferedWriter with the specified BufferedWriterConfig.
+// Returns an error when cap is 0 or negative.
+pub fn new_buffered_writer(o BufferedWriterConfig) !&BufferedWriter {
+	if o.cap < 1 {
+		return error('`o.cap` must be a positive integer')
+	}
+
+	return &BufferedWriter{
+		buf: []u8{len: o.cap}
+		wr:  o.writer
+	}
+}
+
+// reset resets the buffer to its initial state.
+pub fn (mut b BufferedWriter) reset() {
+	cap := b.buf.len
+	b.buf = []u8{len: cap}
+	b.n = 0
+}
+
+// buffered returns the number of bytes currently stored in the buffer.
+pub fn (b BufferedWriter) buffered() int {
+	return b.n
+}
+
+// flush writes the buffered data to the underlying writer and clears the buffer, ensures all data is
+// written.
+// Returns an error if the writer fails to write all buffered data.
+pub fn (mut b BufferedWriter) flush() ! {
+	if b.buffered() == 0 {
+		return
+	}
+	mut written := 0
+	for written < b.n {
+		n := b.wr.write(b.buf[written..b.n]) or {
+			b.shift_unwritten_to_front(written)
+			return err
+		}
+		if n <= 0 || n > b.n - written {
+			b.shift_unwritten_to_front(written)
+			return error('writer returned an invalid number of bytes while flushing')
+		}
+		written += n
+	}
+	b.n = 0
+}
+
+// available returns the amount of available space left in the buffer.
+pub fn (b BufferedWriter) available() int {
+	return b.buf.len - b.n
+}
+
+fn (mut b BufferedWriter) shift_unwritten_to_front(written int) {
+	if written <= 0 {
+		return
+	}
+	remaining := b.n - written
+	if remaining <= 0 {
+		b.n = 0
+		return
+	}
+	copy(mut b.buf[..remaining], b.buf[written..b.n])
+	b.n = remaining
+}
+
+// write writes `src` in the buffer, flushing it to the underlying writer as needed, and returns the
+// number of bytes written.
+pub fn (mut b BufferedWriter) write(src []u8) !int {
+	mut written := 0
+	for written < src.len {
+		remaining := src.len - written
+		if b.buffered() == 0 && remaining > b.available() {
+			n := b.wr.write(src[written..])!
+			if n <= 0 || n > remaining {
+				return error('writer returned an invalid number of bytes while writing')
+			}
+			written += n
+			continue
+		}
+		n := copy(mut b.buf[b.n..], src[written..])
+		b.n += n
+		written += n
+		if b.available() == 0 {
+			b.flush()!
+		}
+	}
+	return written
+}