Flush all of the section contents.

@return void
543960
public function flushSections()
    {
        $this->renderCount = 0;

        $this->sections = [];
        $this->sectionStack = [];

        $this->pushes = [];
        $this->pushStack = [];
    }
1114325
public function flush()
    {
 		global $wpdb;

 		$cachedItems = $wpdb->get_results("
 			SELECT *
 			FROM  {$wpdb->options}
 			WHERE  option_name LIKE  '_transient_%'
 		");

 		foreach ($cachedItems as $item) {
 			$cachedKey = str_replace('_transient_', '', $item->option_name);
 			delete_transient($cachedKey);
 		}
 	}
802887
public function flush()
    {
        $keys = $this->getCacheKeys();
        foreach ($keys as $key) {
            Cache::forget($this->makeCacheKey($key));
        }
        $this->removeKeys($keys);
    }
622779
protected function flushWrites()
    {
        // Skip this if there is no queued write items
        if (count($this->getQueue('write')) === 0) {
            return;
        }

        // Update the state of the queued attachment
        $this->updateQueueState(self::QUEUE_WORKING);

        foreach ($this->getQueue('write') as $name => $style) {
            if ($style && $this->uploaded_file->isImage()) {
                $file = $this->getResizer()
                    ->resize($this->uploaded_file, $style);
            }
            else {
                $file = $this->uploaded_file->getRealPath();
            }

            // Only move it real
            if ($filePath = $this->path($name)) {
                $this->move($file, $filePath);
            }
        }

        $this->resetQueue('write');

        // Update the state of the queued attachment
        $this->updateQueueState(self::QUEUE_DONE);
    }
235591
public function flush()
    {
        $this->aliases = [];
        $this->resolved = [];
        $this->bindings = [];
        $this->instances = [];
        $this->abstractAliases = [];
    }
349325
public function flush(): void
    {
        if ($this->writeDocument === true) {
            $this->write($this->getXML());
        }

        parent::flush();
    }
960516
def flush(self):
        """"""
        if self.mode != 'r':
            with self.mutex:
                self.zf.close()
                # N.B., re-open with mode 'a' regardless of initial mode so we don't wipe
                # what's been written
                self.zf = zipfile.ZipFile(self.path, mode='a',
                                          compression=self.compression,
                                          allowZip64=self.allowZip64)
432866
void flushAll() {
		for (Buffer buff : bufferPool) {
			try {
				buff.getExternalLock().lock();
				buff.flush();
			} finally {
				buff.getExternalLock().unlock();
			}
		}
	}
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();
    }
62505
void flush() {
		internalLock.writeLock().lock();
		flushLock.lock();
		try {
			if (isNew || modifiedBy.size() > 0) {
				VanillaDb.logMgr().flush(lastLsn);
				contents.write(blk);
				modifiedBy.clear();
				isNew = false;
			}
		} finally {
			flushLock.unlock();
			internalLock.writeLock().unlock();
		}
	}
14374
public function flush()
    {
        //todo bugfix batch record
        foreach ($this->deferLogs as $k => $deferLog) {
            $this->record($deferLog['message'], $deferLog['context'], $deferLog['level'], $deferLog['role']);
            $this->removeDeferLog($k);
        }
    }
115722
public function flushBuffer() {
        $content = $this->format($this->buffer->flush());

        if ( ! $this->is(OutputVerbosity::SILENT)) {
            fwrite($this->getOutputStream(), $content);
        }
    }
465631
public static function flushBuffer()
    {
        if (self::$_page && ob_get_length()) {
            self::$_zones[self::$_outputZone]->append(ob_get_clean());
            ob_start();
            return true;
        }
        return false;
    }
1104267
public function flush() {
        $headerHost = $this->host_.($this->port_ != 80 ? ':'.$this->port_ : '');

        $headers = array();
        $defaultHeaders = array('Host' => $headerHost,
                                'Accept' => 'application/x-thrift',
                                'User-Agent' => 'PHP/THttpClient',
                                'Content-Type' => 'application/x-thrift',
                                'Content-Length' => TStringFuncFactory::create()->strlen($this->buf_),
                            );
        foreach (array_merge($defaultHeaders, $this->headers_) as $key => $value) {
            $headers[] = "$key: $value";
        }

        $body = "POST " . $this->uri_ . " HTTP/1.1\r\n";
        foreach ($headers as $val) {
            $body .= "$val\r\n";
        }
        $body .= "\r\n";
        $body .= $this->buf_;

        // Set the hard-coded response.
        $this->respBuffer_ = $this->emptyResponse_;

        if ($this->_ensureSocketCreated()) {
            $this->_writeStream($body);
        } else if ($this->debug_) {
            error_log("Failed to create socket");
        }

        $this->buf_ = '';
    }
1187565
public function flushCache()
    {
        $iterator = new \DirectoryIterator($this->getConfig('cache_folder'));

        foreach ($iterator as $file) {
            if (! $file->isDot()) {
                unlink($file->getPathname());
            }
        }
    }
346078
public static function flush()
    {
        /** @var static $self */
        $self = singleton(static::class);

        $self->getCache()->clear();

        if ($self->config()->get('regenerate_on_flush')) {
            $self->generateAllTabs();
        }
    }
1121657
public function flush()
    {
        $this->buffer = array_merge($this->cache, $this->buffer);

        return file_put_contents($this->options->get('store'), json_encode($this->buffer));
    }