added non safe ring buffer

Author: mighe

lib/concurrent.rb

@@ -36,6 +36,7 @@
 require 'concurrent/channel/channel'
 require 'concurrent/channel/unbuffered_channel'
 require 'concurrent/channel/buffered_channel'
+require 'concurrent/channel/ring_buffer'
 require 'concurrent/channel/blocking_ring_buffer'
 
 require 'concurrent/cached_thread_pool'

lib/concurrent/channel/ring_buffer.rb

@@ -0,0 +1,54 @@
+module Concurrent
+
+  # not thread safe buffer
+  class RingBuffer
+
+    def initialize(capacity)
+      @buffer = Array.new(capacity)
+      @first = @last = 0
+      @count = 0
+    end
+
+    def capacity
+      @buffer.size
+    end
+
+    def count
+      @count
+    end
+
+    def empty?
+      @count == 0
+    end
+
+    def full?
+      @count == capacity
+    end
+
+    # @param [Object] value
+    # @return [Boolean] true if value has been inserted, false otherwise
+    def offer(value)
+      return false if full?
+
+      @buffer[@last] = value
+      @last = (@last + 1) % @buffer.size
+      @count += 1
+      true
+    end
+
+    # @return [Object] the first available value and removes it from the buffer. If buffer is empty returns nil
+    def poll
+      result = @buffer[@first]
+      @buffer[@first] = nil
+      @first = (@first + 1) % @buffer.size
+      @count -= 1
+      result
+    end
+
+    # @return [Object] the first available value and without removing it from the buffer. If buffer is empty returns nil
+    def peek
+      @buffer[@first]
+    end
+
+  end
+end

spec/concurrent/channel/ring_buffer_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+module Concurrent
+
+  describe RingBuffer do
+
+    let(:capacity) { 3 }
+    let(:buffer) { RingBuffer.new(capacity) }
+
+    def fill_buffer
+      capacity.times { buffer.offer 3 }
+    end
+
+    describe '#capacity' do
+      it 'returns the value passed in constructor' do
+        buffer.capacity.should eq capacity
+      end
+    end
+
+    describe '#count' do
+      it 'is zero when created' do
+        buffer.count.should eq 0
+      end
+
+      it 'increases when an element is added' do
+        buffer.offer 5
+        buffer.count.should eq 1
+
+        buffer.offer 1
+        buffer.count.should eq 2
+      end
+
+      it 'decreases when an element is removed' do
+        buffer.offer 10
+        buffer.poll
+
+        buffer.count.should eq 0
+      end
+    end
+
+    describe '#empty?' do
+      it 'is true when count is zero' do
+        buffer.empty?.should be_true
+      end
+
+      it 'is false when count is not zero' do
+        buffer.offer 82
+        buffer.empty?.should be_false
+      end
+    end
+
+    describe '#full?' do
+      it 'is true when count is capacity' do
+        fill_buffer
+        buffer.full?.should be_true
+      end
+
+      it 'is false when count is not capacity' do
+        buffer.full?.should be_false
+      end
+    end
+
+    describe '#offer' do
+      it 'returns false when buffer is full' do
+        fill_buffer
+        buffer.offer(3).should be_false
+      end
+
+      it 'returns true when the buffer is not full' do
+        buffer.offer(5).should be_true
+      end
+
+    end
+
+    describe '#poll' do
+      it 'returns the first added value' do
+        buffer.offer 'hi'
+        buffer.offer 'foo'
+        buffer.offer 'bar'
+
+        buffer.poll.should eq 'hi'
+        buffer.poll.should eq 'foo'
+        buffer.poll.should eq 'bar'
+      end
+
+      it 'returns nil when buffer is empty' do
+        buffer.poll.should be_nil
+      end
+    end
+
+    describe '#peek' do
+      context 'buffer empty' do
+        it 'returns nil when buffer is empty' do
+          buffer.peek.should be_nil
+        end
+      end
+
+      context 'not empty' do
+
+        before(:each) { buffer.offer 'element' }
+
+        it 'returns the first value' do
+          buffer.peek.should eq 'element'
+        end
+
+        it 'does not change buffer' do
+          buffer.peek
+          buffer.count.should eq 1
+        end
+      end
+    end
+
+    context 'circular condition' do
+      it 'can filled many times' do
+        fill_buffer
+        capacity.times { buffer.poll }
+
+        buffer.offer 'hi'
+
+        buffer.poll.should eq 'hi'
+        buffer.capacity.should eq capacity
+      end
+    end
+
+  end
+end