ring_buffer.pony

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
class RingBuffer[A]
  """
  A ring buffer.
  """
  embed _array: Array[A]
  let _mod: USize
  var _write: USize = 0

  new create(len: USize) =>
    """
    Create a ring buffer with a fixed size. The size will be rounded up to the
    next power of 2.
    """
    let n = len.max(2).next_pow2()
    _mod = n - 1
    _array = Array[A](n)

  fun head(): USize ? =>
    """
    The first read that will succeed. If nothing has been written to the ring,
    this will raise an error.
    """
    if _write > 0 then
      if _write > space() then
        _write - space()
      else
        0
      end
    else
      error
    end

  fun size(): USize =>
    """
    The number of elements that have been added to the ring.
    """
    _write

  fun space(): USize =>
    """
    The available space in the ring.
    """
    _mod + 1

  fun apply(i: USize): this->A ? =>
    """
    Get the i-th element from the ring. If the i-th element has not yet been
    added or is no longer available, this will raise an error.
    """
    if (i >= _write) or ((_write - i) > space()) then
      error
    end

    _array(i and _mod)?

  fun ref push(value: A): Bool =>
    """
    Add an element to the ring. If the ring is full, this will drop the oldest
    element in the ring. Returns true if an element was dropped.
    """
    var full = false

    if _write < space() then
      _array.push(consume value)
    else
      try _array(_write and _mod)? = consume value end
      full = true
    end

    _write = _write + 1
    full

  fun ref clear() =>
    """
    Clear the queue.
    """
    _array.clear()
    _write = 0