1. sfNumberFormat.class.php
  2. /**
 * sfNumberFormat class.
 * 
 * sfNumberFormat formats decimal numbers in any locale. The decimal
 * number is formatted according to a particular pattern. These
 * patterns can arise from the sfNumberFormatInfo object which is
 * culturally sensitive. The sfNumberFormat class can be instantiated in
 * many ways. E.g.
 *
 * 
 *  //create a invariant number formatter.
 *  $formatter = new sfNumberFormat();
 * 
 *  //create a number format for the french language locale.
 *  $fr = new sfNumberFormat('fr');
 *
 *  //create a number format base on a sfNumberFormatInfo instance $numberInfo.
 *  $format = new sfNumberFormat($numberInfo);
 * 
 *
 * A normal decimal number can also be displayed as a currency 
 * or as a percentage. For example
 * 
 * $format->format(1234.5); //Decimal number "1234.5"
 * $format->format(1234.5,'c'); //Default currency "$1234.50"
 * $format->format(0.25, 'p') //Percent "25%"
 * 
 *
 * Currency is formated using the localized currency pattern. For example
 * to format the number as Japanese Yen:
 * 
 *  $ja = new sfNumberFormat('ja_JP');
 * 
 *  //Japanese currency pattern, and using Japanese Yen symbol
 *  $ja->format(123.14,'c','JPY'); //ï¿?123 (Yen 123)
 * 
 * For each culture, the symbol for each currency may be different.
 * 
 * @author Xiang Wei Zhuo 
 * @version v1.0, last update on Fri Dec 10 18:10:20 EST 2004
 * @package    symfony
 * @subpackage i18n
 */
  3. class sfNumberFormat
  4. {
  5.   /**
  6.    * The DateTimeFormatInfo, containing culture specific patterns and names.
  7.    * @var DateTimeFormatInfo
  8.    */
  9.   protected $formatInfo;
  11.   /**
  12.    * Creates a new number format instance. The constructor can be instantiated
  13.    * with a string that represent a culture/locale. Similarly, passing
  14.    * a sfCultureInfo or sfNumberFormatInfo instance will instantiated a instance
  15.    * for that particular culture.
  16.    *
  17.    * @param mixed $formatInfo either null, a sfCultureInfo, a sfNumberFormatInfo, or string
  18.    * @return sfNumberFormat
  19.    */
  20.   function __construct($formatInfo = null)
  21.   {
  22.     if (null === $formatInfo)
  23.     {
  24.       $this->formatInfo = sfNumberFormatInfo::getInvariantInfo();
  25.     }
  26.     else if ($formatInfo instanceof sfCultureInfo)
  27.     {
  28.       $this->formatInfo = $formatInfo->sfNumberFormat;
  29.     }
  30.     else if ($formatInfo instanceof sfNumberFormatInfo)
  31.     {
  32.       $this->formatInfo = $formatInfo;
  33.     }
  34.     else
  35.     {
  36.       $this->formatInfo = sfNumberFormatInfo::getInstance($formatInfo);
  37.     }
  38.   }
  40.   /**
  41.    * Formats the number for a certain pattern. The valid patterns are
  42.    * 'c', 'd', 'e', 'p' or a custom pattern, such as "#.000" for
  43.    * 3 decimal places.
  44.    *
  45.    * @param mixed   $number   the number to format.
  46.    * @param string  $pattern  the format pattern, either, 'c', 'd', 'e', 'p'
  47.    * or a custom pattern. E.g. "#.000" will format the number to 
  48.    * 3 decimal places.
  49.    * @param string  $currency 3-letter ISO 4217 code. For example, the code 
  50.    * "USD" represents the US Dollar and "EUR" represents the Euro currency.
  51.    * @param string  $charset  The charset
  52.    * @return string formatted number string 
  53.    */
  54.   function format($number, $pattern = 'd', $currency = 'USD', $charset = 'UTF-8')
  55.   {
  56.     $this->setPattern($pattern);
  58.     if (strtolower($pattern) == 'p')
  59.     {
  60.       $number = $number * 100;
  61.     }
  63.     // avoid conversion with exponents
  64.     // see http://trac.symfony-project.org/ticket/5715
  65.     $precision = ini_set('precision', 14);
  66.     $string = $this->fixFloat($number);
  67.     ini_set('precision', $precision);
  69.     $decimal = $this->formatDecimal($string);
  70.     $integer = $this->formatInteger($this->fixFloat(abs($number)));
  72.     $result = (strlen($decimal) > 0) ? $integer.$decimal : $integer;
  74.     // get the suffix
  75.     if ($number >= 0)
  76.     {
  77.       $suffix = $this->formatInfo->PositivePattern;
  78.     }
  79.     else if ($number < 0)
  80.     {
  81.       $suffix = $this->formatInfo->NegativePattern;
  82.     }
  83.     else
  84.     {
  85.       $suffix = array('', '');
  86.     }
  88.     // append and prepend suffix
  89.     $result = $suffix[0].$result.$suffix[1];
  91.     // replace currency sign
  92.     $symbol = @$this->formatInfo->getCurrencySymbol($currency);
  93.     if (null === $symbol)
  94.     {
  95.       $symbol = $currency;
  96.     }
  98.     $result = str_replace('¤', $symbol, $result);
  100.     return sfToolkit::I18N_toEncoding($result, $charset);
  101.   }
  103.   /**
  104.    * Formats the integer, perform groupings and string padding.
  105.    *
  106.    * @param string  $string the decimal number in string form.
  107.    * @return string  formatted integer string with grouping
  108.    */
  109.   protected function formatInteger($string)
  110.   {
  111.     $string = (string) $string;
  113.     $dp = strpos($string, '.');
  115.     if (is_int($dp))
  116.     {
  117.       $string = substr($string, 0, $dp);
  118.     }
  120.     $integer = '';
  122.     $digitSize = $this->formatInfo->getDigitSize();
  123.     $string = str_pad($string, $digitSize, '0', STR_PAD_LEFT);
  125.     $len = strlen($string);
  127.     $groupSeparator = $this->formatInfo->GroupSeparator;
  128.     $groupSize = $this->formatInfo->GroupSizes;
  130.     $firstGroup = true;
  131.     $multiGroup = is_int($groupSize[1]);
  132.     $count = 0;
  134.     if (is_int($groupSize[0]))
  135.     {
  136.       // now for the integer groupings
  137.       for ($i = 0; $i < $len; $i++)
  138.       {
  139.         $char = $string{$len - $i - 1};
  141.         if ($multiGroup && $count == 0)
  142.         {
  143.           if ($i != 0 && $i % $groupSize[0] == 0)
  144.           {
  145.             $integer = $groupSeparator.$integer;
  146.             $count++;
  147.           }
  148.         }
  149.         else if ($multiGroup && $count >= 1)
  150.         {
  151.           if ($i != 0 && ($i - $groupSize[0]) % $groupSize[1] == 0)
  152.           {
  153.             $integer = $groupSeparator.$integer;
  154.             $count++;
  155.           }
  156.         }
  157.         else
  158.         {
  159.           if ($i != 0 && $i % $groupSize[0] == 0)
  160.           {
  161.             $integer = $groupSeparator.$integer;
  162.             $count++;
  163.           }
  164.         }
  166.         $integer = $char.$integer;
  167.       }
  168.     }
  169.     else
  170.     {
  171.       $integer = $string;
  172.     }
  174.     return $integer;
  175.   }
  177.   /**
  178.    * Formats the decimal places.
  179.    *
  180.    * @param string $string the decimal number in string form.
  181.    * @return string formatted decimal places.
  182.    */
  183.   protected function formatDecimal($string)
  184.   {
  185.     $dp = strpos($string, '.');
  186.     $decimal = '';
  188.     $decimalDigits = $this->formatInfo->DecimalDigits;
  189.     $decimalSeparator = $this->formatInfo->DecimalSeparator;
  191.     if (is_int($dp))
  192.     {
  193.       if ($decimalDigits == -1)
  194.       {
  195.         $decimal = substr($string, $dp + 1);
  196.       }
  197.       else if (is_int($decimalDigits))
  198.       {
  199.         if (false === $pos = strpos($string, '.'))
  200.         {
  201.           $decimal = str_pad($decimal, $decimalDigits, '0');
  202.         }
  203.         else
  204.         {
  205.           $decimal = substr($string, $pos + 1);
  206.           if (strlen($decimal) <= $decimalDigits)
  207.           {
  208.             $decimal = str_pad($decimal, $decimalDigits, '0');
  209.           }
  210.           else
  211.           {
  212.             $decimal = substr($decimal, 0, $decimalDigits);
  213.           }
  214.         }
  215.       }
  216.       else
  217.       {
  218.         return $decimal;
  219.       }
  221.       return $decimalSeparator.$decimal;
  222.     }
  223.     else if ($decimalDigits > 0)
  224.     {
  225.       return $decimalSeparator.str_pad($decimal, $decimalDigits, '0');
  226.     }
  228.     return $decimal;
  229.   }
  231.   /**
  232.    * Sets the pattern to format against. The default patterns
  233.    * are retrieved from the sfNumberFormatInfo instance.
  234.    *
  235.    * @param string $pattern the requested patterns.
  236.    * @return string a number format pattern.
  237.    */
  238.   protected function setPattern($pattern)
  239.   {
  240.     switch ($pattern)
  241.     {
  242.       case 'c':
  243.       case 'C':
  244.         $this->formatInfo->setPattern(sfNumberFormatInfo::CURRENCY);
  245.         break;
  246.       case 'd':
  247.       case 'D':
  248.         $this->formatInfo->setPattern(sfNumberFormatInfo::DECIMAL);
  249.         break;
  250.       case 'e':
  251.       case 'E':
  252.         $this->formatInfo->setPattern(sfNumberFormatInfo::SCIENTIFIC);
  253.         break;
  254.       case 'p':
  255.       case 'P':
  256.         $this->formatInfo->setPattern(sfNumberFormatInfo::PERCENTAGE);
  257.         break;
  258.       default:
  259.         $this->formatInfo->setPattern($pattern);
  260.         break;
  261.     }
  262.   }
  264.   protected function fixFloat($float)
  265.   {
  266.     $string = (string) $float;
  268.     if (false === strstr($float, 'E'))
  269.     {
  270.       return $string;
  271.     }
  273.     list($significand, $exp) = explode('E', $string);
  274.     list(, $decimal) = explode('.', $significand);
  275.     $exp = str_replace('+', '', $exp) - strlen($decimal);
  277.     return str_replace('.', '', $significand).str_repeat('0', $exp);
  278.   }
  279. }
Debug toolbar