Python Queue.clear方法代码示例

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import clear [as 别名]
 def test_queue_clear(self):
   '''
   test the clear() method
   '''
   q = Queue()
   q.enqueue(3)
   q.enqueue(4)
   q.enqueue(13)
   q.clear()
   self.assertIsNone(q.head)
   self.assertIsNone(q.tail)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import clear [as 别名]
  def insert(self, k, v):
    """Inserts a node into the binary tree. A node is inserted at the bottom
    most level using BFS to find the correct spot in order to keep the tree
    balanced.

    Time complexity: O(n)

    Keyword arguments:
    k - key of node
    v - value of node
    """

    node = BinaryNode(k, v)

    if not self.root:
      self.root = node
    else:
      # Perform BFS for the first empty spot to insert the new node
      queue = Queue()

      queue.enqueue(self.root)

      while not queue.is_empty():
        n = queue.dequeue()

        if n.left_child and n.right_child:
          # n is an internal node (keeps binary structure)
          queue.enqueue(n.left_child)
          queue.enqueue(n.right_child)
        else:
          # Add child
          if n.left_child:
            n.right_child = node
          else:
            n.left_child = node

          # Empty queue out as to not continue processing further nodes
          queue.clear()

    self.size += 1

    return node

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import clear [as 别名]
class TestStack(unittest.TestCase):

    def setUp(self):
        self.queue = Queue()

    def test_init(self):
        self.assertEqual(self.queue.get_size(), 0)
        new_queue = Queue("Bob")
        self.assertEqual(new_queue.get_size(), 1)

    def test_enqueue(self):
        self.queue.enqueue("Bob")
        self.assertEqual(self.queue.get_size(), 1)

    def test_dequeue(self):
        self.queue.enqueue("Bob")
        dequeued_item = self.queue.dequeue()
        self.assertEqual(dequeued_item, "Bob")
        another_dequeued_item = self.queue.dequeue()
        self.assertIsNone(another_dequeued_item)

    def test_peek(self):
        self.queue.enqueue("Bob")
        self.queue.enqueue("Bill")
        self.queue.enqueue("Boris")
        peeked_item = self.queue.peek()
        self.assertEqual(peeked_item, "Bob")

    def test_clear(self):
        for i in range(0, 100):
            self.queue.enqueue("Bob")
        self.assertEqual(self.queue.get_size(), 100)
        self.queue.clear()
        self.assertEqual(self.queue.get_size(), 0)

    def test_get_size(self):
        self.assertEqual(self.queue.get_size(), self.queue.linked_list.size)

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import clear [as 别名]
class Connection(object):
    """Abstracción de conexión. Maneja colas de entrada y salida de datos,
    y una funcion de estado (task). Maneja tambien el avance de la maquina de
    estados.
    """
    def __init__(self, fd, address=''):
        """Crea una conexión asociada al descriptor fd"""
        self.socket = fd
        self.task = None  # El estado de la maquina de estados
        self.input = Queue()
        self.output = Queue()
        # Esto se setea a true para pedir al proxy que desconecte
        self.remove = False
        self.address = address

    def fileno(self):
        """
        Número de descriptor del socket asociado.
        Este metodo tiene que existir y llamarse así
        para poder pasar instancias
        de esta clase a select.poll()
        """
        return self.socket.fileno()

    def direction(self):
        """
        Modo de la conexión, devuelve uno de las constantes DIR_*;
        también puede devolver None si el estado es el final
         y no hay datos para enviar.
        """
        # La cola de salida puede estar vacia por dos motivos:
        #   -1) Se enviaron todos los datos -> Remove es True
        #   -2) La cola de salida no esta lista AUN -> Sigue recibiendo
        if self.output.data == "":
            if self.remove:  # (1)
                return None  # El estado es el final
            else:  # (2)
                return DIR_READ  # Sigue recibiendo
        else:  # La cola de salida esta lista para enviarse
            return DIR_WRITE

    def recv(self):
        """
        Lee datos del socket y los pone en la cola de entrada.
        También maneja lo que pasa cuando el remoto se desconecta.
        Aqui va la unica llamada a recv() sobre sockets.
        """
        try:
            data = self.socket.recv(RECV_SIZE)  # Receive
            if data == "":  # El remoto se ha desconectado
                self.remove = True  # Hay que removerlo
            self.input.put(data)  # Encola los datos recibidos
        except socket_error:
            self.send_error(INTERNAL_ERROR, "Internal Error")
            self.remove = True

    def send(self):
        """Manda lo que se pueda de la cola de salida"""
        # Envia sended_size bytes
        sended_size = self.socket.send(self.output.data)
        # Elimina los datos enviados de la cola
        self.output.remove(sended_size)

    def close(self):
        """Cierra el socket. OJO que tambien hay que avisarle al proxy que nos
        borre.
        """
        self.socket.close()
        self.remove = True
        self.output.clear()

    def send_error(self, code, message):
        """Funcion auxiliar para mandar un mensaje de error"""
        logging.warning("Generating error response %s [%s]",
                        code, self.address)
        self.output.put("HTTP/1.1 %d %s\r\n" % (code, message))
        self.output.put("Content-Type: text/html\r\n")
        self.output.put("\r\n")
        self.output.put(
            "<body><h1>%d ERROR: %s</h1></body>\r\n" % (code, message))
        self.remove = True

# 需要导入模块: from queue import Queue [as 别名]
# 或者: from queue.Queue import clear [as 别名]
class Stream():
		# TODO use Threads for output distribution
		def __init__(self,stapModuleInstance, args = {}, interval = 0.1, withdraw=False):
			self.id				= id(self)
			self.args			= args
			self.log			= print if 'logStream' not in args else args['logStream']
			self.name			= stapModuleInstance.name
			self.queue			= Queue()			# the input queue
			self.receivers			= []
			self.interval			= interval			# check every x seconds for output in queue.
			self.withdraw			= withdraw			# if True, drop incomming input if we have no listeners
			self.thread			= Thread(target=self.run)
			self.thread.daemon		= True
			self.thread.running		= True
			self.thread.start()
			stapModuleInstance.queue	= self.queue

		def __str__(self):
			return "<Stream,name=%s,queue=%s,receivers=%s>" % (self.name, self.queue, self.receivers)
		
		def register(self,stapLabModuleInstance):
			if stapLabModuleInstance is not None:
				if stapLabModuleInstance not in self.receivers:
					self.receivers	+= [stapLabModuleInstance]
					stapLabModuleInstance.queue	= self.queue
					self.log("registered %s to %s" % (str(stapLabModuleInstance), self.name))
				else:
					self.log("%s already in receivers of Stream %s" % (stapLabModuleInstance.name, self))

		def unregister(self,module):
			if module is not None:
				try:
					self.receivers.remove(module)
					self.log("unregistered %s from %s" % (str(module), self.name))
				except ValueError:
					self.log("cannot unregister module %s to stream %s" %(module,self))

		def emtpyQueue(self):
			with self.queue.mutex:
				self.queue.clear()

		def run(self):
			self.log("%s entering mainLoop" % self)
			while self.thread.running:
				if not self.queue.empty():
					if len(self.receivers) > 0:
						data	= self.queue.get()
						for receiver in self.receivers:
							if receiver is not None:
								receiver.enqData(data)
					else:
						if self.withdraw:
							self.emptyQueue()

				for receiver in self.receivers:
					if not receiver.thread.running:
						self.unregister(receiver)

				sleep(self.interval)
			self.log("%s leaving mainLoop" % self)

		def stop(self):
			self.thread.running	= False