类 yii\i18n\Formatter

                public function asBoolean($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return $value ? $this->booleanFormat[1] : $this->booleanFormat[0];
}

            

                public function asCurrency($value, $currency = null, $options = [], $textOptions = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $normalizedValue = $this->normalizeNumericValue($value);
    if ($this->isNormalizedValueMispresented($value, $normalizedValue)) {
        return $this->asCurrencyStringFallback((string) $value, $currency);
    }
    if ($this->_intlLoaded) {
        $currency = $currency ?: $this->currencyCode;
        // currency code must be set before fraction digits
        // https://php.ac.cn/manual/en/numberformatter.formatcurrency.php#114376
        if ($currency && !isset($textOptions[NumberFormatter::CURRENCY_CODE])) {
            $textOptions[NumberFormatter::CURRENCY_CODE] = $currency;
        }
        $formatter = $this->createNumberFormatter(NumberFormatter::CURRENCY, null, $options, $textOptions);
        if ($currency === null) {
            $result = $formatter->format($normalizedValue);
        } else {
            $result = $formatter->formatCurrency($normalizedValue, $currency);
        }
        if ($result === false) {
            throw new InvalidArgumentException('Formatting currency value failed: ' . $formatter->getErrorCode() . ' ' . $formatter->getErrorMessage());
        }
        return $result;
    }
    if ($currency === null) {
        if ($this->currencyCode === null) {
            throw new InvalidConfigException('The default currency code for the formatter is not defined and the php intl extension is not installed which could take the default currency from the locale.');
        }
        $currency = $this->currencyCode;
    }
    return $currency . ' ' . $this->asDecimal($normalizedValue, 2, $options, $textOptions);
}

            

                protected function asCurrencyStringFallback($value, $currency = null)
{
    if ($currency === null) {
        if ($this->currencyCode === null) {
            throw new InvalidConfigException('The default currency code for the formatter is not defined.');
        }
        $currency = $this->currencyCode;
    }
    return $currency . ' ' . $this->asDecimalStringFallback($value, 2);
}

            

                public function asDate($value, $format = null)
{
    if ($format === null) {
        $format = $this->dateFormat;
    }
    return $this->formatDateTimeValue($value, $format, 'date');
}

            

                public function asDatetime($value, $format = null)
{
    if ($format === null) {
        $format = $this->datetimeFormat;
    }
    return $this->formatDateTimeValue($value, $format, 'datetime');
}

            

                public function asDecimal($value, $decimals = null, $options = [], $textOptions = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $normalizedValue = $this->normalizeNumericValue($value);
    if ($this->isNormalizedValueMispresented($value, $normalizedValue)) {
        return $this->asDecimalStringFallback((string) $value, $decimals);
    }
    if ($this->_intlLoaded) {
        $f = $this->createNumberFormatter(NumberFormatter::DECIMAL, $decimals, $options, $textOptions);
        if (($result = $f->format($normalizedValue)) === false) {
            throw new InvalidArgumentException('Formatting decimal value failed: ' . $f->getErrorCode() . ' ' . $f->getErrorMessage());
        }
        return $result;
    }
    if ($decimals === null) {
        $decimals = 2;
    }
    return number_format($normalizedValue, $decimals, $this->decimalSeparator, $this->thousandSeparator);
}

            

                protected function asDecimalStringFallback($value, $decimals = 2)
{
    if (empty($value)) {
        $value = 0;
    }
    $value = $this->normalizeNumericStringValue((string) $value);
    $separatorPosition = strrpos($value, '.');
    if ($separatorPosition !== false) {
        $integerPart = substr($value, 0, $separatorPosition);
        $fractionalPart = substr($value, $separatorPosition + 1);
    } else {
        $integerPart = $value;
        $fractionalPart = null;
    }
    $decimalOutput = '';
    if ($decimals === null) {
        $decimals = 2;
    }
    $carry = 0;
    if ($decimals > 0) {
        $decimalSeparator = $this->decimalSeparator;
        if ($this->decimalSeparator === null) {
            $decimalSeparator = '.';
        }
        if ($fractionalPart === null) {
            $fractionalPart = str_repeat('0', $decimals);
        } elseif (strlen($fractionalPart) > $decimals) {
            $cursor = $decimals;
            // checking if fractional part must be rounded
            if ((int) substr($fractionalPart, $cursor, 1) >= 5) {
                while (--$cursor >= 0) {
                    $carry = 0;
                    $oneUp = (int) substr($fractionalPart, $cursor, 1) + 1;
                    if ($oneUp === 10) {
                        $oneUp = 0;
                        $carry = 1;
                    }
                    $fractionalPart = substr($fractionalPart, 0, $cursor) . $oneUp . substr($fractionalPart, $cursor + 1);
                    if ($carry === 0) {
                        break;
                    }
                }
            }
            $fractionalPart = substr($fractionalPart, 0, $decimals);
        } elseif (strlen($fractionalPart) < $decimals) {
            $fractionalPart = str_pad($fractionalPart, $decimals, '0');
        }
        $decimalOutput .= $decimalSeparator . $fractionalPart;
    }
    // checking if integer part must be rounded
    if ($carry || ($decimals === 0 && $fractionalPart !== null && (int) substr($fractionalPart, 0, 1) >= 5)) {
        $integerPartLength = strlen($integerPart);
        $cursor = 0;
        while (++$cursor <= $integerPartLength) {
            $carry = 0;
            $oneUp = (int) substr($integerPart, -$cursor, 1) + 1;
            if ($oneUp === 10) {
                $oneUp = 0;
                $carry = 1;
            }
            $integerPart = substr($integerPart, 0, -$cursor) . $oneUp . substr($integerPart, $integerPartLength - $cursor + 1);
            if ($carry === 0) {
                break;
            }
        }
        if ($carry === 1) {
            $integerPart = '1' . $integerPart;
        }
    }
    if (strlen($integerPart) > 3) {
        $thousandSeparator = $this->thousandSeparator;
        if ($thousandSeparator === null) {
            $thousandSeparator = ',';
        }
        $integerPart = strrev(implode(',', str_split(strrev($integerPart), 3)));
        if ($thousandSeparator !== ',') {
            $integerPart = str_replace(',', $thousandSeparator, $integerPart);
        }
    }
    return $integerPart . $decimalOutput;
}

            

                public function asDuration($value, $implodeString = ', ', $negativeSign = '-')
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    if ($value instanceof DateInterval) {
        $isNegative = $value->invert;
        $interval = $value;
    } elseif (is_numeric($value)) {
        $isNegative = $value < 0;
        $zeroDateTime = (new DateTime())->setTimestamp(0);
        $valueDateTime = (new DateTime())->setTimestamp(abs($value));
        $interval = $valueDateTime->diff($zeroDateTime);
    } elseif (strncmp($value, 'P-', 2) === 0) {
        $interval = new DateInterval('P' . substr($value, 2));
        $isNegative = true;
    } else {
        $interval = new DateInterval($value);
        $isNegative = $interval->invert;
    }
    $parts = [];
    if ($interval->y > 0) {
        $parts[] = Yii::t('yii', '{delta, plural, =1{1 year} other{# years}}', ['delta' => $interval->y], $this->language);
    }
    if ($interval->m > 0) {
        $parts[] = Yii::t('yii', '{delta, plural, =1{1 month} other{# months}}', ['delta' => $interval->m], $this->language);
    }
    if ($interval->d > 0) {
        $parts[] = Yii::t('yii', '{delta, plural, =1{1 day} other{# days}}', ['delta' => $interval->d], $this->language);
    }
    if ($interval->h > 0) {
        $parts[] = Yii::t('yii', '{delta, plural, =1{1 hour} other{# hours}}', ['delta' => $interval->h], $this->language);
    }
    if ($interval->i > 0) {
        $parts[] = Yii::t('yii', '{delta, plural, =1{1 minute} other{# minutes}}', ['delta' => $interval->i], $this->language);
    }
    if ($interval->s > 0) {
        $parts[] = Yii::t('yii', '{delta, plural, =1{1 second} other{# seconds}}', ['delta' => $interval->s], $this->language);
    }
    if ($interval->s === 0 && empty($parts)) {
        $parts[] = Yii::t('yii', '{delta, plural, =1{1 second} other{# seconds}}', ['delta' => $interval->s], $this->language);
        $isNegative = false;
    }
    return empty($parts) ? $this->nullDisplay : (($isNegative ? $negativeSign : '') . implode($implodeString, $parts));
}

            

                public function asEmail($value, $options = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return Html::mailto(Html::encode($value), $value, $options);
}

            

                public function asHtml($value, $config = null)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return HtmlPurifier::process($value, $config);
}

            

                public function asImage($value, $options = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return Html::img($value, $options);
}

            

                public function asInteger($value, $options = [], $textOptions = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $normalizedValue = $this->normalizeNumericValue($value);
    if ($this->isNormalizedValueMispresented($value, $normalizedValue)) {
        return $this->asIntegerStringFallback((string) $value);
    }
    if ($this->_intlLoaded) {
        $f = $this->createNumberFormatter(NumberFormatter::DECIMAL, null, $options, $textOptions);
        $f->setAttribute(NumberFormatter::FRACTION_DIGITS, 0);
        if (($result = $f->format($normalizedValue, NumberFormatter::TYPE_INT64)) === false) {
            throw new InvalidArgumentException('Formatting integer value failed: ' . $f->getErrorCode() . ' ' . $f->getErrorMessage());
        }
        return $result;
    }
    return number_format((int) $normalizedValue, 0, $this->decimalSeparator, $this->thousandSeparator);
}

            

                protected function asIntegerStringFallback($value)
{
    if (empty($value)) {
        $value = 0;
    }
    $value = $this->normalizeNumericStringValue((string) $value);
    $separatorPosition = strrpos($value, '.');
    if ($separatorPosition !== false) {
        $integerPart = substr($value, 0, $separatorPosition);
    } else {
        $integerPart = $value;
    }
    return $this->asDecimalStringFallback($integerPart, 0);
}

            

                public function asLength($value, $decimals = null, $numberOptions = [], $textOptions = [])
{
    return $this->formatUnit(self::UNIT_LENGTH, self::FORMAT_WIDTH_LONG, $value, $decimals, $numberOptions, $textOptions);
}

            

                public function asNtext($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return nl2br(Html::encode($value));
}

            

                public function asOrdinal($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $value = $this->normalizeNumericValue($value);
    if ($this->_intlLoaded) {
        $f = $this->createNumberFormatter(NumberFormatter::ORDINAL);
        if (($result = $f->format($value)) === false) {
            throw new InvalidArgumentException('Formatting number as ordinal failed: ' . $f->getErrorCode() . ' ' . $f->getErrorMessage());
        }
        return $result;
    }
    throw new InvalidConfigException('Format as Ordinal is only supported when PHP intl extension is installed.');
}

            

                public function asParagraphs($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return str_replace('<p></p>', '', '<p>' . preg_replace('/\R{2,}/u', "</p>\n<p>", Html::encode($value)) . '</p>');
}

            

                public function asPercent($value, $decimals = null, $options = [], $textOptions = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $normalizedValue = $this->normalizeNumericValue($value);
    if ($this->isNormalizedValueMispresented($value, $normalizedValue)) {
        return $this->asPercentStringFallback((string) $value, $decimals);
    }
    if ($this->_intlLoaded) {
        $f = $this->createNumberFormatter(NumberFormatter::PERCENT, $decimals, $options, $textOptions);
        if (($result = $f->format($normalizedValue)) === false) {
            throw new InvalidArgumentException('Formatting percent value failed: ' . $f->getErrorCode() . ' ' . $f->getErrorMessage());
        }
        return $result;
    }
    if ($decimals === null) {
        $decimals = 0;
    }
    $normalizedValue *= 100;
    return number_format($normalizedValue, $decimals, $this->decimalSeparator, $this->thousandSeparator) . '%';
}

            

                protected function asPercentStringFallback($value, $decimals = null)
{
    if (empty($value)) {
        $value = 0;
    }
    if ($decimals === null) {
        $decimals = 0;
    }
    $value = $this->normalizeNumericStringValue((string) $value);
    $separatorPosition = strrpos($value, '.');
    if ($separatorPosition !== false) {
        $integerPart = substr($value, 0, $separatorPosition);
        $fractionalPart = str_pad(substr($value, $separatorPosition + 1), 2, '0');
        $integerPart .= substr($fractionalPart, 0, 2);
        $fractionalPart = substr($fractionalPart, 2);
        if ($fractionalPart === '') {
            $multipliedValue = $integerPart;
        } else {
            $multipliedValue = $integerPart . '.' . $fractionalPart;
        }
    } else {
        $multipliedValue = $value . '00';
    }
    return $this->asDecimalStringFallback($multipliedValue, $decimals) . '%';
}

            

                public function asRaw($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return $value;
}

            

                public function asRelativeTime($value, $referenceTime = null)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    if ($value instanceof DateInterval) {
        $interval = $value;
    } else {
        $timestamp = $this->normalizeDatetimeValue($value);
        $timeZone = new DateTimeZone($this->timeZone);
        if ($referenceTime === null) {
            $dateNow = new DateTime('now', $timeZone);
        } else {
            $dateNow = $this->normalizeDatetimeValue($referenceTime);
            $dateNow->setTimezone($timeZone);
        }
        $dateThen = $timestamp->setTimezone($timeZone);
        $interval = $dateThen->diff($dateNow);
    }
    if ($interval->invert) {
        if ($interval->y >= 1) {
            return Yii::t('yii', 'in {delta, plural, =1{a year} other{# years}}', ['delta' => $interval->y], $this->language);
        }
        if ($interval->m >= 1) {
            return Yii::t('yii', 'in {delta, plural, =1{a month} other{# months}}', ['delta' => $interval->m], $this->language);
        }
        if ($interval->d >= 1) {
            return Yii::t('yii', 'in {delta, plural, =1{a day} other{# days}}', ['delta' => $interval->d], $this->language);
        }
        if ($interval->h >= 1) {
            return Yii::t('yii', 'in {delta, plural, =1{an hour} other{# hours}}', ['delta' => $interval->h], $this->language);
        }
        if ($interval->i >= 1) {
            return Yii::t('yii', 'in {delta, plural, =1{a minute} other{# minutes}}', ['delta' => $interval->i], $this->language);
        }
        if ($interval->s == 0) {
            return Yii::t('yii', 'just now', [], $this->language);
        }
        return Yii::t('yii', 'in {delta, plural, =1{a second} other{# seconds}}', ['delta' => $interval->s], $this->language);
    }
    if ($interval->y >= 1) {
        return Yii::t('yii', '{delta, plural, =1{a year} other{# years}} ago', ['delta' => $interval->y], $this->language);
    }
    if ($interval->m >= 1) {
        return Yii::t('yii', '{delta, plural, =1{a month} other{# months}} ago', ['delta' => $interval->m], $this->language);
    }
    if ($interval->d >= 1) {
        return Yii::t('yii', '{delta, plural, =1{a day} other{# days}} ago', ['delta' => $interval->d], $this->language);
    }
    if ($interval->h >= 1) {
        return Yii::t('yii', '{delta, plural, =1{an hour} other{# hours}} ago', ['delta' => $interval->h], $this->language);
    }
    if ($interval->i >= 1) {
        return Yii::t('yii', '{delta, plural, =1{a minute} other{# minutes}} ago', ['delta' => $interval->i], $this->language);
    }
    if ($interval->s == 0) {
        return Yii::t('yii', 'just now', [], $this->language);
    }
    return Yii::t('yii', '{delta, plural, =1{a second} other{# seconds}} ago', ['delta' => $interval->s], $this->language);
}

            

                public function asScientific($value, $decimals = null, $options = [], $textOptions = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $value = $this->normalizeNumericValue($value);
    if ($this->_intlLoaded) {
        $f = $this->createNumberFormatter(NumberFormatter::SCIENTIFIC, $decimals, $options, $textOptions);
        if (($result = $f->format($value)) === false) {
            throw new InvalidArgumentException('Formatting scientific number value failed: ' . $f->getErrorCode() . ' ' . $f->getErrorMessage());
        }
        return $result;
    }
    if ($decimals !== null) {
        return sprintf("%.{$decimals}E", $value);
    }
    return sprintf('%.E', $value);
}

            

                public function asShortLength($value, $decimals = null, $options = [], $textOptions = [])
{
    return $this->formatUnit(self::UNIT_LENGTH, self::FORMAT_WIDTH_SHORT, $value, $decimals, $options, $textOptions);
}

            

                public function asShortSize($value, $decimals = null, $options = [], $textOptions = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    list($params, $position) = $this->formatNumber($value, $decimals, 4, $this->sizeFormatBase, $options, $textOptions);
    if ($this->sizeFormatBase == 1024) {
        switch ($position) {
            case 0:
                return Yii::t('yii', '{nFormatted} B', $params, $this->language);
            case 1:
                return Yii::t('yii', '{nFormatted} KiB', $params, $this->language);
            case 2:
                return Yii::t('yii', '{nFormatted} MiB', $params, $this->language);
            case 3:
                return Yii::t('yii', '{nFormatted} GiB', $params, $this->language);
            case 4:
                return Yii::t('yii', '{nFormatted} TiB', $params, $this->language);
            default:
                return Yii::t('yii', '{nFormatted} PiB', $params, $this->language);
        }
    } else {
        switch ($position) {
            case 0:
                return Yii::t('yii', '{nFormatted} B', $params, $this->language);
            case 1:
                return Yii::t('yii', '{nFormatted} kB', $params, $this->language);
            case 2:
                return Yii::t('yii', '{nFormatted} MB', $params, $this->language);
            case 3:
                return Yii::t('yii', '{nFormatted} GB', $params, $this->language);
            case 4:
                return Yii::t('yii', '{nFormatted} TB', $params, $this->language);
            default:
                return Yii::t('yii', '{nFormatted} PB', $params, $this->language);
        }
    }
}

            

                public function asShortWeight($value, $decimals = null, $options = [], $textOptions = [])
{
    return $this->formatUnit(self::UNIT_WEIGHT, self::FORMAT_WIDTH_SHORT, $value, $decimals, $options, $textOptions);
}

            

                public function asSize($value, $decimals = null, $options = [], $textOptions = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    list($params, $position) = $this->formatNumber($value, $decimals, 4, $this->sizeFormatBase, $options, $textOptions);
    if ($this->sizeFormatBase == 1024) {
        switch ($position) {
            case 0:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{byte} other{bytes}}', $params, $this->language);
            case 1:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{kibibyte} other{kibibytes}}', $params, $this->language);
            case 2:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{mebibyte} other{mebibytes}}', $params, $this->language);
            case 3:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{gibibyte} other{gibibytes}}', $params, $this->language);
            case 4:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{tebibyte} other{tebibytes}}', $params, $this->language);
            default:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{pebibyte} other{pebibytes}}', $params, $this->language);
        }
    } else {
        switch ($position) {
            case 0:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{byte} other{bytes}}', $params, $this->language);
            case 1:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{kilobyte} other{kilobytes}}', $params, $this->language);
            case 2:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{megabyte} other{megabytes}}', $params, $this->language);
            case 3:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{gigabyte} other{gigabytes}}', $params, $this->language);
            case 4:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{terabyte} other{terabytes}}', $params, $this->language);
            default:
                return Yii::t('yii', '{nFormatted} {n, plural, =1{petabyte} other{petabytes}}', $params, $this->language);
        }
    }
}

            

                public function asSpellout($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $value = $this->normalizeNumericValue($value);
    if ($this->_intlLoaded) {
        $f = $this->createNumberFormatter(NumberFormatter::SPELLOUT);
        if (($result = $f->format($value)) === false) {
            throw new InvalidArgumentException('Formatting number as spellout failed: ' . $f->getErrorCode() . ' ' . $f->getErrorMessage());
        }
        return $result;
    }
    throw new InvalidConfigException('Format as Spellout is only supported when PHP intl extension is installed.');
}

            

                public function asText($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    return Html::encode($value);
}

            

                public function asTime($value, $format = null)
{
    if ($format === null) {
        $format = $this->timeFormat;
    }
    return $this->formatDateTimeValue($value, $format, 'time');
}

            

                public function asTimestamp($value)
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $timestamp = $this->normalizeDatetimeValue($value);
    return number_format($timestamp->format('U'), 0, '.', '');
}

            

                public function asUrl($value, $options = [])
{
    if ($value === null) {
        return $this->nullDisplay;
    }
    $url = $value;
    $scheme = ArrayHelper::remove($options, 'scheme');
    if ($scheme === null) {
        if (strpos($url, '://') === false) {
            $url = 'http://' . $url;
        }
    } else {
        $url = Url::ensureScheme($url, $scheme);
    }
    return Html::a(Html::encode($value), $url, $options);
}

            

                public function asWeight($value, $decimals = null, $options = [], $textOptions = [])
{
    return $this->formatUnit(self::UNIT_WEIGHT, self::FORMAT_WIDTH_LONG, $value, $decimals, $options, $textOptions);
}

            

                protected function createNumberFormatter($style, $decimals = null, $options = [], $textOptions = [])
{
    $formatter = new NumberFormatter($this->locale, $style);
    // set text attributes
    foreach ($this->numberFormatterTextOptions as $attribute => $value) {
        $this->setFormatterTextAttribute($formatter, $attribute, $value, 'numberFormatterTextOptions', 'numberFormatterOptions');
    }
    foreach ($textOptions as $attribute => $value) {
        $this->setFormatterTextAttribute($formatter, $attribute, $value, '$textOptions', '$options');
    }
    // set attributes
    foreach ($this->numberFormatterOptions as $attribute => $value) {
        $this->setFormatterIntAttribute($formatter, $attribute, $value, 'numberFormatterOptions', 'numberFormatterTextOptions');
    }
    foreach ($options as $attribute => $value) {
        $this->setFormatterIntAttribute($formatter, $attribute, $value, '$options', '$textOptions');
    }
    if ($decimals !== null) {
        $formatter->setAttribute(NumberFormatter::MAX_FRACTION_DIGITS, $decimals);
        $formatter->setAttribute(NumberFormatter::MIN_FRACTION_DIGITS, $decimals);
    }
    // set symbols
    if ($this->decimalSeparator !== null) {
        $formatter->setSymbol(NumberFormatter::DECIMAL_SEPARATOR_SYMBOL, $this->decimalSeparator);
    }
    if ($this->currencyDecimalSeparator !== null) {
        $formatter->setSymbol(NumberFormatter::MONETARY_SEPARATOR_SYMBOL, $this->currencyDecimalSeparator);
    }
    if ($this->thousandSeparator !== null) {
        $formatter->setSymbol(NumberFormatter::GROUPING_SEPARATOR_SYMBOL, $this->thousandSeparator);
        $formatter->setSymbol(NumberFormatter::MONETARY_GROUPING_SEPARATOR_SYMBOL, $this->thousandSeparator);
    }
    foreach ($this->numberFormatterSymbols as $symbol => $value) {
        $this->setFormatterSymbol($formatter, $symbol, $value, 'numberFormatterSymbols');
    }
    return $formatter;
}

            

                public function format($value, $format)
{
    if ($format instanceof Closure) {
        return $format($value, $this);
    }
    if (is_array($format)) {
        if (!isset($format[0])) {
            throw new InvalidArgumentException('The $format array must contain at least one element.');
        }
        $f = $format[0];
        $format[0] = $value;
        $params = $format;
        $format = $f;
    } else {
        $params = [$value];
    }
    $method = 'as' . $format;
    if ($this->hasMethod($method)) {
        return call_user_func_array([$this, $method], array_values($params));
    }
    throw new InvalidArgumentException("Unknown format type: $format");
}

            

                protected function formatNumber($value, $decimals, $maxPosition, $formatBase, $options, $textOptions)
{
    $value = $this->normalizeNumericValue($value);
    $position = 0;
    if (is_array($formatBase)) {
        $maxPosition = count($formatBase) - 1;
    }
    do {
        if (is_array($formatBase)) {
            if (!isset($formatBase[$position + 1])) {
                break;
            }
            if (abs($value) < $formatBase[$position + 1]) {
                break;
            }
        } else {
            if (abs($value) < $formatBase) {
                break;
            }
            $value /= $formatBase;
        }
        $position++;
    } while ($position < $maxPosition + 1);
    if (is_array($formatBase) && $position !== 0) {
        $value /= $formatBase[$position];
    }
    // no decimals for smallest unit
    if ($position === 0) {
        $decimals = 0;
    } elseif ($decimals !== null) {
        $value = round($value, $decimals);
    }
    // disable grouping for edge cases like 1023 to get 1023 B instead of 1,023 B
    $oldThousandSeparator = $this->thousandSeparator;
    $this->thousandSeparator = '';
    if ($this->_intlLoaded && !isset($options[NumberFormatter::GROUPING_USED])) {
        $options[NumberFormatter::GROUPING_USED] = 0;
    }
    // format the size value
    $params = [
        // this is the unformatted number used for the plural rule
        // abs() to make sure the plural rules work correctly on negative numbers, intl does not cover this
        // https://english.stackexchange.com/questions/9735/is-1-followed-by-a-singular-or-plural-noun
        'n' => abs($value),
        // this is the formatted number used for display
        'nFormatted' => $this->asDecimal($value, $decimals, $options, $textOptions),
    ];
    $this->thousandSeparator = $oldThousandSeparator;
    return [$params, $position];
}

            

                public function init()
{
    if ($this->timeZone === null) {
        $this->timeZone = Yii::$app->timeZone;
    }
    if ($this->locale === null) {
        $this->locale = Yii::$app->language;
    }
    if ($this->language === null) {
        $this->language = strtok($this->locale, '@');
    }
    if ($this->booleanFormat === null) {
        $this->booleanFormat = [Yii::t('yii', 'No', [], $this->language), Yii::t('yii', 'Yes', [], $this->language)];
    }
    if ($this->nullDisplay === null) {
        $this->nullDisplay = '<span class="not-set">' . Yii::t('yii', '(not set)', [], $this->language) . '</span>';
    }
    $this->_intlLoaded = extension_loaded('intl');
    if (!$this->_intlLoaded) {
        if ($this->decimalSeparator === null) {
            $this->decimalSeparator = '.';
        }
        if ($this->thousandSeparator === null) {
            $this->thousandSeparator = ',';
        }
    }
}

            

                protected function isNormalizedValueMispresented($value, $normalizedValue)
{
    if (empty($value)) {
        $value = 0;
    }
    return (string) $normalizedValue !== $this->normalizeNumericStringValue((string) $value);
}

            

                protected function normalizeDatetimeValue($value, $checkDateTimeInfo = false)
{
    // checking for DateTime and DateTimeInterface is not redundant, DateTimeInterface is only in PHP>5.5
    if ($value === null || $value instanceof DateTime || $value instanceof DateTimeInterface) {
        // skip any processing
        return $checkDateTimeInfo ? [$value, true, true] : $value;
    }
    if (empty($value)) {
        $value = 0;
    }
    try {
        if (is_numeric($value)) { // process as unix timestamp, which is always in UTC
            $timestamp = new DateTime('@' . (int) $value, new DateTimeZone('UTC'));
            return $checkDateTimeInfo ? [$timestamp, true, true] : $timestamp;
        }
        if (
            ($timestamp = DateTime::createFromFormat(
                'Y-m-d|',
                $value,
                new DateTimeZone($this->defaultTimeZone)
            )
            ) !== false
        ) { // try Y-m-d format (support invalid dates like 2012-13-01)
            return $checkDateTimeInfo ? [$timestamp, false, true] : $timestamp;
        }
        if (
            ($timestamp = DateTime::createFromFormat(
                'Y-m-d H:i:s',
                $value,
                new DateTimeZone($this->defaultTimeZone)
            )
            ) !== false
        ) { // try Y-m-d H:i:s format (support invalid dates like 2012-13-01 12:63:12)
            return $checkDateTimeInfo ? [$timestamp, true, true] : $timestamp;
        }
        // finally try to create a DateTime object with the value
        if ($checkDateTimeInfo) {
            $timestamp = new DateTime($value, new DateTimeZone($this->defaultTimeZone));
            $info = date_parse($value);
            return [
                $timestamp,
                !($info['hour'] === false && $info['minute'] === false && $info['second'] === false),
                !($info['year'] === false && $info['month'] === false && $info['day'] === false && empty($info['zone'])),
            ];
        }
        return new DateTime($value, new DateTimeZone($this->defaultTimeZone));
    } catch (\Exception $e) {
        throw new InvalidArgumentException("'$value' is not a valid date time value: " . $e->getMessage()
            . "\n" . print_r(DateTime::getLastErrors(), true), $e->getCode(), $e);
    }
}

            

                protected function normalizeNumericStringValue($value)
{
    $powerPosition = strrpos($value, 'E');
    if ($powerPosition !== false) {
        $valuePart = substr($value, 0, $powerPosition);
        $powerPart = substr($value, $powerPosition + 1);
    } else {
        $powerPart = null;
        $valuePart = $value;
    }
    $separatorPosition = strrpos($valuePart, '.');
    if ($separatorPosition !== false) {
        $integerPart = substr($valuePart, 0, $separatorPosition);
        $fractionalPart = substr($valuePart, $separatorPosition + 1);
    } else {
        $integerPart = $valuePart;
        $fractionalPart = null;
    }
    // truncate insignificant zeros, keep minus
    $integerPart = preg_replace('/^\+?(-?)0*(\d+)$/', '$1$2', $integerPart);
    // for zeros only leave one zero, keep minus
    $integerPart = preg_replace('/^\+?(-?)0*$/', '${1}0', $integerPart);
    if ($fractionalPart !== null) {
        // truncate insignificant zeros
        $fractionalPart = rtrim($fractionalPart, '0');
        if (empty($fractionalPart)) {
            $fractionalPart = $powerPart !== null ? '0' : null;
        }
    }
    $normalizedValue = $integerPart;
    if ($fractionalPart !== null) {
        $normalizedValue .= '.' . $fractionalPart;
    } elseif ($normalizedValue === '-0') {
        $normalizedValue = '0';
    }
    if ($powerPart !== null) {
        $normalizedValue .= 'E' . $powerPart;
    }
    return $normalizedValue;
}

            

                protected function normalizeNumericValue($value)
{
    if (empty($value)) {
        return 0;
    }
    if (is_string($value) && is_numeric($value)) {
        $value = (float) $value;
    }
    if (!is_numeric($value)) {
        throw new InvalidArgumentException("'$value' is not a numeric value.");
    }
    return $value;
}