batchwriter.go RawHistoryFolder

1package term
2
3import (
4	"bufio"
5	"io"
6	"sync"
7
8	"github.com/bnema/vev/internal/ports"
9)
10
11// batchWriter is a thread-safe buffered writer. Writes accumulate in an
12// internal buffer until Flush is called; a single write larger than the
13// buffer's capacity passes straight through to the underlying sink
14// (bufio.Writer's standard behavior).
15type batchWriter struct {
16	mu   sync.Mutex
17	bw   *bufio.Writer
18	sink ports.UIObservationSink
19}
20
21type observedWriter struct {
22	out  io.Writer
23	sink ports.UIObservationSink
24}
25
26func (w observedWriter) Write(p []byte) (int, error) {
27	n, err := w.out.Write(p)
28	if n > 0 {
29		w.sink.ObserveTerminalWrite(p[:n])
30	}
31	return n, err
32}
33
34// newBatchWriter wraps out with a buffer of the given size.
35func newBatchWriter(out io.Writer, size int) *batchWriter {
36	return newBatchWriterWithObservation(out, size, nil)
37}
38
39func newBatchWriterWithObservation(out io.Writer, size int, sink ports.UIObservationSink) *batchWriter {
40	writer := out
41	if sink != nil {
42		writer = observedWriter{out: out, sink: sink}
43	}
44	return &batchWriter{bw: bufio.NewWriterSize(writer, size), sink: sink}
45}
46
47// Write buffers p, flushing to the underlying sink only as bufio.Writer
48// requires (e.g. when p would overflow the buffer).
49func (w *batchWriter) Write(p []byte) (int, error) {
50	w.mu.Lock()
51	defer w.mu.Unlock()
52	return w.bw.Write(p)
53}
54
55// WriteString is the string analogue of Write.
56func (w *batchWriter) WriteString(s string) (int, error) {
57	w.mu.Lock()
58	defer w.mu.Unlock()
59	return w.bw.WriteString(s)
60}
61
62// Flush writes any buffered data to the underlying sink.
63func (w *batchWriter) Flush() error {
64	w.mu.Lock()
65	defer w.mu.Unlock()
66	if err := w.bw.Flush(); err != nil {
67		return err
68	}
69	if w.sink != nil {
70		w.sink.ObserveTerminalFlush()
71	}
72	return nil
73}
74
75// Buffered reports the number of bytes currently buffered and not yet
76// flushed to the underlying sink.
77func (w *batchWriter) Buffered() int {
78	w.mu.Lock()
79	defer w.mu.Unlock()
80	return w.bw.Buffered()
81}