list1.print()
print("After insert_keep_old(7)")
list1.insert_keep_old("7")
list1.print()
print("After insert_keep_old(8)")
list1.insert_keep_old("8")
list1.print()
print("Capacity is ", list1.capacity())
print("Testing remove_newest()")
list1.remove_newest()
list1.print()
print("Testing remove_oldest()")
list1.remove_oldest()
list1.print()
print("Size of RingBuffer", list1.sizeOf())
print("Capacity of RingBuffer", list1.capacity())
print("Testing find. Searching for 3")
list1.Find("3")
print("Reseting the RingBuffer to capacity 0")
list1 = RingBuffer(0)
print("Trying to insert_keep_new(1)")
list1.insert_keep_new("1")
print("-----------------------")
print("Test Case of Stack")
print(
"Assumed Stack capacity is 5 for testing. All the test cases below are according to size 5"
)
sizeOfS = int(input("Enter size of Stack"))
class Stack:
'''
This is a list based implementation of a stack which will keep newest data
and drop anything oldest that there is not room for
'''
__slots__ = "RB","capacity1", "top1"
def __init__(self, capacity):
"""
initlizes the Stack class
:param own: slef object
:param capacity: Capacity of the Stack
"""
# create list of size capacity
#self.list_stack = [None] * capacity
self.RB = RingBuffer(capacity)
# store as instance variable
self.capacity1 = capacity
# set other instance variable defaults
self.top1 = None
def __str__(self):
"""
Convert Stack in a string format
:param own: slef object
:return: returns stack in the String format
"""
if self.capacity1==0 or self.capacity1<0:
print("Capacity of Stack is 0 or less than 1. Can't print Stack")
return
self.RB.print()
def push(self, val):
"""
push operation of the stack.
:param own: slef object
:return: returns the pushed element
"""
if self.capacity1==0 or self.capacity1<0:
print("Capacity of Stack is 0 or less than 1. Can't use this Stack")
return
if self.RB.sizeOf() == self.capacity1:
print("As Stack is full, Removing top ", self.top1)
self.top1=self.RB.insert_keep_new(val)
return self.top1
def pop(self):
"""
pop operation of the stack.
:param own: slef object
:return: returns the poped element
"""
if self.capacity1==0 or self.capacity1<0:
print("Capacity of Stack is 0 or less than 1. Can't use this Stack")
return
if self.size()==0 :
print("Stack is empty")
return
self.top1= self.RB.remove_newest()
def peek(self):
"""
peek operation of the stack.
:param own: self object
:return: returns the element at the top
"""
if self.capacity1==0 or self.capacity1<0:
print("Capacity of Stack is 0 or less than 1. Can't use this Stack")
return
if self.size()==0 :
print("Stack is empty")
return
return self.top1
def size(self):
"""
check size of the stack
:param own: self object
:return: returns the size of the stack
"""
return self.RB.sizeOf()
def capacity(self):
"""
check capacity of the stack
:param own: self object
:return: returns the capacity of the stack
"""
return self.capacity1
class Queue:
'''
This is a list based implementation of a Queue
'''
__slots__ = "RB", "capacity1", "front", "back"
def __init__(self, capacity):
"""
initlizes the Queue class
:param own: slef object
:param capacity: Capacity of the Queue
"""
# create list of size capacity
#self.list_stack = [None] * capacity
self.RB = RingBuffer(capacity)
# store as instance variable
self.capacity1 = capacity
# set other instance variable defaults
self.front = None
self.back = None
#self.sizeIs = 0
def __str__(self):
"""
Convert Queue in a string format
:param own: slef object
:return: returns Queue in the String format
"""
if self.capacity1 == 0 or self.capacity1 < 0:
print(
"Capacity of Queue is 0 or less than 1. Can't print this Queue"
)
return
if self.size() == 0:
print("Queue is empty")
return
self.RB.print()
def is_empty(self):
"""
check if empty
:param own: slef object
:return: returns the true if Queue is empty or false if not
"""
return self.front == None
def enqueue(self, val):
"""
Addes the element to the Queue
:param own: slef object
:param val: Element to be added
"""
if self.capacity1 == 0 or self.capacity1 < 0:
print(
"Capacity of Queue is 0 or less than 1. Can't use this Queue")
return
#self.RB.insert_keep_new(val)
if self.is_empty() == True:
self.front = self.RB.insert_keep_old(val)
self.back = self.front
return
elif self.RB.sizeOf() == self.capacity1:
print("Queue is full. Can't add any value")
return
else:
self.back = self.RB.insert_keep_old(val)
def dequeue(self):
"""
Removes the element from the Queue
:param own: slef object
"""
if self.capacity1 == 0 or self.capacity1 < 0:
print(
"Capacity of Queue is 0 or less than 1. Can't use this Queue")
return
#print("Is empty in deque", self.is_empty())
if self.is_empty() == True:
print("Queue is empty")
return
elif self.RB.sizeOf() == 1:
self.front = None
self.back = None
self.RB.clear()
return
self.front = self.RB.remove_oldest()
def peek(self):
"""
Peek operation for the Queue
:param own: slef object
:Return : the first element
"""
if self.is_empty() == True:
print("Queue is empty")
return
return self.front
def capacity(self):
"""
Checks the capacity of the Queue
:param own: slef object
:Return : the capacity of the Queue
"""
return self.capacity1
def size(self):
"""
Checks the size of the Queue
:param own: slef object
:Return : the size of the Queue
"""
return self.RB.sizeOf()
