1. sfDateTimeFormatInfo.class.php
  2. /**
 * Defines how DateTime values are formatted and displayed, depending 
 * on the culture.
 * 
 * This class contains information, such as date patterns, time patterns, 
 * and AM/PM designators. 
 *
 * To create a sfDateTimeFormatInfo for a specific culture, create a 
 * sfCultureInfo for that culture and retrieve the sfCultureInfo.sfDateTimeFormat 
 * property. For example:
 * 
 * $culture = new sfCultureInfo('en_AU');
 * $dtfi = $culture->DateTimeFormat;
 * 
 * 
 * To create a sfDateTimeFormatInfo for the invariant culture, use 
 * 
 * sfDateTimeFormatInfo::getInstance($culture=null);
 * 
 * you may pass a sfCultureInfo parameter $culture to get the sfDateTimeFormatInfo
 * for a specific culture.
 *
 * sfDateTime values are formatted using standard or custom patterns stored in 
 * the properties of a sfDateTimeFormatInfo.
 * 
 * The standard patterns can be replaced with custom patterns by setting the 
 * associated properties of sfDateTimeFormatInfo.
 *
 * The following table lists the standard format characters for each standard 
 * pattern and the associated sfDateTimeFormatInfo property that can be set to 
 * modify the standard pattern. The format characters are case-sensitive;
 * for example, 'g' and 'G' represent slightly different patterns.
 *
 * 
 *  Format Character    Associated Property     Example Format Pattern (en-US)
 *  --------------------------------------------------------------------------
 *  d                   ShortDatePattern        MM/dd/yyyy 
 *  D                   LongDatePattern         dddd, dd MMMM yyyy 
 *  F                   FullDateTimePattern     dddd, dd MMMM yyyy HH:mm:ss
 *  m, M                MonthDayPattern         MMMM dd 
 *  r, R                RFC1123Pattern          ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
 *  s                   SortableDateTimePattern yyyy'-'MM'-'dd'T'HH':'mm':'ss 
 *  t                   ShortTimePattern        HH:mm 
 *  T                   LongTimePattern         HH:mm:ss 
 *  Y                   YearMonthPattern        yyyy MMMM 
 *  --------------------------------------------------------------------------
 * 
 *
 * @author Xiang Wei Zhuo 
 * @version v1.0, last update on Fri Dec 03 22:30:31 EST 2004
 * @package    symfony
 * @subpackage i18n
 */
  3. class sfDateTimeFormatInfo
  4. {
  5.   /**
  6.    * ICU date time formatting data.
  7.    */
  8.   protected $data = array();
  10.   /**
  11.    * A list of properties that are accessable/writable.
  12.    */
  13.   protected $properties = array();
  15.   /**
  16.    * Allows functions that begins with 'set' to be called directly
  17.    * as an attribute/property to retrieve the value.
  18.    *
  19.    * @return mixed
  20.    */
  21.   function __get($name)
  22.   {
  23.     $getProperty = 'get'.$name;
  24.     if (in_array($getProperty, $this->properties))
  25.     {
  26.       return $this->$getProperty();
  27.     }
  28.     else
  29.     {
  30.       throw new sfException(sprintf('Property %s does not exists.', $name));
  31.     }
  32.   }
  34.   /**
  35.    * Allows functions that begins with 'set' to be called directly
  36.    * as an attribute/property to set the value.
  37.    */
  38.   function __set($name, $value)
  39.   {
  40.     $setProperty = 'set'.$name;
  41.     if (in_array($setProperty, $this->properties))
  42.     {
  43.       $this->$setProperty($value);
  44.     }
  45.     else
  46.     {
  47.       throw new sfException(sprintf('Property %s can not be set.', $name));
  48.     }
  49.   }
  51.   /**
  52.    * Initializes a new writable instance of the sfDateTimeFormatInfo class 
  53.    * that is dependent on the ICU data for date time formatting 
  54.    * information. <b>N.B.</b>You should not initialize this class directly
  55.    * unless you know what you are doing. Please use use 
  56.    * sfDateTimeFormatInfo::getInstance() to create an instance.
  57.    *
  58.    * @param array   $data ICU data for date time formatting.
  59.    * @see getInstance()
  60.    */
  61.   function __construct($data = array())
  62.   {
  63.     $this->properties = get_class_methods($this);
  65.     if (empty($data))
  66.     {
  67.       throw new sfException('Please provide the ICU data to initialize.');
  68.     }
  70.     $this->data = $data;
  71.   }
  73.   /**
  74.    * Gets the internal ICU data for date time formatting.
  75.    *
  76.    * @return array ICU date time formatting data.
  77.    */
  78.   protected function getData()
  79.   {
  80.     return $this->data;
  81.   }
  83.   /**
  84.    * Gets the default sfDateTimeFormatInfo that is culture-independent (invariant).
  85.    *
  86.    * @return sfDateTimeFormatInfo default sfDateTimeFormatInfo. 
  87.    */
  88.   static function getInvariantInfo()
  89.   {
  90.     static $invariant;
  92.     if (null === $invariant)
  93.     {
  94.       $invariant = sfCultureInfo::getInvariantCulture()->DateTimeFormat;
  95.     }
  97.     return $invariant;
  98.   }
  100.   /**
  101.    * Returns the sfDateTimeFormatInfo associated with the specified culture.
  102.    *
  103.    * @param sfCultureInfo   $culture  the culture that gets the sfDateTimeFormat property.
  104.    * @return sfDateTimeFormatInfo sfDateTimeFormatInfo for the specified
  105.    * culture.
  106.    */
  107.   static function getInstance($culture = null)
  108.   {
  109.     if ($culture instanceof sfCultureInfo)
  110.     {
  111.       return $culture->DateTimeFormat;
  112.     }
  113.     else if (is_string($culture))
  114.     {
  115.       return sfCultureInfo::getInstance($culture)->DateTimeFormat;
  116.     }
  117.     else
  118.     {
  119.       return sfCultureInfo::getInvariantCulture()->DateTimeFormat;
  120.     }
  121.   }
  123.   /**
  124.    * A one-dimensional array of type String containing
  125.    * the culture-specific abbreviated names of the days
  126.    * of the week. The array for InvariantInfo contains
  127.    * "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", and "Sat".
  128.    *
  129.    * @return array abbreviated day names
  130.    */
  131.   function getAbbreviatedDayNames()
  132.   {
  133.     return $this->data['dayNames']['format']['abbreviated'];
  134.   }
  136.   /**
  137.    * Sets the abbreviated day names. The value should be
  138.    * an array of string starting with Sunday and ends in Saturady.
  139.    * For example,
  140.    * <code>array("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat");</code>
  141.    *
  142.    * @param array $value abbreviated day names.
  143.    */
  144.   function setAbbreviatedDayNames($value)
  145.   {
  146.     $this->data['dayNames']['format']['abbreviated'] = $value;
  147.   }
  149.   /**
  150.    * A one-dimensional array of type String containing
  151.    * the culture-specific narrow names of the days
  152.    * of the week. The array for InvariantInfo contains
  153.    * "S", "M", "T", "W", "T", "F", and "S".
  154.    *
  155.    * @return array narrow day names
  156.    */
  157.   function getNarrowDayNames()
  158.   {
  159.     return $this->data['dayNames']['stand-alone']['narrow'];
  160.   }
  162.   /**
  163.    * Sets the narrow day names. The value should be
  164.    * an array of string starting with Sunday and ends in Saturady.
  165.    * For example,
  166.    * <code>array("S", "M", "T", "W", "T", "F", "S");</code>
  167.    *
  168.    * @param array $value narrow day names.
  169.    */
  170.   function setNarrowDayNames($value)
  171.   {
  172.     $this->data['dayNames']['stand-alone']['narrow'] = $value;
  173.   }
  175.   /**
  176.    * A one-dimensional array of type String containing the
  177.    * culture-specific full names of the days of the week.
  178.    * The array for InvariantInfo contains "Sunday", "Monday",
  179.    * "Tuesday", "Wednesday", "Thursday", "Friday", and "Saturday".
  180.    *
  181.    * @return array day names
  182.    */
  183.   function getDayNames()
  184.   {
  185.     return $this->data['dayNames']['format']['wide'];
  186.   }
  188.   /**
  189.    * Sets the day names. The value should be
  190.    * an array of string starting with Sunday and ends in Saturady.
  191.    * For example,
  192.    * <code>array("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
  193.    * "Friday", "Saturday".);</code>
  194.    *
  195.    * @param array $value day names.
  196.    */
  197.   function setDayNames($value)
  198.   {
  199.     $this->data['dayNames']['format']['wide'] = $value;
  200.   }
  202.   /**
  203.    * A one-dimensional array of type String containing the
  204.    * culture-specific narrow names of the months. The array
  205.    * for InvariantInfo contains "J", "F", "M", "A", "M", "J",
  206.    * "J", "A", "S", "O", "N", and "D".
  207.    *
  208.    * @return array narrow month names.
  209.    */
  210.   function getNarrowMonthNames()
  211.   {
  212.     return $this->data['monthNames']['stand-alone']['narrow'];
  213.   }
  215.   /**
  216.    * Sets the narrow month names. The value should be
  217.    * an array of string starting with J and ends in D.
  218.    * For example,
  219.    * <code>array("J","F","M","A","M","J","J","A","S","O","N","D");</code>
  220.    *
  221.    * @param array $value month names.
  222.    */
  223.   function setNarrowMonthNames($value)
  224.   {
  225.     $this->data['monthNames']['stand-alone']['narrow'] = $value;
  226.   }
  228.   /**
  229.    * A one-dimensional array of type String containing the 
  230.    * culture-specific abbreviated names of the months. The array 
  231.    * for InvariantInfo contains "Jan", "Feb", "Mar", "Apr", "May", 
  232.    * "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", and "Dec".
  233.    *
  234.    * Returns wide names if abbreviated names doesn't exist.
  235.    *
  236.    * @return array abbreviated month names.
  237.    */
  238.   function getAbbreviatedMonthNames()
  239.   {
  240.     if (isset($this->data['monthNames']['format']['abbreviated']))
  241.     {
  242.       return $this->data['monthNames']['format']['abbreviated'];
  243.     }
  244.     else
  245.     {
  246.       return $this->data['monthNames']['format']['wide'];
  247.     }
  248.   }
  250.   /**
  251.    * Sets the abbreviated month names. The value should be
  252.    * an array of string starting with Jan and ends in Dec.
  253.    * For example,
  254.    * <code>array("Jan", "Feb", "Mar", "Apr", "May", "Jun",
  255.    * "Jul", "Aug", "Sep","Oct","Nov","Dec");</code>
  256.    *
  257.    * @param array $value month names.
  258.    */
  259.   function setAbbreviatedMonthNames($value)
  260.   {
  261.     $this->data['monthNames']['format']['abbreviated'] = $value;
  262.   }
  264.   /**
  265.    * A one-dimensional array of type String containing the 
  266.    * culture-specific full names of the months. The array for 
  267.    * InvariantInfo contains "January", "February", "March", "April",
  268.    * "May", "June", "July", "August", "September", "October", "November",
  269.    * and "December"
  270.    *
  271.    * @return array month names.
  272.    */
  273.   function getMonthNames()
  274.   {
  275.     return $this->data['monthNames']['format']['wide'];
  276.   }
  278.   /**
  279.    * Sets the month names. The value should be
  280.    * an array of string starting with Janurary and ends in December.
  281.    * For example,
  282.    * <code>array("January", "February", "March", "April", "May", "June",
  283.    * "July", "August", "September","October","November","December");</code>
  284.    *
  285.    * @param array $value month names.
  286.    */
  287.   function setMonthNames($value)
  288.   {
  289.     $this->data['monthNames']['format']['wide'] = $value;
  290.   }
  292.   /**
  293.    * A string containing the name of the era.
  294.    *
  295.    * @param int $era era The integer representing the era. 
  296.    * @return string the era name.
  297.    */
  298.   function getEra($era)
  299.   {
  300.     return $this->data['eras']['abbreviated'][$era];
  301.   }
  303.   /**
  304.    * The string designator for hours that are "ante meridiem" (before noon).
  305.    * The default for InvariantInfo is "AM".
  306.    *
  307.    * @return string AM designator.
  308.    */
  309.   function getAMDesignator()
  310.   {
  311.     $result = $this->getAMPMMarkers();
  313.     return $result[0];
  314.   }
  316.   /**
  317.    * Sets the AM Designator. For example, 'AM'.
  318.    *
  319.    * @param string $value AM designator.
  320.    */
  321.   function setAMDesignator($value)
  322.   {
  323.     $markers = $this->getAMPMMarkers();
  324.     $markers[0] = $value;
  325.     $this->setAMPMMarkers($markers);
  326.   }
  328.   /**
  329.    * The string designator for hours that are "post meridiem" (after noon).
  330.    * The default for InvariantInfo is "PM".
  331.    *
  332.    * @return string PM designator.
  333.    */
  334.   function getPMDesignator()
  335.   {
  336.     $result = $this->getAMPMMarkers();
  338.     return $result[1];
  339.   }
  341.   /**
  342.    * Sets the PM Designator. For example, 'PM'.
  343.    *
  344.    * @param string $value PM designator.
  345.    */
  346.   function setPMDesignator($value)
  347.   {
  348.     $markers = $this->getAMPMMarkers();
  349.     $markers[1] = $value;
  350.     $this->setAMPMMarkers($markers);
  351.   }
  353.   /**
  354.    * Gets the AM and PM markers array.
  355.    * Default InvariantInfo for AM and PM is <code>array('AM','PM');</code>
  356.    *
  357.    * @return array AM and PM markers
  358.    */
  359.   function getAMPMMarkers()
  360.   {
  361.     return $this->data['AmPmMarkers'];
  362.   }
  364.   /**
  365.    * Sets the AM and PM markers array.
  366.    * For example <code>array('AM','PM');</code>
  367.    *
  368.    * @param array $value AM and PM markers
  369.    */
  370.   function setAMPMMarkers($value)
  371.   {
  372.     $this->data['AmPmMarkers'] = $value;
  373.   }
  375.   /**
  376.    * Returns the full time pattern "HH:mm:ss z" (default).
  377.    * This is culture sensitive.
  378.    *
  379.    * @return string pattern "HH:mm:ss z".
  380.    */
  381.   function getFullTimePattern()
  382.   {
  383.     return $this->data['DateTimePatterns'][0];
  384.   }
  386.   /**
  387.    * Returns the long time pattern "HH:mm:ss z" (default).
  388.    * This is culture sensitive.
  389.    *
  390.    * @return string pattern "HH:mm:ss z".
  391.    */
  392.   function getLongTimePattern()
  393.   {
  394.     return $this->data['DateTimePatterns'][1];
  395.   }
  397.   /**
  398.    * Returns the medium time pattern "HH:mm:ss" (default).
  399.    * This is culture sensitive.
  400.    *
  401.    * @return string pattern "HH:mm:ss".
  402.    */
  403.   function getMediumTimePattern()
  404.   {
  405.     return $this->data['DateTimePatterns'][2];
  406.   }
  408.   /**
  409.    * Returns the short time pattern "HH:mm" (default).
  410.    * This is culture sensitive.
  411.    *
  412.    * @return string pattern "HH:mm".
  413.    */
  414.   function getShortTimePattern()
  415.   {
  416.     return $this->data['DateTimePatterns'][3];
  417.   }
  419.   /**
  420.    * Returns the full date pattern "EEEE, yyyy MMMM dd" (default).
  421.    * This is culture sensitive.
  422.    * @return string pattern "EEEE, yyyy MMMM dd".
  423.    */
  424.   function getFullDatePattern()
  425.   {
  426.     return $this->data['DateTimePatterns'][4];
  427.   }
  429.   /**
  430.    * Returns the long date pattern "yyyy MMMM d" (default).
  431.    * This is culture sensitive.
  432.    * @return string pattern "yyyy MMMM d".
  433.    */
  434.   function getLongDatePattern()
  435.   {
  436.     return $this->data['DateTimePatterns'][5];
  437.   }
  439.   /**
  440.    * Returns the medium date pattern "yyyy MMMM d" (default).
  441.    * This is culture sensitive.
  442.    * @return string pattern "yyyy MMM d".
  443.    */
  444.   function getMediumDatePattern()
  445.   {
  446.     return $this->data['DateTimePatterns'][6];
  447.   }
  449.   /**
  450.    * Returns the short date pattern "yy/MM/dd" (default).
  451.    * This is culture sensitive.
  452.    *
  453.    * @return string pattern "yy/MM/dd".
  454.    */
  455.   function getShortDatePattern()
  456.   {
  457.     return $this->data['DateTimePatterns'][7];
  458.   }
  460.   /**
  461.    * Returns the date time order pattern, "{1} {0}" (default).
  462.    * This is culture sensitive.
  463.    *
  464.    * @return string pattern "{1} {0}".
  465.    */
  466.   function getDateTimeOrderPattern()
  467.   {
  468.     return $this->data['DateTimePatterns'][8];
  469.   }
  471.   /**
  472.    * Formats the date and time in a culture sensitive paterrn.
  473.    * The default is "Date Time".
  474.    *
  475.    * @return string date and time formated
  476.    */
  477.   function formatDateTime($date, $time)
  478.   {
  479.     return str_replace(array('{0}','{1}'), array($time, $date), $this->getDateTimeOrderPattern());
  480.   }
  481. }
Debug toolbar