blob: e40248ffe556fe36665f9ec70615d31029b1a131 (
plain)
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
79
80
81
82
83
84
85
86
87
|
class Pry
# A ring is a thread-safe fixed-capacity array to which you can only add
# elements. Older entries are overwritten as you add new elements, so that the
# ring can never contain more than `max_size` elemens.
#
# @example
# ring = Pry::Ring.new(3)
# ring << 1 << 2 << 3
# ring.to_a #=> [1, 2, 3]
# ring << 4
# ring.to_a #=> [2, 3, 4]
#
# ring[0] #=> 2
# ring[-1] #=> 4
# ring.clear
# ring[0] #=> nil
#
# @api public
# @since v0.12.0
class Ring
# @return [Integer] maximum buffer size
attr_reader :max_size
# @return [Integer] how many objects were added during the lifetime of the
# ring
attr_reader :count
alias size count
# @param [Integer] max_size Maximum buffer size. The buffer will start
# overwriting elements once its reaches its maximum capacity
def initialize(max_size)
@max_size = max_size
@mutex = Mutex.new
clear
end
# Push `value` to the current index.
#
# @param [Object] value
# @return [self]
def <<(value)
@mutex.synchronize do
@buffer[count % max_size] = value
@count += 1
self
end
end
# Read the value stored at `index`.
#
# @param [Integer, Range] index The element (if Integer) or elements
# (if Range) associated with `index`
# @return [Object, Array<Object>, nil] element(s) at `index`, `nil` if none
# exist
def [](index)
@mutex.synchronize do
return @buffer[(count + index) % max_size] if index.is_a?(Integer)
return @buffer[index] if count <= max_size
transpose_buffer_tail[index]
end
end
# @return [Array<Object>] the buffer as unwinded array
def to_a
return @buffer.dup if count <= max_size
transpose_buffer_tail
end
# Clear the buffer and reset count.
# @return [void]
def clear
@mutex.synchronize do
@buffer = []
@count = 0
end
end
private
def transpose_buffer_tail
tail = @buffer.slice(count % max_size, @buffer.size)
tail.concat @buffer.slice(0, count % max_size)
end
end
end
|
