Get the default progress limit.

@return int
16673
public function getProgressLimit()
    {
        if ($this->progressLimit === null) {
            $this->setProgressLimit($this->config->get('concrete.i18n.community_translation.progress_limit', 90));
        }

        return $this->progressLimit;
    }
660741
public function getLimit() {
        if (false !== strpos($this->limit, ','))
            return $this->limit; // both offset and limit are in the limit attribute;
        return $this->limit ? $this->limit . ' OFFSET ' . $this->offset : '';
    }
371896
public function getRateLimit()
    {
        $result = null;
        $config = $this->app->make('community_translation/config');
        $maxRequests = (int) $config->get('options.api.rateLimit.maxRequests');
        if ($maxRequests > 0) {
            $timeWindow = (int) $config->get('options.api.rateLimit.timeWindow');
            if ($timeWindow > 0) {
                $result = [$maxRequests, $timeWindow];
            }
        }

        return $result;
    }
813382
public function getTotal()
    {
        $query = clone $this->getQuery();
        $query->order = null;
        $query->limit = null;

        return $query->fetchValue('COUNT(*)');
    }
277125
public function limit($request) {
        $limit = (int)$request->getVar('limit');
        if($limit && is_int($limit) && $limit > 0) {
            return $limit;
        } else {
            return static::$default_limit;
        }
    }
1198563
public function getProgress()
    {
        $progress = new Progress();
        $progress->percent = $this->__get('progress_percent');
        $progress->step = $this->__get('progress_step');
        $progress->stepName = $this->__get('progress_name');
        $progress->totalSteps = $this->__get('progress_steps');
        $progress->leftOverSeconds = $this->__get('progress_remaining');
        return $progress;
    }
1246322
public function getRateLimit()
    {
        $this->start();
        try {
            $this->getUserControl()->checkRateLimit();
            $this->getUserControl()->checkGenericAccess(__FUNCTION__);
            $rateLimit = $this->getUserControl()->getRateLimit();
            if ($rateLimit === null) {
                $result = $this->buildJsonResponse(null);
            } else {
                list($maxRequests, $timeWindow) = $rateLimit;
                $visits = $this->getUserControl()->getVisitsCountFromCurrentIP($timeWindow);
                $result = $this->buildJsonResponse([
                    'maxRequests' => $maxRequests,
                    'timeWindow' => $timeWindow,
                    'currentCounter' => $visits,
                ]);
            }
        } catch (Exception $x) {
            $result = $this->buildErrorResponse($x);
        } catch (Throwable $x) {
            $result = $this->buildErrorResponse($x);
        }

        return $this->finish($result);
    }
269245
public function limit() 
    {
        $url = self::HOST . self::LIMIT;

        $params = $this->get_default_params();
        $result = $this->request($url, $params);
        $result = explode("\n", $result);

        return array(
            'code' => $result[0],
            'total' => $result[1],
            'current' => $result[2]
        );
    }
730234
public function max(){
		
		if($this->isEmpty()){
			throw new \UnderflowException(\get_called_class() . ' is empty');
		}
		
		$max = $this->front();
		
		for($i = 1, $l = $this->count(); $i < $l; ++$i){
			if(Number::greaterThan($this->_Arr[$i], $max)){
				$max = $this->_Arr[$i];
			}
		}
		
		return $max;
		
	}
1339785
public static function getRecursionLimit(): int
    {
        if (self::$recursionLimit) {
            return self::$recursionLimit;
        }

        self::$recursionLimit = self::$recursionLimitFallback;

        if (self::$objectManager instanceof ObjectManagerInterface) {
            $configurationManager = self::$objectManager->get(ConfigurationManager::class);
            if ($configurationManager instanceof ConfigurationManager) {
                $recursionLimitFromSettings = $configurationManager->getConfiguration('Settings', 'Neos.Flow.error.debugger.recursionLimit');
                if (is_int($recursionLimitFromSettings)) {
                    self::$recursionLimit = $recursionLimitFromSettings;
                }
            }
        }

        return self::$recursionLimit;
    }
897315
protected function fetchLimits()
    {
        $result = $this->get('/rate_limit') ?: [];

        // Assemble Limit instances
        foreach ($result['resources'] as $resourceName => $resource) {
            $this->resources[$resourceName] = new RateLimitResource($resourceName, $resource);
        }

        return $result;
    }
751636
public function getLength()
    {
        if (!$this->container) {
            return 0;
        }

        $count = count($this->container);
        $keys = array_keys($this->container);
        return (array_keys($this->container) === range(0, $count - 1))
            ? $count
            : max($keys);
    }
418340
public function limitExceeded()
    {
        $limit = $this->_agent->getLimit();
        return $limit != CollectionAgentAbstract::NO_LIMIT && $this->_count > $this->_agent->getLimit();
    }
357836
public function getCurrentRealmsIncrement(): int
    {
        $currentDifficulty = $this->getValue();
        $maximalDifficulty = $this->getMaximal();
        if ($currentDifficulty <= $maximalDifficulty) {
            return 0;
        }
        $additionalDifficulty = $currentDifficulty - $maximalDifficulty;
        $steps = $additionalDifficulty / $this->getDifficultyAddition()->getDifficultyAdditionPerStep();
        $realmsIncrement = $steps * $this->getDifficultyAddition()->getRealmsChangePerAdditionStep();

        return (int)\ceil($realmsIncrement); // even a tiny piece of a higher realm means the lower realm is not able to create that formula
    }
1160275
public static function getMaxUploadSize()
    {
        $limit = false;
        if ($value = self::iniSizeToInt(ini_get('upload_max_filesize')))
        {
            $limit = $value;
        }

        $value = self::iniSizeToInt(ini_get('post_max_size'));
        $reserveForHeadersAndBody = 1024;
        if ($value && $value - $reserveForHeadersAndBody < $limit)
        {
            $limit = $value - $reserveForHeadersAndBody;
        }

        /*
        $value = self::iniValueToInt(ini_get('memory_limit'));
        $reserveForAppItself = memory_get_peak_usage(true);
        if ($value && $value < $limit)
        {
            $limit = $value - $reserveForAppItself;
        }
        */
        return $limit;
    }
821515
protected function getTimeLimit()
    {
        $timeLimit = self::DEFAULT_TIME_LIMIT;
        if($this->hasOption(self::TIME_LIMIT_OPT)){
            $timeLimit = (int)$this->getOption(self::TIME_LIMIT_OPT);
        }
        return $timeLimit;
    }
861193
public function getRemaining()
    {
        $speed = $this->getSpeed();
        $notHandledCount = $this->all - $this->handled;

        $remainingSeconds = $speed != 0 ? $notHandledCount / $speed : $notHandledCount;

        return round($remainingSeconds);
    }