Flushes the queue by transmitting the enqueued messages using the registered services
 @return [FlushResult] the result of the operation
434556
def flush
      failed_messages = []
      new_token_messages = []

      @queued_messages.each do |service, messages|
        service.init_push
        messages.each do |message|
          service.send(message)
        end
        (failed, new_token) = service.end_push
        failed_messages += failed
        new_token_messages += new_token
      end
      @queued_messages = {}
      return FlushResult.new(failed_messages, new_token_messages)
    end
487885
def flush(self):
        

        done = threading.Event()

        def _callback():
            done.set()

        self.defer(_callback)
        done.wait()
119573
def flush(self):
        
        self._write_all(self._wbuffer.getvalue())
        self._wbuffer = StringIO()
        return
936617
def flush(self):
        

        self.clear()
        self.delete(self.session_key)
        self.create()
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
1167890
def flush(self):
        
        self.acquire()
        try:
            if self.stream and hasattr(self.stream, "flush"):
                self.stream.flush()
        finally:
            self.release()
914883
def flush(self):
        
        self.notify(tuple(self._queue))
        self._queue.clear()
444346
public function flush()
    {
        $this->_result = null;
        $this->_lastResult = array();
        $this->_lastQuery = null;
        $this->_lastQueryHash = null;
    }
568859
def flush(self):
        
        local_sender = self.sender
        if not local_sender:
            return
        while True:
            # get at most send_buffer_size items and send them
            data = []
            while len(data) < local_sender.send_buffer_size:
                item = self.get()
                if not item:
                    break
                data.append(item)
            if len(data) == 0:
                break
            local_sender.send(data)
482093
def flush(self):
        
        self.queue(None, None, flush=True)
        if not self._flushed.wait(timeout=self._max_flush_time):
            raise ValueError("flush timed out")
1023931
public function flush()
    {
        parent::flush();

        $this->middleware = [];
        $this->currentRoute = [];
        $this->loadedProviders = [];
        $this->routeMiddleware = [];
        $this->reboundCallbacks = [];
        $this->resolvingCallbacks = [];
        $this->availableBindings = [];
        $this->ranServiceBinders = [];
        $this->loadedConfigurations = [];
        $this->afterResolvingCallbacks = [];

        $this->router = null;
        $this->dispatcher = null;
        static::$instance = null;
    }
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;
        }
450198
public function flush()
    {
        $script = "
		local entries = redis.call('LRANGE',KEYS[1],0,-1)
		for k1,entryIdentifier in ipairs(entries) do
			redis.call('DEL', ARGV[1]..'entry:'..entryIdentifier)
			local tags = redis.call('SMEMBERS', ARGV[1]..'tags:'..entryIdentifier)
			for k2,tagName in ipairs(tags) do
				redis.call('DEL', ARGV[1]..'tag:'..tagName)
			end
			redis.call('DEL', ARGV[1]..'tags:'..entryIdentifier)
		end
		redis.call('DEL', KEYS[1])
		redis.call('DEL', KEYS[2])
		";
        $this->redis->eval($script, [$this->buildKey('entries'), $this->buildKey('frozen'), $this->buildKey('')], 2);

        $this->frozen = null;
    }
834807
def flush(self):
        
        for elem in self:
            if elem.id[0] != scoop.worker:
                elem._delete()
            self.socket.sendFuture(elem)
        self.ready.clear()
        self.movable.clear()
815461
def flush(base = nil)
    debug { 'flush ' << base.to_s }

    @sync.synchronize do

      if @flush_delay
        next_flush = @last_flush + @flush_delay

        if next_flush > Time.now
          flush_at(next_flush, base)
        else
          flush_now(base)
          @last_flush = Time.now
        end

      else
        flush_now(base)
      end
    end
  end
521286
def nextResult
      result = nil
      @mutex.synchronize do
        result = @results.shift
        @progressMutex.synchronize{ @requestProgress.delete result.requestId } if result
      end
      result
    end
592254
def flush_queue(self):
        """"""
        records = []

        while not self.queue.empty() and len(records) < self.batch_size:
            records.append(self.queue.get())

        if records:
            self.send_records(records)
            self.last_flush = time.time()