class Pry::Ring

@since v0.12.0
@api public<br><br>ring #=> nil<br>ring.clear<br>ring #=> 4<br>ring #=> 2
ring.to_a #=> [2, 3, 4]
ring << 4
ring.to_a #=> [1, 2, 3]
ring << 1 << 2 << 3
ring = Pry::Ring.new(3)
@example
ring can never contain more than ‘max_size` elemens.
elements. Older entries are overwritten as you add new elements, so that the
A ring is a thread-safe fixed-capacity array to which you can only add

def <<(value)

Returns:
  • (self) -

Parameters:
  • value (Object) -- 
def <<(value)
  @mutex.synchronize do
    @buffer[count % max_size] = value
    @count += 1
    self
  end
end

def [](index)

Returns:
  • (Object, Array, nil) - element(s) at `index`, `nil` if none
    Parameters:
    • index (Integer, Range) -- The element (if Integer) or elements 
    def [](index)
  @mutex.synchronize do
    return @buffer[index] if count <= max_size
    return @buffer[(count + index) % max_size] if index.is_a?(Integer)
    transpose_buffer_tail[index]
  end
end

    def clear

    Returns:
    • (void) - 
    def clear
  @mutex.synchronize do
    @buffer = []
    @count = 0
  end
end

    def initialize(max_size)

    Parameters:
    • max_size (Integer) -- Maximum buffer size. The buffer will start 
    def initialize(max_size)
  @max_size = max_size
  @mutex = Mutex.new
  clear
end

    def to_a

    Returns:
    • (Array) - the buffer as unwinded array 
      def to_a
  return @buffer.dup if count <= max_size
  transpose_buffer_tail
end

      def transpose_buffer_tail 

      def transpose_buffer_tail
  tail = @buffer.slice(count % max_size, @buffer.size)
  tail.concat @buffer.slice(0, count % max_size)
end