A Python Implementation Of the Fixed-Size Queue

"""
A homogeneous fixed-size queue.
"""

from array import array

class FixedsizeQueue(object):
"""
    A fixed size queue is a homogeneous FIFO queue that can't grow.
    """
def __init__(self, max_size, typecode='i'):
self.size = 0
self.head = 0
self.tail = 0
self.typecode = typecode
self.max = max_size
self._data = None
return

@property
def data(self):
"""
        :return: an array of size self.max, type self.typecode
        """
if self._data is None:
self._data = array(self.typecode, [0 for i in range(self.max)])
return self._data

def enqueue(self, item):
"""
        :param:

         - `item`: the item to add to the queue

        :return: True if added, False if full
        """
if self.size == self.max:
return False

self.data[self.tail] = item

self.size += 1
self.tail += 1

if self.tail == self.max:
self.tail = 0
return True

def dequeue(self):
"""
        :return: oldest item or None
        """
if self.size == 0:
return
item = self.data[self.head]

self.size -= 1
self.head += 1

if self.head == self.max:
self.head = 0
return item

def reset(self):
"""
        :postcondition: head, tail and size reset to 0
        """
self.size = 0
self.tail = 0
self.head = 0
return

def empty(self):
"""
        :return: True if the queue is empty.
        """
return self.size == 0

def full(self):
"""
        :return: True if the queue is full.
        """
return self.size == self.max
# end class FixedsizeQueue