1. sfCultureInfo.class.php
  2. /**
 * sfCultureInfo class.
 *
 * Represents information about a specific culture including the
 * names of the culture, the calendar used, as well as access to
 * culture-specific objects that provide methods for common operations,
 * such as formatting dates, numbers, and currency.
 *
 * The sfCultureInfo class holds culture-specific information, such as the
 * associated language, sublanguage, country/region, calendar, and cultural
 * conventions. This class also provides access to culture-specific
 * instances of sfDateTimeFormatInfo and sfNumberFormatInfo. These objects
 * contain the information required for culture-specific operations,
 * such as formatting dates, numbers and currency.
 *
 * The culture names follow the format "_",
 * where  is a lowercase two-letter code derived from ISO 639
 * codes. You can find a full list of the ISO-639 codes at
 * http://www.ics.uci.edu/pub/ietf/http/related/iso639.txt
 *
 * The  is an uppercase two-letter code derived from
 * ISO 3166. A copy of ISO-3166 can be found at
 * http://www.chemie.fu-berlin.de/diverse/doc/ISO_3166.html
 *
 * For example, Australian English is "en_AU".
 *
 * @author Xiang Wei Zhuo 
 * @version v1.0, last update on Sat Dec 04 13:41:46 EST 2004
 * @package    symfony
 * @subpackage i18n
 */
  3. class sfCultureInfo
  4. {
  5.   /**
  6.    * ICU data filename extension.
  7.    * @var string
  8.    */
  9.   protected $dataFileExt = '.dat';
  11.   /**
  12.    * The ICU data array.
  13.    * @var array
  14.    */
  15.   protected $data = array();
  17.   /**
  18.    * The current culture.
  19.    * @var string
  20.    */
  21.   protected $culture;
  23.   /**
  24.    * Directory where the ICU data is stored.
  25.    * @var string
  26.    */
  27.   protected $dataDir;
  29.   /**
  30.    * A list of ICU date files loaded.
  31.    * @var array
  32.    */
  33.   protected $dataFiles = array();
  35.   /**
  36.    * The current date time format info.
  37.    * @var sfDateTimeFormatInfo
  38.    */
  39.   protected $dateTimeFormat;
  41.   /**
  42.    * The current number format info.
  43.    * @var sfNumberFormatInfo
  44.    */
  45.   protected $numberFormat;
  46.   
  47.   /**
  48.    * A list of properties that are accessable/writable.
  49.    * @var array
  50.    */ 
  51.   protected $properties = array();
  53.   /**
  54.    * Culture type, all.
  55.    * @see getCultures()
  56.    * @var int
  57.    */
  58.   const ALL = 0;
  60.   /**
  61.    * Culture type, neutral.
  62.    * @see getCultures()
  63.    * @var int
  64.    */
  65.   const NEUTRAL = 1;
  67.   /**
  68.    * Culture type, specific.
  69.    *
  70.    * @see getCultures()
  71.    * @var int
  72.    */
  73.   const SPECIFIC = 2;
  75.   /**
  76.    * Gets the sfCultureInfo that for this culture string.
  77.    *
  78.    * @param string  $culture The culture for this instance
  79.    * @return sfCultureInfo Invariant culture info is "en"
  80.    */
  81.   public static function getInstance($culture = 'en')
  82.   {
  83.     static $instances = array();
  85.     if (!isset($instances[$culture]))
  86.     {
  87.       $instances[$culture] = new sfCultureInfo($culture);
  88.     }
  90.     return $instances[$culture];
  91.   }
  93.   /**
  94.    * Displays the culture name.
  95.    *
  96.    * @return string the culture name.
  97.    * @see getName()
  98.    */
  99.   public function __toString()
  100.   {
  101.     return $this->getName();
  102.   }
  104.   /**
  105.    * Allows functions that begins with 'set' to be called directly
  106.    * as an attribute/property to retrieve the value.
  107.    *
  108.    * @param string $name The property to get
  109.    * @return mixed
  110.    */
  111.   public function __get($name)
  112.   {
  113.     $getProperty = 'get'.$name;
  114.     if (in_array($getProperty, $this->properties))
  115.     {
  116.       return $this->$getProperty();
  117.     }
  118.     else
  119.     {
  120.       throw new sfException(sprintf('Property %s does not exists.', $name));
  121.     }
  122.   }
  124.   /**
  125.    * Allows functions that begins with 'set' to be called directly
  126.    * as an attribute/property to set the value.
  127.    *
  128.    * @param string $name  The property to set
  129.    * @param string $value The property value
  130.    */
  131.   public function __set($name, $value)
  132.   {
  133.     $setProperty = 'set'.$name;
  134.     if (in_array($setProperty, $this->properties))
  135.     {
  136.       $this->$setProperty($value);
  137.     }
  138.     else
  139.     {
  140.       throw new sfException(sprintf('Property %s can not be set.', $name));
  141.     }
  142.   }
  144.   /**
  145.    * Initializes a new instance of the sfCultureInfo class based on the 
  146.    * culture specified by name. E.g. <code>new sfCultureInfo('en_AU');</code>
  147.    * The culture indentifier must be of the form 
  148.    * "<language>_(country/region/variant)".
  149.    *
  150.    * @param string $culture a culture name, e.g. "en_AU".
  151.    * @return return new sfCultureInfo.
  152.    */
  153.   public function __construct($culture = 'en')
  154.   {
  155.     $this->properties = get_class_methods($this);
  157.     if (empty($culture))
  158.     {
  159.       $culture = 'en';
  160.     }
  162.     $this->dataDir = self::dataDir();
  163.     $this->dataFileExt = self::fileExt();
  165.     $this->setCulture($culture);
  167.     $this->loadCultureData('root');
  168.     $this->loadCultureData($culture);
  169.   }
  171.   /**
  172.    * Gets the default directory for the ICU data.
  173.    * The default is the "data" directory for this class.
  174.    *
  175.    * @return string directory containing the ICU data.
  176.    */
  177.   protected static function dataDir()
  178.   {
  179.     return dirname(__FILE__).'/data/';
  180.   }
  182.   /**
  183.    * Gets the filename extension for ICU data. Default is ".dat".
  184.    *
  185.    * @return string filename extension for ICU data.
  186.    */
  187.   protected static function fileExt()
  188.   {
  189.     return '.dat';
  190.   }
  192.   /**
  193.    * Determines if a given culture is valid. Simply checks that the
  194.    * culture data exists.
  195.    *
  196.    * @param string $culture a culture
  197.    * @return boolean true if valid, false otherwise.
  198.    */
  199.   static public function validCulture($culture)
  200.   {
  201.     if (preg_match('/^[a-z]{2}(_[A-Z]{2,5}){0,2}$/', $culture))
  202.     {
  203.       return is_file(self::dataDir().$culture.self::fileExt());
  204.     }
  206.     return false;
  207.   }
  209.   /**
  210.    * Sets the culture for the current instance. The culture indentifier
  211.    * must be of the form "<language>_(country/region)".
  212.    *
  213.    * @param string $culture culture identifier, e.g. "fr_FR_EURO".
  214.    */
  215.   protected function setCulture($culture)
  216.   {
  217.     if (!empty($culture))
  218.     {
  219.       if (!preg_match('/^[a-z]{2}(_[A-Z]{2,5}){0,2}$/', $culture))
  220.       {
  221.         throw new sfException(sprintf('Invalid culture supplied: %s', $culture));
  222.       }
  223.     }
  225.     $this->culture = $culture;
  226.   }
  228.   /**
  229.    * Loads the ICU culture data for the specific culture identifier.
  230.    *
  231.    * @param string $culture the culture identifier.
  232.    */
  233.   protected function loadCultureData($culture)
  234.   {
  235.     $file_parts = explode('_', $culture);
  236.     $current_part = $file_parts[0];
  238.     $files = array($current_part);
  240.     for ($i = 1, $max = count($file_parts); $i < $max; $i++)
  241.     {
  242.       $current_part .= '_'.$file_parts[$i];
  243.       $files[] = $current_part;
  244.     }
  246.     foreach ($files as $file)
  247.     {
  248.       $filename = $this->dataDir.$file.$this->dataFileExt;
  250.       if (is_file($filename) == false)
  251.       {
  252.         throw new sfException(sprintf('Data file for "%s" was not found.', $file));
  253.       }
  255.       if (in_array($filename, $this->dataFiles) == false)
  256.       {
  257.         array_unshift($this->dataFiles, $file);
  259.         $data = &$this->getData($filename);
  260.         $this->data[$file] = &$data;
  262.         if (isset($data['__ALIAS']))
  263.         {
  264.           $this->loadCultureData($data['__ALIAS']);
  265.         }
  266.         unset($data);
  267.       }
  268.     }
  269.   }
  271.   /**
  272.    * Gets the data by unserializing the ICU data from disk.
  273.    * The data files are cached in a static variable inside
  274.    * this function.
  275.    *
  276.    * @param string $filename the ICU data filename
  277.    * @return array ICU data 
  278.    */
  279.   protected function &getData($filename)
  280.   {
  281.     static $data  = array();
  282.     static $files = array();
  284.     if (!in_array($filename, $files))
  285.     {
  286.       $data[$filename] = unserialize(file_get_contents($filename));
  287.       $files[] = $filename;
  288.     }
  290.     return $data[$filename];
  291.   }
  293.   /**
  294.    * Finds the specific ICU data information from the data.
  295.    * The path to the specific ICU data is separated with a slash "/".
  296.    * E.g. To find the default calendar used by the culture, the path
  297.    * "calendar/default" will return the corresponding default calendar.
  298.    * Use merge=true to return the ICU including the parent culture.
  299.    * E.g. The currency data for a variant, say "en_AU" contains one
  300.    * entry, the currency for AUD, the other currency data are stored
  301.    * in the "en" data file. Thus to retrieve all the data regarding 
  302.    * currency for "en_AU", you need to use findInfo("Currencies,true);.
  303.    *
  304.    * @param string  $path   the data you want to find.
  305.    * @param boolean $merge  merge the data from its parents.
  306.    * @return mixed the specific ICU data.
  307.    */
  308.   protected function findInfo($path = '/', $merge = false)
  309.   {
  310.     $result = array();
  311.     foreach ($this->dataFiles as $section)
  312.     {
  313.       $info = $this->searchArray($this->data[$section], $path);
  315.       if ($info)
  316.       {
  317.         if ($merge)
  318.         {
  319.           $result = $this->array_add($result, $info);
  320.         }
  321.         else
  322.         {
  323.           return $info;
  324.         }
  325.       }
  326.     }
  328.     return $result;
  329.   }
  331.   /**
  332.    * Adds an array to an already existing array.
  333.    * If an element is already existing in array1 it is not overwritten.
  334.    * If this element is an array this logic will be applied recursively.
  335.    */
  336.   private function array_add($array1, $array2)
  337.   {
  338.     foreach ($array2 as $key => $value)
  339.     {
  340.       if (isset($array1[$key]))
  341.       {
  342.         if(is_array($array1[$key]) && is_array($value))
  343.         {
  344.           $array1[$key] = $this->array_add($array1[$key], $value);
  345.         }
  346.       }
  347.       else
  348.       {
  349.         $array1[$key] = $value;
  350.       }
  351.     }
  352.     return $array1;
  353.   }
  355.   /**
  356.    * Searches the array for a specific value using a path separated using
  357.    * slash "/" separated path. e.g to find $info['hello']['world'],
  358.    * the path "hello/world" will return the corresponding value.
  359.    *
  360.    * @param array   $info  the array for search
  361.    * @param string  $path  slash "/" separated array path.
  362.    * @return mixed the value array using the path
  363.    */
  364.   protected function searchArray($info, $path = '/')
  365.   {
  366.     $index = explode('/', $path);
  368.     $array = $info;
  370.     for ($i = 0, $max = count($index); $i < $max; $i++)
  371.     {
  372.       $k = $index[$i];
  373.       if ($i < $max - 1 && isset($array[$k]))
  374.       {
  375.         $array = $array[$k];
  376.       }
  377.       else if ($i == $max - 1 && isset($array[$k]))
  378.       {
  379.         return $array[$k];
  380.       }
  381.     }
  382.   }
  383.   
  384.   /**
  385.    * Gets the culture name in the format 
  386.    * "<languagecode2>_(country/regioncode2)".
  387.    *
  388.    * @return string culture name.
  389.    */
  390.   public function getName()
  391.   {
  392.     return $this->culture;
  393.   }
  395.   /**
  396.    * Gets the sfDateTimeFormatInfo that defines the culturally appropriate
  397.    * format of displaying dates and times.
  398.    *
  399.    * @return sfDateTimeFormatInfo date time format information for the culture.
  400.    */
  401.   public function getDateTimeFormat()
  402.   {
  403.     if (null === $this->dateTimeFormat)
  404.     {
  405.       $calendar = $this->getCalendar();
  406.       $info = $this->findInfo("calendar/{$calendar}", true);
  407.       $this->setDateTimeFormat(new sfDateTimeFormatInfo($info));
  408.     }
  410.     return $this->dateTimeFormat;
  411.   }
  413.   /**
  414.    * Sets the date time format information.
  415.    *
  416.    * @param sfDateTimeFormatInfo $dateTimeFormat the new date time format info.
  417.    */
  418.   public function setDateTimeFormat($dateTimeFormat)
  419.   {
  420.     $this->dateTimeFormat = $dateTimeFormat;
  421.   }
  423.   /**
  424.    * Gets the default calendar used by the culture, e.g. "gregorian".
  425.    *
  426.    * @return string the default calendar.
  427.    */
  428.   public function getCalendar()
  429.   {
  430.     return $this->findInfo('calendar/default');
  431.   }
  433.   /**
  434.    * Gets the culture name in the language that the culture is set
  435.    * to display. Returns <code>array('Language','Country');</code>
  436.    * 'Country' is omitted if the culture is neutral.
  437.    *
  438.    * @return array array with language and country as elements, localized.
  439.    */
  440.   public function getNativeName()
  441.   {
  442.     $lang = substr($this->culture, 0, 2);
  443.     $reg = substr($this->culture, 3, 2);
  444.     $language = $this->findInfo("Languages/{$lang}");
  445.     $region = $this->findInfo("Countries/{$reg}");
  446.     if ($region)
  447.     {
  448.       return $language.' ('.$region.')';
  449.     }
  450.     else
  451.     {
  452.       return $language;
  453.     }
  454.   }
  456.   /**
  457.    * Gets the culture name in English.
  458.    * Returns <code>array('Language','Country');</code>
  459.    * 'Country' is omitted if the culture is neutral.
  460.    *
  461.    * @return array array with language and country as elements.
  462.    */
  463.   public function getEnglishName()
  464.   {
  465.     $lang = substr($this->culture, 0, 2);
  466.     $reg = substr($this->culture, 3, 2);
  467.     $culture = $this->getInvariantCulture();
  469.     $language = $culture->findInfo("Languages/{$lang}");
  470.     if (count($language) == 0)
  471.     {
  472.       return $this->culture;
  473.     }
  475.     $region = $culture->findInfo("Countries/{$reg}");
  477.     return $region ? $language.' ('.$region.')' : $language;
  478.   }
  480.   /**
  481.    * Gets the sfCultureInfo that is culture-independent (invariant).
  482.    * Any changes to the invariant culture affects all other
  483.    * instances of the invariant culture.
  484.    * The invariant culture is assumed to be "en";
  485.    *
  486.    * @return sfCultureInfo invariant culture info is "en".
  487.    */
  488.   static function getInvariantCulture()
  489.   {
  490.     static $invariant;
  492.     if (null === $invariant)
  493.     {
  494.       $invariant = new sfCultureInfo();
  495.     }
  497.     return $invariant;
  498.   }
  500.   /**
  501.    * Gets a value indicating whether the current sfCultureInfo 
  502.    * represents a neutral culture. Returns true if the culture
  503.    * only contains two characters.
  504.    *
  505.    * @return boolean true if culture is neutral, false otherwise.
  506.    */
  507.   public function getIsNeutralCulture()
  508.   {
  509.     return strlen($this->culture) == 2;
  510.   }
  512.   /**
  513.    * Gets the sfNumberFormatInfo that defines the culturally appropriate
  514.    * format of displaying numbers, currency, and percentage.
  515.    *
  516.    * @return sfNumberFormatInfo the number format info for current culture.
  517.    */
  518.   public function getNumberFormat()
  519.   {
  520.     if (null === $this->numberFormat)
  521.     {
  522.       $elements = $this->findInfo('NumberElements');
  523.       $patterns = $this->findInfo('NumberPatterns');
  524.       $currencies = $this->getCurrencies(null, true);
  525.       $data = array('NumberElements' => $elements, 'NumberPatterns' => $patterns, 'Currencies' => $currencies);
  527.       $this->setNumberFormat(new sfNumberFormatInfo($data));
  528.     }
  530.     return $this->numberFormat;
  531.   }
  533.   /**
  534.    * Sets the number format information.
  535.    *
  536.    * @param sfNumberFormatInfo $numberFormat the new number format info.
  537.    */
  538.   public function setNumberFormat($numberFormat)
  539.   {
  540.     $this->numberFormat = $numberFormat;
  541.   }
  543.   /**
  544.    * Gets the sfCultureInfo that represents the parent culture of the 
  545.    * current sfCultureInfo
  546.    *
  547.    * @return sfCultureInfo parent culture information.
  548.    */
  549.   public function getParent()
  550.   {
  551.     if (strlen($this->culture) == 2)
  552.     {
  553.       return $this->getInvariantCulture();
  554.     }
  556.     return new sfCultureInfo(substr($this->culture, 0, 2));
  557.   }
  559.   /**
  560.    * Gets the list of supported cultures filtered by the specified 
  561.    * culture type. This is an EXPENSIVE function, it needs to traverse
  562.    * a list of ICU files in the data directory.
  563.    * This function can be called statically.
  564.    *
  565.    * @param int $type culture type, sfCultureInfo::ALL, sfCultureInfo::NEUTRAL
  566.    * or sfCultureInfo::SPECIFIC.
  567.    * @return array list of culture information available. 
  568.    */
  569.   static function getCultures($type = sfCultureInfo::ALL)
  570.   {
  571.     $dataDir = sfCultureInfo::dataDir();
  572.     $dataExt = sfCultureInfo::fileExt();
  573.     $dir = dir($dataDir);
  575.     $neutral = array();
  576.     $specific = array();
  578.     while (false !== ($entry = $dir->read()))
  579.     {
  580.       if (is_file($dataDir.$entry) && substr($entry, -4) == $dataExt && $entry != 'root'.$dataExt)
  581.       {
  582.         $culture = substr($entry, 0, -4);
  583.         if (strlen($culture) == 2)
  584.         {
  585.           $neutral[] = $culture;
  586.         }
  587.         else
  588.         {
  589.           $specific[] = $culture;
  590.         }
  591.       }
  592.     }
  593.     $dir->close();
  595.     switch ($type)
  596.     {
  597.       case sfCultureInfo::ALL:
  598.         $all =  array_merge($neutral, $specific);
  599.         sort($all);
  600.         return $all;
  601.         break;
  602.       case sfCultureInfo::NEUTRAL:
  603.         return $neutral;
  604.         break;
  605.       case sfCultureInfo::SPECIFIC:
  606.         return $specific;
  607.         break;
  608.     }
  609.   }
  611.   /**
  612.    * Get the country name in the current culture for the given code.
  613.    *
  614.    * @param  string $code A valid country code
  615.    *
  616.    * @return string The country name in the current culture
  617.    */
  618.   public function getCountry($code)
  619.   {
  620.     $countries = $this->findInfo('Countries', true);
  622.     if (!isset($countries[$code]))
  623.     {
  624.       throw new InvalidArgumentException(sprintf('The country %s does not exist.', $code));
  625.     }
  627.     return $countries[$code];
  628.   }
  630.   /**
  631.    * Get the currency name in the current culture for the given code.
  632.    *
  633.    * @param  string $code A valid currency code
  634.    *
  635.    * @return string The currency name in the current culture
  636.    */
  637.   public function getCurrency($code)
  638.   {
  639.     $currencies = $this->findInfo('Currencies', true);
  641.     if (!isset($currencies[$code]))
  642.     {
  643.       throw new InvalidArgumentException(sprintf('The currency %s does not exist.', $code));
  644.     }
  646.     return $currencies[$code][1];
  647.   }
  649.   /**
  650.    * Get the language name in the current culture for the given code.
  651.    *
  652.    * @param  string $code A valid language code
  653.    *
  654.    * @return string The language name in the current culture
  655.    */
  656.   public function getLanguage($code)
  657.   {
  658.     $languages = $this->findInfo('Languages', true);
  660.     if (!isset($languages[$code]))
  661.     {
  662.       throw new InvalidArgumentException(sprintf('The language %s does not exist.', $code));
  663.     }
  665.     return $languages[$code];
  666.   }
  668.   /**
  669.    * Gets a list of countries in the language of the localized version.
  670.    *
  671.    * @param  array $countries An array of countries used to restrict the returned array (null by default, which means all countries)
  672.    *
  673.    * @return array a list of localized country names. 
  674.    */
  675.   public function getCountries($countries = null)
  676.   {
  677.     $allCountries = $this->findInfo('Countries', true);
  679.     // restrict countries to a sub-set
  680.     if (null !== $countries)
  681.     {
  682.       if ($problems = array_diff($countries, array_keys($allCountries)))
  683.       {
  684.         throw new InvalidArgumentException(sprintf('The following countries do not exist: %s.', implode(', ', $problems)));
  685.       }
  687.       $allCountries = array_intersect_key($allCountries, array_flip($countries));
  688.     }
  690.     $this->sortArray($allCountries);
  692.     return $allCountries;
  693.   }
  695.   /**
  696.    * Gets a list of currencies in the language of the localized version.
  697.    *
  698.    * @param  array   $currencies An array of currencies used to restrict the returned array (null by default, which means all currencies)
  699.    * @param  Boolean $full       Whether to return the symbol and the name or not (false by default)
  700.    *
  701.    * @return array a list of localized currencies.
  702.    */
  703.   public function getCurrencies($currencies = null, $full = false)
  704.   {
  705.     $allCurrencies = $this->findInfo('Currencies', true);
  707.     // restrict countries to a sub-set
  708.     if (null !== $currencies)
  709.     {
  710.       if ($problems = array_diff($currencies, array_keys($allCurrencies)))
  711.       {
  712.         throw new InvalidArgumentException(sprintf('The following currencies do not exist: %s.', implode(', ', $problems)));
  713.       }
  715.       $allCurrencies = array_intersect_key($allCurrencies, array_flip($currencies));
  716.     }
  718.     if (!$full)
  719.     {
  720.       foreach ($allCurrencies as $key => $value)
  721.       {
  722.         $allCurrencies[$key] = $value[1];
  723.       }
  724.     }
  726.     $this->sortArray($allCurrencies);
  728.     return $allCurrencies;
  729.   }
  731.   /**
  732.    * Gets a list of languages in the language of the localized version.
  733.    *
  734.    * @param  array $languages An array of languages used to restrict the returned array (null by default, which means all languages)
  735.    *
  736.    * @return array list of localized language names.
  737.    */
  738.   public function getLanguages($languages = null)
  739.   {
  740.     $allLanguages = $this->findInfo('Languages', true);
  742.     // restrict languages to a sub-set
  743.     if (null !== $languages)
  744.     {
  745.       if ($problems = array_diff($languages, array_keys($allLanguages)))
  746.       {
  747.         throw new InvalidArgumentException(sprintf('The following languages do not exist: %s.', implode(', ', $problems)));
  748.       }
  750.       $allLanguages = array_intersect_key($allLanguages, array_flip($languages));
  751.     }
  753.     $this->sortArray($allLanguages);
  755.     return $allLanguages;
  756.   }
  758.   /**
  759.    * Gets a list of scripts in the language of the localized version.
  760.    *
  761.    * @return array list of localized script names.
  762.    */
  763.   public function getScripts()
  764.   {
  765.     return $this->findInfo('Scripts', true);
  766.   }
  768.   /**
  769.    * Gets a list of timezones in the language of the localized version.
  770.    *
  771.    * @return array list of localized timezones.
  772.    */
  773.   public function getTimeZones()
  774.   {
  775.     //new format since ICU 3.8
  776.     //zoneStrings contains metaTimezones
  777.     $metadata = $this->findInfo('zoneStrings', true);
  778.     //TimeZones contains the Timezone name => metaTimezone identifier
  779.     $timeZones = $this->findInfo('TimeZones', true);
  780.     foreach ($timeZones as $key => $value)
  781.     {
  782.       $timeZones[$key] = $metadata['meta:'.$value];
  783.       $timeZones[$key]['identifier'] = $key;
  784.       $timeZones[$key]['city'] = str_replace('_', ' ', substr($key, strpos($key, '/') + 1));
  785.     }
  786.     return $timeZones;
  787.   }
  789.   /**
  790.    * sorts the passed array according to the locale of this sfCultureInfo class
  791.    *
  792.    * @param  array the array to pe sorted wiht "asort" and this locale
  793.    */
  794.   public function sortArray(&$array)
  795.   {
  796.     $oldLocale = setlocale(LC_COLLATE, 0);
  797.     setlocale(LC_COLLATE, $this->getName());
  798.     asort($array, SORT_LOCALE_STRING);
  799.     setlocale(LC_COLLATE, $oldLocale);
  800.   }
  801. }
Debug toolbar