Flush all streams.
543042
def flush(self):
        """"""
        if self.__logFileStream is not None:
            try:
                self.__logFileStream.flush()
            except:
                pass
            try:
                os.fsync(self.__logFileStream.fileno())
            except:
                pass
        if self.__stdout is not None:
            try:
                self.__stdout.flush()
            except:
                pass
            try:
                os.fsync(self.__stdout.fileno())
            except:
                pass
497519
public function flush()
    {
        parent::flush();

        $this->booted = false;
        $this->hasBeenBootstrapped = false;

        $this->bootingCallbacks = [];
        $this->bootedCallbacks = [];
        $this->reboundCallbacks = [];
        $this->resolvingCallbacks = [];
        $this->terminatingCallbacks = [];
        $this->afterResolvingCallbacks = [];
        $this->globalResolvingCallbacks = [];

        $this->serviceProviders = [];
        $this->deferredServices = [];
        $this->buildStack = [];
    }
1282996
def Flush(self):
    """"""
    while self._age:
      node = self._age.PopLeft()
      self.KillObject(node.data)

    self._hash = dict()
119573
def flush(self):
        
        self._write_all(self._wbuffer.getvalue())
        self._wbuffer = StringIO()
        return
235591
public function flush()
    {
        $this->aliases = [];
        $this->resolved = [];
        $this->bindings = [];
        $this->instances = [];
        $this->abstractAliases = [];
    }
774520
def flush_all(self):
        
        for queue_name in chain(self.queues, self.delay_queues):
            self.flush(queue_name)
115722
public function flushBuffer() {
        $content = $this->format($this->buffer->flush());

        if ( ! $this->is(OutputVerbosity::SILENT)) {
            fwrite($this->getOutputStream(), $content);
        }
    }
1050684
def flush(self):
        """"""
        for seq in self.buffer:
            SeqIO.write(seq, self.handle, self.format)
        self.buffer = []
713315
public static function flushAll()
    {
        $GLOBALS["CACHE_MANAGER"]->cleanAll();
        $GLOBALS["stackCacheManager"]->cleanAll();
        $staticHtmlCache = StaticHtmlCache::getInstance();
        $staticHtmlCache->deleteAll();
        BXClearCache(true);
    }
503502
public function flush()
    {
        $keys = $this->redis->keys($this->redis->prefix('*'));

        foreach ($keys as $key) {
            $this->redis->del($key);
        }
    }
464765
public function flush()
    {
        $this->filters = [];
        $this->include = null;
        $this->id = null;
        $this->endpoint = null;
        $this->sort = null;
        $this->fields = null;
        $this->pageSize = null;
        $this->response = null;
    }
1237015
public function flushAll()
    {
        foreach (array_keys($this->serverArray) as $name) {
            $this->getClient($name)->flushAll();
        }
    }
1047748
def _flush(self):
        
        for consumer in self.consumers:
            if not getattr(consumer, "closed", False):
                consumer.flush()
411846
void doFlush()
    {
        enableFlush = true;
        flush();
        execute();
        enableFlush = false;
        flushManager.commit();
        flushManager.clearFlushStack();
    }
687007
def FlushCache(self):
    """"""
    self._cache = b''
    self._cache_start_offset = None
    self._cache_end_offset = None
    self._ResetDecompressorState()
1347855
def flush(self):
        
        if self._writable:
            with self._seek_lock:
                self._flush_raw_or_buffered()

                # Clear the buffer
                self._write_buffer = bytearray(self._buffer_size)
                self._buffer_seek = 0
1110436
def flush(flush = Zlib::SYNC_FLUSH)
      run '', flush unless flush == Zlib::NO_FLUSH

      detatch_output
    end