Cleans up too hold negative response messages (5 * duration).
@return void
@internal
497380
function cleanupNegativeResponseMessages() {
        $current = \time();
        $timeout = 5 * ((int) $this->client->getOption('negativeResponseThrottlingDuration'));
        
        foreach($this->negativeResponseThrottling as $key => $time) {
            if(($current - $time) >= $timeout) {
                unset($this->negativeResponseThrottling[$key]);
            }
        }
    }
507042
function cleanup()
    {
        $this->HTTP->removeSessionVariable( $this->StorageName . $this->MetaDataName );
        $this->HTTP->removeSessionVariable( $this->StorageName . $this->VariableListName );
        $this->MetaData = array();
        $this->VariableList = array();
    }
747576
public function cleanup(): void
    {
        foreach ($this->getStore() as $key => $value)
        {
            $this->remove($key);
        }
    }
1204059
public function cleanUp()
    {
        $this->filesystem->remove($this->compressedArchivePath);
        $this->filesystem->remove($this->outputPath);
    }
794566
public function clearCommand()
    {
        $startTimestamp = time();

        $path = FLOW_PATH_ROOT . 'Data/MagicWandStash';
        FileUtils::removeDirectoryRecursively($path);

        #################
        # Final Message #
        #################

        $endTimestamp = time();
        $duration = $endTimestamp - $startTimestamp;

        $this->renderHeadLine('Done');
        $this->renderLine('Cleanup successful in %s seconds', [$duration]);
    }
1358725
function clear_messages()
    {
        $this->last_error = null;
        $this->last_error_id = null;
        $this->last_query = null;
    }
617256
public function cleanCountersByLevel()
    {
        foreach ($this->counters as $pos => $counter) {
            if ($counter->getLevel() !== $this->highestActiveLevel + 1) {
                unset($this->counters[$pos]);
            }
        }
    }
722754
public function clear() {
        $this->statusCode = self::HTTP_OK;
        $this->headers = [];
        $this->cookies = [];
        $this->content = null;
        $this->sent = false;
    }
960093
public static function cleanup() {
		if (!isset($_SESSION[Config::$sticky_session_name])) {
			return;
		}

		foreach ($_SESSION[Config::$sticky_session_name] as $key => $variables) {
			if (isset($variables['counter']) and $variables['counter'] < 1) {
				$_SESSION[Config::$sticky_session_name][$key]['counter']++;
				continue;
			}
			unset($_SESSION[Config::$sticky_session_name][$key]);
		}
	}
583038
public function clearMessages()
    {
        if (isset($this->storage[$this->storageKey])) {
            $this->storage[$this->storageKey] = [];
        }

        $this->fromPrevious = [];
        $this->forNow = [];
    }
699101
public function clear()
    {
        $this->_actual = null;
        $this->_passed = null;
        $this->_processed = null;
        $this->_not = false;
        $this->_timeout = 0;
        $this->_logs = [];
        $this->_deferred = null;
    }
1063168
public function cleanup()
    {
        $this->requestId = null;
        $this->result    = null;
        $this->setState(self::READY);
    }
287510
protected function flushDeletes()
    {
        if ( ! $this->deleteTarget) {
            return;
        }

        foreach ($this->queuedForDelete as $variant) {
            $this->handler->deleteVariant($this->deleteTarget, $variant);
        }

        $this->queuedForDelete = [];
    }
1327781
public function Cleanup() {
      foreach ($this->_Objects as $FactoryInstanceName => &$FactoryInstance) {
         if (!is_array($FactoryInstance)) continue;
         $FactoryType = $FactoryInstance['FactoryType'];
         
         if (!array_key_exists($FactoryType, $FactoryInstance)) continue;
         $FactoryObject = &$FactoryInstance[$FactoryType];
         
         if (method_exists($FactoryObject, 'Cleanup'))
            $FactoryObject->Cleanup();
         
         unset($FactoryInstance);
      }
   }
1291538
public function clean()
	{
		if ($this->output->isInteractive())
		{
			$performed = 0;
			$proceed   = $this->output->getResponse('Do you want to purge all rollback points except the latest? [y|n]');

			if ($proceed == 'y' || $proceed == 'yes')
			{
				$this->mechanism->purgeRollbackPoints();
				$this->output->addLine('Purging rollback points.');
				$performed++;
			}

			$proceed = $this->output->getResponse('Do you want to purge all stashed changes? [y|n]');

			if ($proceed == 'y' || $proceed == 'yes')
			{
				$this->mechanism->purgeStash();
				$this->output->addLine('Purging repository stash.');
				$performed++;
			}

			$this->output->addLine("Clean up complete. Performed ({$performed}/2) cleanup operations available.");
		}
		else
		{
			$didSomething = false;
			if ($this->arguments->getOpt('purge-rollback-points'))
			{
				$this->mechanism->purgeRollbackPoints();
				$this->output->addLine('Purging rollback points.');
				$didSomething = true;
			}

			if ($this->arguments->getOpt('purge-stash'))
			{
				$this->mechanism->purgeStash();
				$this->output->addLine('Purging repository stash.');
				$didSomething = true;
			}

			if (!$didSomething)
			{
				$this->output->addLine('Please specify which cleanup operations to perform');
			}
		}
	}
1026182
public function actionClearAll()
    {
        $caches = $this->findCaches();
        $cachesInfo = [];

        if (empty($caches)) {
            $this->notifyNoCachesFound();
            return ExitCode::OK;
        }

        foreach ($caches as $name => $class) {
            $cachesInfo[] = [
                'name' => $name,
                'class' => $class,
                'is_flushed' => $this->canBeCleared($class) ? $this->app->get($name)->clear() : false,
            ];
        }

        $this->notifyCleared($cachesInfo);
    }
796013
private function cleanOldPreviews()
    {
        $oldPreviews = array_filter($this->files->files($this->storage()), function ($file) {
            return (time() - $this->files->lastModified($file)) > (Config::get('mail-debug.lifetime') * 60);
        });

        if ($oldPreviews) {
            $this->files->delete($oldPreviews);
        }
    }