Flushes the action queue (e.g. commands that should be send to the wbdriver server)

@method flushQueue
@chainable
343357
function () {
    // clear the action queue
    this.actionQueue = [];
    
    // kill the session
    var promise = this.webdriverClient.deleteSession();

    // emit the run.complete event
    promise.then(function () {
      this.events.emit('driver:message', {key: 'run.complete', value: null});
    }.bind(this));

    return this;
  }
936617
def flush(self):
        

        self.clear()
        self.delete(self.session_key)
        self.create()
869052
public function flush()
    {
        if (file_exists($this->CacheFolder . "/" . $this->CacheIndex)) {
            unlink($this->CacheFolder . "/" . $this->CacheIndex);
            touch($this->CacheFolder . "/" . $this->CacheIndex);
        }
        if (file_exists($this->CacheFolder . "/" . $this->CacheDB)) {
            unlink($this->CacheFolder . "/" . $this->CacheDB);
            touch($this->CacheFolder . "/" . $this->CacheDB);
        }
    }
265502
function flush() {
    if (queue) {
      result.push(queue)

      if (handleText) {
        handleText.call(textContext, queue, {start: prev, end: now()})
      }

      queue = ''
    }
  }
1090844
def flush(o)
      @hooks.keys.each do |type|
        next unless Splib.type_of?(o, type)
        @hooks[type].each_pair do |key, objects|
          if(key == :procs)
            objects.each do |pr|
              if(@serial)
                pr.call(o)
              else
                @pool.process{ pr.call(o) }
              end
            end
          else
            objects.each do |h|
              if(h[:req].call(o))
                if(@serial)
                  h[:object].send(h[:method], o)
                else
                  @pool.process{ h[:object].send(h[:method], o) }
                end
              end
            end
          end
        end
      end
      nil
    end
713439
public void flushInsert()
    {
        if (!useBulkInsert)
        {
            for (int i = 0; i < numberOfQueues; i++)
            {
                if (!insertLists[i].isEmpty())
                {
                    this.submitTaskToQueue(this.createInsertTask(insertLists[i]), i, processedInserts);
                    this.insertLists[i] = new ArrayList(batchSize);
                    this.insertsQueued++;
                }
            }
        }
    }
707290
public static function flush() {
        if (count($_COOKIE) > 0) {
            foreach ($_COOKIE as $key => $value) {
                self::delete($key, '/');
            }
        }
    }
283335
function flushQueue()
    {
        var queued = WebInspector.log.queued;
        if (!queued)
            return;

        for (var i = 0; i < queued.length; ++i)
            logMessage(queued[i]);

        delete WebInspector.log.queued;
    }
513023
public function flush(): void
    {
        while (false == $this->events->isEmpty()) {
            list($topic, $message) = $this->events->dequeue();

            $this->realProducer->sendEvent($topic, $message);
        }

        while (false == $this->commands->isEmpty()) {
            list($command, $message) = $this->commands->dequeue();

            $this->realProducer->sendCommand($command, $message);
        }
    }
1237015
public function flushAll()
    {
        foreach (array_keys($this->serverArray) as $name) {
            $this->getClient($name)->flushAll();
        }
    }
1050684
def flush(self):
        """"""
        for seq in self.buffer:
            SeqIO.write(seq, self.handle, self.format)
        self.buffer = []
218046
public function flush(): void
    {
        if (empty($this->buffers)) {
            return;
        }

        foreach ($this->buffers as $buffer) {
            try {
                $this->sender->sendTo($buffer[0], $buffer[1], $buffer[2]);
            } catch (SenderException $e) {
                if (404 === $e->getCode()) {
                    $this->manager->remove($buffer[0]);
                }
            }
        }

        // WARNING! this will flush every models.
        // Worst case if we have invalid state model and not empty of this.buffers
        // buffers and invalid state models will be flush (eg. in process of none form.isValid())
        $this->manager->flush();
    }
1267104
function flush () {
            var i = 0;
            while (i < fnQueueLen) {
                fn(fnQueue[i], fnQueue[i + 1]);
                fnQueue[i++] = $undefined;
                fnQueue[i++] = $undefined;
            }

            fnQueueLen = 0;
            if (fnQueue.length > initQueueSize) fnQueue.length = initQueueSize;
        }
767635
public function flush()
    {
        foreach ($this->buffer as $data) {
            $this->output->write($data['messages'], $data['newline'], $data['options']);
        }

        // Clear the buffer array.
        $this->buffer = [];
    }
1209648
public function flush()
    {
        Files::emptyDirectoryRecursively($this->cacheDirectory);
        if ($this->frozen === true) {
            @unlink($this->cacheDirectory . 'FrozenCache.data');
            $this->frozen = false;
        }
    }
408449
public void flush()
  {
    if (!enabled)
    {
      return;
    }
    if (!queue.isEmpty())
    {
      // start a new thread to upload without blocking the current thread
      Runnable runUpload = new TelemetryUploader(this, exportQueueToString());
      uploader.execute(runUpload);
    }
  }
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()