plum

module std

import std/ByteSlice

import std/Str

import std/Bool

import std/Number

# A Buffer is a growable, mutable sequence of bytes for efficiently building

# up a `Str` piece by piece — modeled on Go's `bytes.Buffer`. Backed by a

# `[]Byte` (`data`, its CAPACITY) plus a logical `len` (how many of those

# bytes are actually in use) — `data` may have spare capacity past `len`,

# doubled whenever a write would overflow it, so a sequence of `n` writes is

# amortized O(n) overall (each `grow` only recopies existing bytes when

# capacity actually runs out, not on every single write), matching the real

# `bytes.Buffer`'s asymptotic behavior — unlike the previous `Str`-backed

# version of this type, which recopied everything written so far on every

# write.

enum Buffer(ToStr) =

  | Buffer(data: []Byte, len: Int)

  # A no-param `init` nested in the type is `Buffer()`'s constructor — a

  # zero-arg `Buffer()` call desugars to `Buffer.init()` (see `plum-checker`'s

  # and `plum-wasm-codegen`'s `ClassCall` handling), so this is the only place

  # that ever needs to know `data`/`len`'s starting values.

  fun init() -> Buffer =

    Buffer(data: makeBytes(0), len: 0)

  # Appends `s` to the buffer.

  fun write(self, s: Str) -> Unit =

    n := s.length()

    self.ensureCapacity(self.len + n)

    copyStrToBytes(self.data, self.len, s, 0, n)

    self.len = self.len + n

  # Appends the single raw byte `b` to the buffer.

  fun writeByte(self, b: Byte) -> Unit =

    self.ensureCapacity(self.len + 1)

    self.data.set(self.len, b)

    self.len = self.len + 1

  # Appends the Unicode codepoint `cp`, UTF-8 encoded, to the buffer.

  fun writeRune(self, cp: Int) -> Unit =

    self.write(codePointToStr(cp))

  # Returns the buffer's contents as a `Str`.

  fun toStr(self) -> Str =

    bytesToStr(self.data, 0, self.len)

  # Number of bytes currently in the buffer.

  fun length(self) -> Int =

    self.len

  fun isEmpty(self) -> Bool =

    self.len == 0

  # Discards the buffer's contents, leaving it empty. Keeps its current

  # capacity — matching Go's `bytes.Buffer.Reset`, which reuses the backing

  # array rather than releasing it.

  fun reset(self) -> Unit =

    self.len = 0

  # Grows `data` (doubling — or to exactly `needed` if even doubling isn't

  # enough) whenever it's too small to hold `needed` bytes. A no-op

  # otherwise, so a write that fits in the existing capacity costs no

  # allocation or copy at all.

  fun ensureCapacity(self, needed: Int) -> Unit =

    cap := self.data.length()

    if needed <= cap

      return

    new_cap := cap == 0 ? 16 : cap * 2

    new_cap = needed > new_cap ? needed : new_cap

    new_data := makeBytes(new_cap)

    copyBytes(new_data, 0, self.data, 0, self.len)

    self.data = new_data

fun exerciseBufferInit() -> Str =

  b := Buffer()

  b.write("hello ")

  b.write("world")

  b.toStr()

test "Buffer() with no args runs init() and works immediately"

  assert exerciseBufferInit() == "hello world"