def map_set(self, body, key, value, last_value=None, comments="") -> State:
"""Generates the `map_set` state when a particular key is set for a new
value.
Args:
body : The contents of the map that are to be sent along with the state
key : The key that has been accessed
value : The current value being associated with key
last_value (optional): the last value that the key was associated to.
comments (optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``map_set`` state for the respective map mentioned
"""
state_type = "map_set"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": body.copy(),
"key": key,
"value": value,
"last_value": last_value
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def dllnode_iter(self,
value,
next_node,
prev_node,
last_value=None,
comments=""):
"""Generates the `dllnode_iter` state when a node is accessed or its
value is changed.
Args:
value : The value stored in the linked list node
next_node (DoublyLinkedListNode): The next pointer
prev_node (DoublyLinkedListNode): The prev pointer
last_value (optional): stores the value in the linked list node before it was changed.
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `dllnode_iter` state
"""
state_type = "dllnode_iter"
state_def = {
"id": self._id,
"variable_name": self.name,
"value": value,
"next": next_node.name if next_node else "none",
"prev": prev_node.name if prev_node else "none",
}
if last_value is not None:
state_def["last_value"] = last_value
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def dllnode_next(self,
value,
next_node,
prev_node,
last_next,
comments=""):
"""Generates the `dllnode_next` state when the next pointer changes.
Args:
value : The value stored in the linked list node
next_node (DoublyLinkedListNode): The next pointer
prev_node (DoublyLinkedListNode): The prev pointer
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `dllnode_next` state
"""
state_type = "dllnode_next"
state_def = {
"id": self._id,
"variable_name": self.name,
"value": value,
"next": next_node.name if next_node else "none",
"prev": prev_node.name if prev_node else "none",
"last_next": last_next.name if last_next else "none",
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def llnode_iter(self,value,_next,last_value=None,comments=""):
"""Generates the `llnode_iter` state when a node is accessed or its
value is changed.
Args:
value : The value stored in the linkedlist node
next (LinkedListNode): The next pointer
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `llnode_iter` state
"""
state_type = "llnode_iter"
state_def = {
"id" : self._id,
"variable_name" : self.name,
"value" : value,
"next" : _next.name if _next else "none"
}
if not(last_value is None):
state_def["last_value"] = last_value
return State(
state_type=state_type,
state_def=state_def,
comments=comments
)
def vector_iter(self,
body,
index,
value=None,
last_value=None,
comments=""):
"""Generates the `vector_iter` state when a particular index of vector
has been accessed.
Args:
body (list): The contents of the vector that are to be sent along with the state
index (int): The index of vector that has been accessed
value (optional): The current value at array[index] if __setitem__(self, key, value) was called.
last_value (optional): The current value at array[index] if __setitem__(self, key, value) was called.
comments (str,optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``vector_iter`` state for the respective vector mentioned
"""
state_type = "vector_iter"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"index": index
}
if not (last_value is None):
state_def["value"] = value
state_def["last_value"] = last_value
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def stack_declare(self, comments=""):
"""Generates the `stack_declare` state when an instance of stack is
created.
Args:
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `stack_declare` state for respective stack
"""
state_type = "stack_declare"
state_def = {"id": self._id, "variable_name": self.name, "body": []}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def priorityqueue_declare(self, comments=""):
"""Generates the `priorityqueue_declare` state when an instance of
PriorityQueue is created.
Args:
body: The contents of the PriorityQueue that are to be sent along with the state
comments (optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``priorityqueue_declare`` state for the respective PriorityQueue mentioned
"""
state_type = "priorityqueue_declare"
state_def = {"id": self._id, "variable_name": self.name, "body": []}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def dllnode_delete(self, comments=""):
"""Generates the `dllnode_delete` state when a node is deleted.
Args:
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `dllnode_delete` state
"""
state_type = "dllnode_delete"
state_def = {
"id": self._id,
"variable_name": self.name,
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def stack_top(self, body, comments=""):
"""Generates the `stack_push` state when top of stack is accessed.
Args:
body (list): contents of stack
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `stack_top` state for respective stack
"""
state_type = "stack_top"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def queue_front(self, body, comments=""):
"""Generates the `queue_front` state when front of queue is accessed.
Args:
body (list): Body of queue
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `queue_front` state for respective queue
"""
state_type = "queue_front"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def priorityqueue_peek(self, body, comments=""):
"""Generates the `priorityqueue_peek` when first element of priority
queue is accessed.
Args:
body: The contents of the PriorityQueue that are to be sent along with the state
comments (optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``priorityqueue_peek`` state for the respective PriorityQueue mentioned
"""
state_type = "priorityqueue_peek"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def map_declare(self, body, comments="") -> State:
"""Generates the `map_declare` state when an instance of Map class is
created.
Args:
body: The contents of the map that are to be sent along with the state
comments (optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``map_declare`` state for the respective map mentioned
"""
state_type = "map_declare"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": body.copy()
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def vector_declare(self, body, comments=""):
"""Generates the `vector_declare` state when an instance of Vector
class is created.
Args:
body (list): The contents of the vector that are to be sent along with the state
comments (str,optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``vector_declare`` state for the respective vector mentioned
"""
state_type = "vector_declare"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body)
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def ll_declare(self,head,comments=""):
"""Generates the `ll_declare` state when a new linkedlist is created.
Args:
head (LinkedListNode): The head pointer
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `ll_declare` state
"""
state_type = "ll_declare"
state_def = {
"id" : self._id,
"variable_name" : self.name,
"head" : head.name if head else "none"
}
return State(
state_type=state_type,
state_def=state_def,
comments=comments
)
def stack_push(self, body, element, comments=""):
"""Generates the `stack_push` state when an element is added to stack.
Args:
body (list): contents of stack
element : Element pushed to stack top
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `stack_push` state for respective stack
"""
state_type = "stack_push"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"element": element
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def queue_push(self, body, element, comments=""):
"""Generates the `queue_push` state when an element is added to queue.
Args:
body (list): Body of queue
element: Element to be added to back of queue
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `queue_push` state for respective queue
"""
state_type = "queue_push"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"element": element
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def set_remove(self, body, key, comments="") -> State:
"""Generates the `set_remove` state when a particular key is deleted.
Args:
body : The contents of the set that are to be sent along with the state
key : The key that has been deleted
comments (optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``set_remove`` state for the respective set mentioned
"""
state_type = "set_remove"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": body.copy(),
"key": key,
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def string_append(self, body, element, comments=""):
"""Generates the `string_append` state when another string has been
appended to this string.
Args:
body (str): The original string appended with new string
element (str): The new string that has been appended
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `string_append` state for respective string
"""
state_type = "string_append"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": body,
"element": element,
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def vector_remove(self, body, index, comments=""):
"""Generates the `vector_remove` state when a element at particular
index of vector is removed.
Args:
body (list): The contents of the vector that are to be sent along with the state
index (int): The index of vector at which the element has to be removed
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``vector_remove`` state for the respective vector mentioned
"""
state_type = "vector_remove"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"index": index
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def string_iter(self, body, index, comments=""):
"""Generates the `string_iter` state when an character of string has
been accessed.
Args:
body (str): The string
index (int): The index which has been accessed
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `string_iter` state for respective string
"""
state_type = "string_iter"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": body,
"index": index
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def stack_pop(self, body, element, comments=""):
"""Generates the `stack_pop` state when an element is popped from
stack.
Args:
body (list): contents of stack
comments (str, optional): Comments for descriptive purpose. Defaults to "".
element : element that was popped from the stack.
Returns:
State: Returns the `stack_pop` state for respective stack
"""
state_type = "stack_pop"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"element": element,
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def queue_pop(self, body, element, comments=""):
"""Generates the `queue_pop` state when an element is removed from
queue.
Args:
body (list): Body of queue
comments (str, optional): Comments for descriptive purpose. Defaults to "".
element : element that was popped from the queue.
Returns:
State: Returns the `queue_pop` state for respective queue
"""
state_type = "queue_pop"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"element": element,
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def priorityqueue_poll(self, body, element, comments=""):
"""Generates the `priorityqueue_offer` when an element is popped from
priority queue.
Args:
body: The contents of the PriorityQueue that are to be sent along with the state
comments (optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
element : the element that was polled from the priorityqueue.
Returns:
ARgorithmToolkit.utils.State: returns the ``priorityqueue_poll`` state for the respective PriorityQueue mentioned
"""
state_type = "priorityqueue_poll"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"element": element,
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def array_swap(self, body, indexes, comments=""):
"""Generates the ``array_swap`` state when values at two indexes of
array are being swapped.
Args:
body: The contents of the array that are to be sent along with the state
indexes : The indexes that are supposed to be swapped
comments (optional):The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``array_swap`` state for the respective array mentioned
"""
state_type = "array_swap"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": body.tolist(),
"index1": indexes[0],
"index2": indexes[1]
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def dll_tail(self, head, tail, last_tail=None, comments=""):
"""Generates the `dll_tail` state when linked list tail is changed.
Args:
head (DoublyLinkedListNode): The head pointer
tail (DoublyLinkedListNode): The tail pointer
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `dll_tail` state
"""
state_type = "dll_tail"
state_def = {
"id": self._id,
"variable_name": self.name,
"head": head.name if head else "none",
"tail": tail.name if tail else "none"
}
if not (last_tail is None):
state_def['last_tail'] = last_tail
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def llnode_declare(self,value,_next,comments=""):
"""Generates the `llnode_declare` state when a new node is created.
Args:
value : The value stored in the linkedlist node
next (LinkedListNode): The next pointer
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `llnode_declare` state
"""
state_type = "llnode_declare"
state_def = {
"id" : self._id,
"variable_name" : self.name,
"value" : value,
"next" : _next.name if _next else "none"
}
return State(
state_type=state_type,
state_def=state_def,
comments=comments
)
def ll_head(self,head,last_head=None,comments=""):
"""Generates the `ll_head` state when linkedlist head is changed.
Args:
head (LinkedListNode): The head pointer
comments (str, optional): Comments for descriptive purpose. Defaults to "".
Returns:
State: Returns the `ll_head` state
"""
state_type = "ll_head"
state_def = {
"id" : self._id,
"variable_name" : self.name,
"head" : head.name if head else "none"
}
if not (last_head is None):
state_def["last_head"] = last_head
return State(
state_type=state_type,
state_def=state_def,
comments=comments
)
def vector_compare(self, body, indexes, comments=""):
"""Generates the ``vector_compare`` state when values at two indexes of
vector are being compared.
Args:
body (list): The contents of the vector that are to be sent along with the state
indexes (tuple): The indexes that are supposed to be compared
comments (str,optional):The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``vector_compare`` state for the respective vector mentioned
"""
state_type = "vector_compare"
state_def = {
"id": self._id,
"variable_name": self.name,
"body": list(body),
"index1": indexes[0],
"index2": indexes[1]
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
def set_find(self, body, key, found, comments="") -> State:
"""Generates the `set_find` state when a particular key is searched
for.
Args:
body : The contents of the set that are to be sent along with the state
key : The key that has been searched
found : true if found false if not found
comments (optional): The comments that are supposed to rendered with the state for descriptive purpose. Defaults to "".
Returns:
ARgorithmToolkit.utils.State: returns the ``set_find`` state for the respective set mentioned
"""
state_type = "set_find"
state_def = {
"id": self._id,
"variable_name": self.name,
"key": key,
"found": found,
"body": body.copy()
}
return State(state_type=state_type,
state_def=state_def,
comments=comments)
