Avatar of Nia11

Nia11's solution

to Circular Buffer in the Lua Track

Published at Dec 09 2018 · 0 comments
Instructions
Test suite
Solution

A circular buffer, cyclic buffer or ring buffer is a data structure that uses a single, fixed-size buffer as if it were connected end-to-end.

A circular buffer first starts empty and of some predefined length. For example, this is a 7-element buffer:

[ ][ ][ ][ ][ ][ ][ ]

Assume that a 1 is written into the middle of the buffer (exact starting location does not matter in a circular buffer):

[ ][ ][ ][1][ ][ ][ ]

Then assume that two more elements are added — 2 & 3 — which get appended after the 1:

[ ][ ][ ][1][2][3][ ]

If two elements are then removed from the buffer, the oldest values inside the buffer are removed. The two elements removed, in this case, are 1 & 2, leaving the buffer with just a 3:

[ ][ ][ ][ ][ ][3][ ]

If the buffer has 7 elements then it is completely full:

[6][7][8][9][3][4][5]

When the buffer is full an error will be raised, alerting the client that further writes are blocked until a slot becomes free.

When the buffer is full, the client can opt to overwrite the oldest data with a forced write. In this case, two more elements — A & B — are added and they overwrite the 3 & 4:

[6][7][8][9][A][B][5]

3 & 4 have been replaced by A & B making 5 now the oldest data in the buffer. Finally, if two elements are removed then what would be returned is 5 & 6 yielding the buffer:

[ ][7][8][9][A][B][ ]

Because there is space available, if the client again uses overwrite to store C & D then the space where 5 & 6 were stored previously will be used not the location of 7 & 8. 7 is still the oldest element and the buffer is once again full.

[D][7][8][9][A][B][C]

Running the tests

To run the tests, run the command busted from within the exercise directory.

Further information

For more detailed information about the Lua track, including how to get help if you're having trouble, please visit the exercism.io Lua language page.

Source

Wikipedia http://en.wikipedia.org/wiki/Circular_buffer

Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

circular-buffer_spec.lua

local CircularBuffer = require('circular-buffer')

describe('circular-buffer', function()
  it('reading an empty buffer throws a BufferEmptyException', function()
    local buffer = CircularBuffer:new(1)
    assert.has_error((function() buffer:read() end), 'buffer is empty')
  end)

  it('write and read back one item', function()
    local buffer = CircularBuffer:new(1)
    buffer:write('1')
    assert.are.equals('1', buffer:read())
    assert.has_error((function() buffer:read() end), 'buffer is empty')
  end)

  it('write and read back multiple items', function()
    local buffer = CircularBuffer:new(2)
    buffer:write('1')
    buffer:write('2')
    assert.are.equals('1', buffer:read())
    assert.are.equals('2', buffer:read())
    assert.has_error((function() buffer:read() end), 'buffer is empty')
  end)

  it('clearing a buffer', function()
    local buffer = CircularBuffer:new(2)
    buffer:write('1')
    buffer:write('2')
    buffer:clear()
    assert.has_error((function() buffer:read() end), 'buffer is empty')
    buffer:write('3')
    buffer:write('4')
    assert.are.equals('3', buffer:read())
    assert.are.equals('4', buffer:read())
  end)

  it('alternate write and read', function()
    local buffer = CircularBuffer:new(2)
    buffer:write('1')
    assert.are.equals('1', buffer:read())
    buffer:write('2')
    assert.are.equals('2', buffer:read())
  end)

  it('reads back oldest item', function()
    local buffer = CircularBuffer:new(3)
    buffer:write('1')
    buffer:write('2')
    buffer:read()
    buffer:write('3')
    assert.are.equals('2', buffer:read())
    assert.are.equals('3', buffer:read())
  end)

  it('writes of nil do not occupy buffer', function()
    local buffer = CircularBuffer:new(3)
    buffer:write(nil)
    for i = 1, 3 do
      buffer:write(tostring(i))
    end
    assert.are.equals('1', buffer:read())
  end)

  it('writing to a full buffer throws a BufferFullException', function()
    local buffer = CircularBuffer:new(2)
    buffer:write('1')
    buffer:write('2')
    assert.has_error((function() buffer:write('A') end), 'buffer is full')
  end)

  it('forced writes over write oldest item in a full buffer', function()
    local buffer = CircularBuffer:new(2)
    buffer:write('1')
    buffer:write('2')
    buffer:forceWrite('A')
    assert.are.equals('2', buffer:read())
    assert.are.equals('A', buffer:read())
    assert.has_error((function() buffer:read() end), 'buffer is empty')
  end)

  it('forced writes act like normal writes in a non-full buffer', function()
    local buffer = CircularBuffer:new(2)
    buffer:write('1')
    buffer:forceWrite('2')
    assert.are.equals('1', buffer:read())
    assert.are.equals('2', buffer:read())
    assert.has_error((function() buffer:read() end), 'buffer is empty')
  end)

  it('alternate force write and read into full buffer', function()
    local buffer = CircularBuffer:new(5)
    for i = 1, 3 do
      buffer:write(tostring(i))
    end
    buffer:read()
    buffer:read()
    buffer:write('4')
    buffer:read()
    for i = 5, 8 do
      buffer:write(tostring(i))
    end
    buffer:forceWrite('A')
    buffer:forceWrite('B')
    assert.are.equals('6', buffer:read())
    assert.are.equals('7', buffer:read())
    assert.are.equals('8', buffer:read())
    assert.are.equals('A', buffer:read())
    assert.are.equals('B', buffer:read())
    assert.has_error((function() buffer:read() end), 'buffer is empty')
  end)
end)
buffer={}
buffer.__index=buffer

function buffer:new(size)
	local o = {}
	o.size=size
	o.start=1
	o.filled=0
	o.contents={}
	for i=1,size do
		table.insert(o.contents,false)
	end
	return setmetatable(o, buffer)
end


function buffer:read()
	if self.filled<1 then error('buffer is empty') end
	local out  = self.contents[self.start]
	self.contents[self.start]=false
	self.start=self.start+1
	if self.start>self.size then self.start=1 end
	self.filled=self.filled-1
	return out
end

function buffer:write(input)
	if input~=nil then	
		if self.filled==self.size then error('buffer is full') end
		local index = self.start+self.filled
		if index>self.size then index=index-self.size end
		self.contents[index]=input
		self.filled=self.filled+1
	end
end	
	
function buffer:clear()
	self.filled=0
	for k,_ in pairs(self.contents) do
		self.contents[k]=false
	end
end

function buffer:forceWrite(input)
	if self.filled<self.size then
		self:write(input)
	else
		self.contents[self.start]=input
		self.start=self.start+1
		if self.start>self.size then self.start=1 end
	end
end


return buffer

What can you learn from this solution?

A huge amount can be learned from reading other people’s code. This is why we wanted to give exercism users the option of making their solutions public.

Here are some questions to help you reflect on this solution and learn the most from it.

  • What compromises have been made?
  • Are there new concepts here that you could read more about to improve your understanding?