Get priority string.

@return string
513059
public function getPriorityString()
    {
        if (!empty(TicketMessageInterface::PRIORITIES[$this->priority])) {
            return TicketMessageInterface::PRIORITIES[$this->priority];
        }

        return TicketMessageInterface::PRIORITIES[0];
    }
857082
public function getSortingParameters()
    {
        $sorting = $this->getSorting($this->getSortIdent());
        if (!is_array($sorting)) {
            return null;
        }

        return implode('|', $sorting);
    }
1343129
protected function getSeverityString($severity)
    {
        switch ($severity) {
            case Log::Error:
                return 'Error';
            case Log::Warning:
                return 'Warning';
            case Log::Notice:
                return 'Notice';
            case Log::Info:
                return 'Info';
            case Log::Debug:
            default:
                return 'Debug';
        }
    }
1064891
public function getSortNext()
	{
		$defaultSort = $this->grid->getColumnDefaultSort($this->key);

		if ($this->sort == 'ASC') {
			return [$this->key => $defaultSort === 'DESC' ? FALSE : 'DESC'];
		} else if ($this->sort == 'DESC') {
			return [$this->key => $defaultSort === 'DESC' ? 'ASC' : FALSE];
		}

		return [$this->key => 'ASC'];
	}
603133
public function getBetterTraceAsString() {
        if (!$this->betterTraceAsString)
            $this->betterTraceAsString = DebugHelper::getBetterTraceAsString($this);
        return $this->betterTraceAsString;
    }
700929
public function getPrevChar()
	{
		if( $this->direction == ">" )
			$this->pointer--;
		if( $this->pointer <= $this->count() &&  $this->pointer > 0 )
		{
			$this->direction = "<";
			$this->pointer--;
			$character = $this->buffer[$this->pointer];
		}
		return $character;
	}
48941
public function getSortOrder()
    {
        $sortOrder = isset($this->requestParams[self::PARAM_SORT_ORDER]) ?
            $this->requestParams[self::PARAM_SORT_ORDER] : self::DEFAULT_SORT_ORDER;
        $sortOrder = mb_strtolower($sortOrder);

        if (!in_array($sortOrder, ['asc', 'desc'])) {
            $sortOrder = self::DEFAULT_SORT_ORDER;
        }

        return $sortOrder;
    }
247820
public function getDirection()
    {
        if (null === $this->_direction) {
            if (null === $this->_string) {
                $this->_direction = static::LTR;
            } else {
                $this->_direction = static::getCharDirection(
                    \mb_substr($this->_string, 0, 1)
                );
            }
        }

        return $this->_direction;
    }
406118
public function getDescription()
    {
        return vsprintf(
            'The value is expected to be between %f and %f'
            . ' (%f <= x <= %f).',
            [$this->min, $this->max, $this->min, $this->max]
        );
    }
205817
public function getPrev()
    {
        return self::find()->where(['<', 'id', $this->id])->orderBy(['id' => SORT_DESC])->limit(1)->one();
    }
1266153
public function getRules()
    {
        if (!isset($this->ruleSet)) {
            $this->ruleSet = new PriorityList(RuleInterface::class);
        }
        return $this->ruleSet;
    }
345180
public function getOperators()
    {
        // Order the by priority then precedent.
        $list = (array)$this->operators;
        usort($list, function(Operator $a, Operator $b) {
            // Sort by priority.
            if ($a->getPriority() === $b->getPriority()) {
                // Then by associativity.
                if ($a->getAssociativity() == $b->getAssociativity()) {
                    // Then by regex length (the longer the better).
                    if (strlen($a->getRegex()) === strlen($b->getRegex())) {
                        return 0;
                    }
                    return strlen($a->getRegex()) > strlen($b->getRegex()) ? -1 : 1;
                }
                return $a->getAssociativity() > $b->getAssociativity() ? -1 : 1;
            }
            return $a->getPriority() > $b->getPriority() ? -1 : 1;
        });

        return $list;
    }
167571
static function prioritizedLanguageCodes()
    {
        $languages = eZContentLanguage::prioritizedLanguages();
        $localeList = array();

        foreach ( $languages as $language )
        {
            $localeList[] = $language->attribute( 'locale' );
        }

        return $localeList;
    }
876162
public function toString()
    {
        if ($this->max !== -1) {
            return vsprintf('{length: %d <= x <= %d}', [
                $this->min,
                $this->max,
            ]);
        }

        return vsprintf('{length: %d <= x}', [
            $this->min,
        ]);
    }
350666
public function getSeverityString()
    {
        switch ($this->getSeverity()) {
            case self::SEVERITY_CRITICAL:
                return 'critical';

            case self::SEVERITY_HIGH:
                return 'high';

            case self::SEVERITY_NORMAL:
                return 'normal';

            case self::SEVERITY_LOW:
                return 'low';
        }
    }
1162061
protected function prioritseCandidates()
    {
        $requestParts       = array();

        // Turn numeric request parts into integers
        foreach (explode('/', $this->request->getPathInfo()) as $part) {
            if (is_numeric($part)) {
                $requestParts[] = (int) $part;
            } else {
                $requestParts[] = $part;
            }
        }

        foreach ($this->candidates as $key => $route) {
            $isCandidate    = true;
            $priority       = 0;

            $this->establishPriority(count($route->getRequirements()));

            // Remove from candidates list those Routes that Method does not match Request method
            if (!in_array($this->request->getMethod(), $route->getMethods())) {
                $isCandidate = false;
            }

            $routeParts = explode('/', $route->getPath());

            foreach ($route->getRequirements() as $requirement => $type) {
                $pattern = '{' . $requirement . '}';
                $key = array_search($pattern, $routeParts);
                $part = $routeParts[$key];

                if (preg_match('/^\{\w+\}/', $part)) {
                    if ($type == 'int') {
                        if (is_numeric($requestParts[$key])) {
                            $priority ++;
                        }
                    } elseif ($type == 'str') {
                        if (is_string($requestParts[$key])) {
                            $priority ++;
                        }
                    }
                }

            }

            if ($isCandidate) {
                $this->prioritised[$priority][] = $route;
            }
        }
    }
1212243
public function getPriority()
    {
        if (!isset($this->priority)) {
            $typeToPriority = array(static::CONTEXT_ERROR   => static::PRIORITY_MAX,
                                    static::CONTEXT_WARNING => static::PRIORITY_HIGH,
                                    static::CONTEXT_SUCCESS => static::PRIORITY_MIN,
                                    static::CONTEXT_INFO    => static::PRIORITY_LOW);

            if (array_key_exists($this->context, $typeToPriority)) {
                return $typeToPriority[$this->context];
            }

            return static::PRIORITY_LOW;
        }

        return $this->priority;
    }