Flush an event queue, firing the flusher for each payload.

@param  string  $queue
@return void
437199
public static function flush($queue)
	{
		foreach (static::$flushers[$queue] as $flusher)
		{
			// We will simply spin through each payload registered for the event and
			// fire the flusher, passing each payloads as we go. This allows all
			// the events on the queue to be processed by the flusher easily.
			if ( ! isset(static::$queued[$queue])) continue;

			foreach (static::$queued[$queue] as $key => $payload)
			{
				array_unshift($payload, $key);

				call_user_func_array($flusher, $payload);
			}
		}
	}
503502
public function flush()
    {
        $keys = $this->redis->keys($this->redis->prefix('*'));

        foreach ($keys as $key) {
            $this->redis->del($key);
        }
    }
1237015
public function flushAll()
    {
        foreach (array_keys($this->serverArray) as $name) {
            $this->getClient($name)->flushAll();
        }
    }
914883
def flush(self):
        
        self.notify(tuple(self._queue))
        self._queue.clear()
808392
private void flushQueue() {
        while (true) {
            final Action act = firstNonNull(actionQueue.poll(), new Action(Actions.END, null));
            switch (act.action) {
                case POST: post(act.object); break;
                case REGISTER: register(act.object); break;
                case UNREGISTER: unregister(act.object); break;
                case END: default: return;
            }
        }
    }
265270
public function handleFlush(FlushEvent $event)
    {
        foreach ($this->persistEvents as $persistEvent) {
            $document = $persistEvent->getDocument();
            $structure = $this->documentToStructure($document);

            $event = new ContentNodeEvent($this->documentInspector->getNode($document), $structure);
            $this->eventDispatcher->dispatch(ContentEvents::NODE_POST_SAVE, $event);
        }

        $this->persistEvents = [];
    }
1213748
public function flush($model)
    {
        if (! $this->shouldMaintainIndex($model)) {
            return;
        }

        $indexColumn = $this->getIndexColumn($model);

        $this->database
            ->table($model->searchableAs())
            ->update([$indexColumn => null]);
    }
536075
function clear(): void {
        $queue = $this->queue;
        $this->queue = array();
        
        while($item = \array_shift($queue)) {
            unset($item);
        }
    }
112836
public function setQueue($queue, $value)
    {
        // Ensure the value is an array
        if (is_array($value) === false) {
            $value = [$value];
        }

        $this->queues[$queue] = array_merge(
            $this->getQueue($queue), $value
        );
    }
392545
public function flush()
    {
        // Prevent an endless loop and work on a batch copy.
        $promises = $this->getPromises();
        $this->setPromises([]);
        Promise\settle($promises)->wait();
    }
1006167
public function subscribeQueueEvents(QueueManager $queue)
    {
        $queue->looping(function () {
            // Flush any and all events that were possibly generated by queue jobs
            Integration::flushEvents();

            // We have added a scope when a job starts processing
            Hub::getCurrent()->popScope();
        });

        foreach (static::$queueEventHandlerMap as $eventName => $handler) {
            $this->events->listen($eventName, [$this, $handler]);
        }
    }
477360
public function flush()
    {
        $result = $this->bucket->manager()->flush();
        if (isset($result['_'])) {
            throw new FlushException($result);
        }
    }
259590
public static function busy(&$queue){

        self::$_busy_event_buffer_counter ++;
        self::$_last_busy_ts = time();

        self::_buffer($queue);
    }
1028627
public function flushQueue(string $connectionName = null)
    {
        if (empty($this->queues)) {
            return;
        }

        if ($connectionName === null) {
            foreach ($this->queues as $queueConnectionName => $queue) {
                $this->flushQueueItem($queueConnectionName, $queue);
            }
        } elseif (array_key_exists($connectionName, $this->queues)) {
            $this->flushQueueItem($connectionName, $this->queues[$connectionName]);
        }
    }
187
protected function flush($maxBufferLevel = null)
    {
        if (null === $maxBufferLevel) {
            $maxBufferLevel = ob_get_level();
        }

        while (ob_get_level() > $maxBufferLevel) {
            ob_end_flush();
        }
    }
863967
private function flush()
    {
        foreach ($this->queue as $item) {
            $this->delegate->writeItem($item);
        }

        if ($this->delegate instanceof FlushableWriter) {
            $this->delegate->flush();
        }
    }
58162
public function flush($tags = null)
    {
        $tags = $this->getCacheTags($tags);

        $this->flushKeysForTags($tags);
    }