Flushes the commands in the pipeline queue to Redis and returns the responses.
@see pipeline
333321
public function execute()
	{
		// open a Redis connection and execute the queued commands
		foreach ($this->queue as $command)
		{
			for ($written = 0; $written < strlen($command); $written += $fwrite)
			{
				$fwrite = fwrite($this->connection, substr($command, $written));
				if ($fwrite === false)
				{
					throw new \RedisException('Failed to write entire command to stream');
				}
			}
		}

		// Read in the results from the pipelined commands
		$responses = array();
		for ($i = 0; $i < count($this->queue); $i++)
		{
			$responses[] = $this->readResponse();
		}

		// Clear the queue and return the response
		$this->queue = array();

		if ($this->pipelined)
		{
			$this->pipelined = false;
			return $responses;
		}
		else
		{
			return $responses[0];
		}
	}
314018
private void flush() {
    try {
      QueuedCommand cmd;
      int i = 0;
      boolean flushedOnce = false;
      while ((cmd = queue.poll()) != null) {
        cmd.run(channel);
        if (++i == DEQUE_CHUNK_SIZE) {
          i = 0;
          // Flush each chunk so we are releasing buffers periodically. In theory this loop
          // might never end as new events are continuously added to the queue, if we never
          // flushed in that case we would be guaranteed to OOM.
          channel.flush();
          flushedOnce = true;
        }
      }
      // Must flush at least once, even if there were no writes.
      if (i != 0 || !flushedOnce) {
        channel.flush();
      }
    } finally {
      // Mark the write as done, if the queue is non-empty after marking trigger a new write.
      scheduled.set(false);
      if (!queue.isEmpty()) {
        scheduleFlush();
      }
    }
  }
1237015
public function flushAll()
    {
        foreach (array_keys($this->serverArray) as $name) {
            $this->getClient($name)->flushAll();
        }
    }
1202888
def Flush(self):
    """"""
    self._CheckLeaseAndFlush()
    self.Load()
    super(FlowBase, self).Flush()
    # Writing the messages queued in the queue_manager of the runner always has
    # to be the last thing that happens or we will have a race condition.
    self.FlushMessages()
444346
public function flush()
    {
        $this->_result = null;
        $this->_lastResult = array();
        $this->_lastQuery = null;
        $this->_lastQueryHash = null;
    }
990945
public function flush() {
    if ($this->locked) return;
    while ($this->send()) {
    }
    foreach ($this->files as $file) {
      $this->output($file->getCentral());
    }
    $this->output($this->getEOF());
    $this->locked = TRUE;
    $this->outputter->flush();
  }
605797
public synchronized void flush()
	{
		if (out != null)
			try {
				out.flush();
			}
			catch (final IOException e) {
				getErrorHandler().error(this, "on flush", e);
			}
	}
25203
public function flushPipeline($send = true)
    {
        if ($send && !$this->pipeline->isEmpty()) {
            $responses = $this->executePipeline($this->getConnection(), $this->pipeline);
            $this->responses = array_merge($this->responses, $responses);
        } else {
            $this->pipeline = new \SplQueue();
        }

        return $this;
    }
1016396
public function flush()
    {
        $flushCallback = function ($allFlushed, $cache) {
            return $allFlushed && $cache->flush();
        };
        return array_reduce($this->caches, $flushCallback, true);
    }
477360
public function flush()
    {
        $result = $this->bucket->manager()->flush();
        if (isset($result['_'])) {
            throw new FlushException($result);
        }
    }
427885
public function flush_all()
    {
        /**
         * flush_all\r\n
         */

        // Build packet to send ...
        $data = self::COMMAND_FLUSH_ALL . self::COMMAND_TERMINATOR;

        return $this->send(self::COMMAND_FLUSH_ALL, $data);
    }
916803
def flush_all
      # It can take a long time to flush all of the messages
      # on a server, so we'll set the read timeout to something
      # much higher than usual.
      connection.with_additional_read_timeout(60) do
        resp = send_recv( KJess::Request::FlushAll.new )
        return KJess::Response::End === resp
      end
    end
564873
function flush(req, res) {
  this.spawn();
  this.reply(req, res);
  this.ps.send({event: 'flush'});
}
230794
def flush(self):
        """"""
        self.stages = []
        self.stagenames = []

        if not self.queue:
            return

        if self.print_statistics:#pragma: no cover
            print("LEN OF QUENE", len(self))
            t = time()

        if self._chain._collect_compiler_artifacts:
            self._compile(debug=True, stages=self.stages,
                          stagenames=self.stagenames)
        else:
            self._compile()

        if self.debug:
            print("ABOUT TO EXEC", self.queue)#pragma: no cover

        if self.print_statistics:#pragma: no cover
            print("COMPILE TIME", time()-t)
            print("TOTAL BITS OF ALL PRIMS", sum(
                (p.count for p in self.queue if hasattr(p, 'count'))))
            t = time()

        self._chain._controller._execute_primitives(self.queue)

        if self.print_statistics:
            print("EXECUTE TIME", time()-t)#pragma: no cover

        self.queue = []
        self._chain._sm.state = self._fsm.state
850569
public function flush() {
		$specRawer = new SpecRawer($this->attributes);
		$specRawer->rawTypes($this->eiTypeExtractions, $this->customTypeExtractions);
		$specRawer->rawEiMasks($this->eiTypeExtensionExtractionGroups);
		$specRawer->rawEiModificatorExtractionGroups($this->eiModificatorExtractionGroups);
		$specRawer->rawLaunchPads($this->launchPadExtractions);
		
		$this->configSource->writeArray($this->attributes->toArray());
	}
1009331
def flush(self):
        
        self._pending_flush = False

        if self.handler is None:
            return

        if self.send_queue.is_empty():
            return

        self.handler.send_pack('a[%s]' % self.send_queue.get())
        self.send_queue.clear()
1012307
def flush(self):
        """"""
        if self.shutdown:
            return
        self.flush_buffers(force=True)
        self.queue.put(FLUSH_MARKER)
        self.queue.join()