Queues the message on the flow's state.
351449
def QueueResponse(self, response, timestamp=None):
    """"""
    if timestamp is None:
      timestamp = self.frozen_timestamp
    self.response_queue.append((response, timestamp))
222213
public void onMessage(Message msg) {
	        try {
                    LOG.debug("Queuing msg [" + msg.getJMSMessageID() + "]");
                } catch (JMSException e) {
                }
		this.queue.offer(msg);
	}
501279
def process_queue #:nodoc:
      messages_come = false
      @connections.each do |connection|
        while not connection.msg_queue.empty?
          msg = connection.msg_queue.pop
          messages_come = true
          if @callback
            @callback.call(msg)
          end
        end
      end
      messages_come
    end
222164
def _ensure_queue(self):
        """"""
        if self._queue_path not in self._client.kv:
            self._client.kv[self._queue_path] = None
1049371
private void sendQueuedInvocations() {
        while (true) {
            MethodInvocation<?> currentRPC = queuedRpcList.poll();
            if (currentRPC == null) {
                return;
            }

            try {
                connector.executeAsyncMethod(currentRPC.getProxy(),
                                             currentRPC.getMethod(),
                                             currentRPC.getArgs(),
                                             currentRPC.getFuture());
            } catch (JoynrRuntimeException e) {
                currentRPC.getFuture().onFailure(e);
            } catch (Exception e) {
                currentRPC.getFuture().onFailure(new JoynrRuntimeException(e));
            }

        }

    }
557986
private void notifyMessageReceived(QueueData queueData)
   {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "notifyMessageReceived", queueData);

      long messageLength = queueData.getMessageLength();
      if (trackBytes)
      {
         bytesReceivedSinceLastRequestForMsgs += messageLength;
      }

      // Update the message arrival time
      queueData.updateArrivalTime(approxTimeThread.getApproxTime());

      messagesReceived++;
      currentBytesOnQueue += messageLength;

      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "notifyMessageReceived");
   }
982828
public void enqueue(TaskMessage message, Channel channel) {
        // lots of messages may be lost when deserialize queue hasn't finished init operation
        while (!bstartRec) {
            LOG.info("check whether deserialize queues have already been created");
            boolean isFinishInit = true;
            for (Integer task : workerTasks) {
                if (deserializeQueues.get(task) == null) {
                    isFinishInit = false;
                    JStormUtils.sleepMs(10);
                    break;
                }
            }
            if (isFinishInit) {
                bstartRec = isFinishInit;
            }
        }
        short type = message.get_type();
        if (type == TaskMessage.NORMAL_MESSAGE) {
            // 
            int task = message.task();
            DisruptorQueue queue = deserializeQueues.get(task);
            if (queue == null) {
                LOG.warn("Received invalid message directed at task {}. Dropping...", task);
                LOG.debug("Message data: {}", JStormUtils.toPrintableString(message.message()));
                return;
            }
            if (!isBackpressureEnable) {
                queue.publish(message.message());
            } else {
                flowCtrlHandler.flowCtrl(channel, queue, task, message.message());
            }
        } else if (type == TaskMessage.CONTROL_MESSAGE) {
            // enqueue a control message
            if (recvControlQueue == null) {
                LOG.info("Can not find the recvControlQueue. Dropping this control message");
                return;
            }
            recvControlQueue.publish(message);
        } else {
            LOG.warn("Unexpected message (type={}) was received from task {}", type, message.task());
        }
    }
880222
def send_to_queue(self, message):
        
        if not self.queue_delivery:
            raise RuntimeError("No queue_path provided")

        return self.queue_delivery.send(*self._message_args(message))
1099872
async def incoming(self):
        
        msg = await self._queue.get()
        self._queue.task_done()
        return msg
928183
function broadcastQueuedMessages() {
            var message;
            while (messageQueue.length) {
                message = messageQueue.shift();
                broadcast(message.name, message.data);
            }
            messageQueue = null;
        }
29740
public void process(Queue<String> argq, Object state) {
    String command = argq.peek();
    if (command != null) {
      System.err.print("Unrecognzied command: ");
      System.err.println(command);
    }
  }
566
public void queueEvent(Runnable r) {
                synchronized (this) {
                        mEventQueue.add(r);
                        synchronized (sGLThreadManager) {
                                mEventsWaiting = true;
                                sGLThreadManager.notifyAll();
                        }
                }
        }
849219
def queue(self):
        
        queue = NotificationQueue()
        self._listeners.add(queue)
        yield queue
        self._listeners.remove(queue)
936304
def write(self, message, flush=False):
        """"""
        # this need be threadsafe because the concurrent spinning running on
        # the stderr
        with self.lock:
            self.paralell_stream.erase()
            super(Clean, self).write(message, flush)
1099968
def process_messages_loop_internal(self):
        
        logging.info("Starting work queue loop.")
        self.connection.receive_loop_with_callback(self.queue_name, self.process_message)
91903
function Queue(concurrency) {
  this.paused = false;
  this.concurrency = concurrency;
  this.waitTimeout = 0;
  this.processTimeout = 0;
  this.throttleCount = 0;
  this.throttleInterval = 1000;
  this.count = 0;
  this.tasks = [];
  this.waiting = [];
  this.factors = {};
  this.fifoMode = true;
  this.roundRobinMode = false;
  this.priorityMode = false;
  this.onProcess = null;
  this.onDone = null;
  this.onSuccess = null;
  this.onTimeout = null;
  this.onFailure = null;
  this.onDrain = null;
}
4341
public function toMessage()
    {
        $m = new Message();
        foreach ($this->queueStatus as $action) {
            $m->push($action['action']);
            $m->push($action['queue']);
            $m->push($action['busy']);
            $m->push($action['available']);
        }

        return $m;
    }