queue.py

from collections import deque

import datatypes
import exceptions
import pprint
from command import Command

class RQueue(Command):
    def __init__(self, size):
        self.q = deque([])
        self.size = size

    def push(self, val):
        assert val is not None
        assert self.size >= len(self.q)
        if self.size == len(self.q):
            raise exceptions.QQError("Register queue is full.")
        self.q.append(val)

    def pop(self):
        return self.q.popleft()


class RQAlloc(Command):
    def execute(self, env):
        if env.rqueue is not None:
            raise exceptions.QQError("Register queue is already allocated")
        size = env.qframe.popleft()
        env.rqueue = RQueue(size.value)


class QueueFrameBase:
    def get_queue(self, env):
        pass

    def return_queue(self, env):
        pass

    def pop(self, env):
        return env.qframe.popleft()

    def push(self, env, val):
        env.qframe.append(val)


class RegisterQueueBase:
    def get_queue(self, env):
        pass

    def return_queue(self, env):
        pass

    def pop(self, env):
        if env.rqueue is None:
            raise exceptions.QQError("Register queue is not allocated")

        return env.rqueue.pop()

    def push(self, env, val):
        if env.rqueue is None:
            raise exceptions.QQError("Register queue is not allocated")

        env.rqueue.push(val)


class QQueueBase:
    def get_queue(self, env):
        if type(env.qframe[0]) != datatypes.Queue:
            raise exceptions.QQError("Element at front of queue is not a Queue")
        self.queue = env.qframe.popleft()

    def return_queue(self, env):
        env.qframe.append(self.queue)

    def pop(self, env):
        return self.queue.pop()

    def push(self, env, val):
        self.queue.push(val)


class RotBase:
    def execute(self, env):
        self.get_queue(env)
        self.push(env, self.pop(env))
        self.return_queue(env)


class Rot(Command, RotBase, QueueFrameBase): pass
class RRot(Command, RotBase, RegisterQueueBase): pass
class QRot(Command, RotBase, QQueueBase): pass


class PopBase:
    def execute(self, env):
        self.get_queue(env)
        env.qframe.append(self.pop(env))
        self.return_queue(env)


class Pop(Command):
    def execute(self, env):
        env.qframe.popleft()

class RPop(Command, PopBase, RegisterQueueBase): pass
class QPop(Command, PopBase, QQueueBase): pass


class PushBase:
    def execute(self, env):
        self.get_queue(env)
        self.push(env, env.qframe.popleft())
        self.return_queue(env)


class Push(Command, PushBase, QueueFrameBase): pass  # This is the same as Rot, but left it for funsies
class RPush(Command, PushBase, RegisterQueueBase): pass
class QPush(Command, PushBase, QQueueBase): pass


class DrainBase:
    def execute(self, env):
        self.get_queue(env)
        try:
            while True:
                self.pop(env)
        except IndexError:
            pass
        self.return_queue(env)


class Drain(Command, DrainBase, QueueFrameBase): pass
class RDrain(Command, DrainBase, RegisterQueueBase): pass
class QDrain(Command, DrainBase, QQueueBase): pass


class DupBase:
    def execute(self, env):
        self.get_queue(env)
        elm = self.pop(env)
        self.push(env, elm)
        self.push(env, elm.copy())
        self.return_queue(env)


class Dup(Command, DupBase, QueueFrameBase): pass
class RDup(Command, DupBase, RegisterQueueBase): pass
class QDup(Command, DupBase, QQueueBase): pass


class Pack(Command):
    def execute(self, env):
        size = env.qframe.popleft()
        new_q = datatypes.Queue([env.qframe.popleft() for _ in range(int(size.value))])
        env.qframe.append(new_q)