Source for file date.php

Documentation is available at date.php

  1. <?php
  2. /**
  3. * Simple date and time classes to perform basic date calculations
  4. *
  5. * @author    Stuart Prescott
  6. * @copyright  Copyright Stuart Prescott
  7. * @license    http://opensource.org/licenses/gpl-license.php GNU Public License
  8. * @version    $Id$
  9. * @package    Bumblebee
  10. * @subpackage Misc
  11. */
  12.  
  13. /** Load ancillary functions */
  14. require_once 'inc/typeinfo.php';
  15. checkValidInclude();
  16.  
  17. /** config system */
  18. require_once 'inc/bb/configreader.php';
  19.  
  20. /**
  21. * Simple date class to perform basic date calculations
  22. *
  23. * WARNING USING TICKS DIRECTLY IS DANGEROUS
  24. *
  25. * The ticks variable here is a little problematic... daylight saving transitions tend
  26. * to make it rather frought. For example, for the purposes of this system,
  27. * if you want to know what 4 days after 9am 20th March
  28. * is, you expect to get 9am 23rd March regardless of a timezone change from daylight saving.
  29. *
  30. * For example, this might not give you what you want:<code>
  31. * $date = new SimpleDate('2005-03-20');
  32. * $date->addSecs(4*24*60*60);   // add 4 days
  33. * </code>
  34. * But this will:<code>
  35. * $date = new SimpleDate('2005-03-20');
  36. * $date->addDays(4);   // add 4 days
  37. * </code>
  38. *
  39. * @package    Bumblebee
  40. * @subpackage Misc
  41. */
  42. class SimpleDate {
  43.   /**
  44.   * cache of date in string format
  45.   * @var string 
  46.   */
  47.   var $_cache = array();
  48.   /**
  49.   * date in seconds since epoch
  50.   * @var integer 
  51.   */
  52.   var $ticks  = '';
  53.   /**
  54.   * is a valid date-time
  55.   * @var boolean 
  56.   */
  57.   var $isValid = 1;
  58.  
  59.   /**
  60.   * construct a Date-Time object
  61.   *
  62.   * constructor will work with $time in the following formats:
  63.   * - YYYY-MM-DD            (assumes 00:00:00 for time part)
  64.   * - YYYY-MM-DD HH:MM      (assumes :00 for seconds part)
  65.   * - YYYY-MM-DD HH:MM:SS
  66.   * - seconds since epoch
  67.   * - SimpleDate object
  68.   * @param mixed $time  initial time to use
  69.   */
  70.   function SimpleDate($time) {
  71.     ($time == NULL) && $time = 0;
  72.     if (is_numeric($time)) {
  73.       $this->setTicks($time);
  74.     } elseif (type_is_a($time, 'SimpleDate')) {
  75.       $this->setTicks($time->ticks);
  76.     } else {
  77.       $this->setStr($time);
  78.     }
  79.   }
  80.  
  81.   /**
  82.   * set the date and time from a string
  83.   *
  84.   * - YYYY-MM-DD            (assumes 00:00:00)
  85.   * - YYYY-MM-DD HH:MM      (assumes :00)
  86.   * - YYYY-MM-DD HH:MM:SS
  87.   * @param mixed $s date time string
  88.   */
  89.   function setStr($s) {
  90.     $this->isValid = 1;
  91.     $this->_setTicks($s);
  92.   }
  93.  
  94.   function dateTimeString() {
  95.     if (! isset($this->_cache['datetime'])) {
  96.       $this->_cache['datetime'] = strftime('%Y-%m-%d %H:%M:%S', $this->ticks);
  97.     }
  98.     return $this->_cache['datetime'];
  99.   }
  100.  
  101.   function timeString() {
  102.     if (! isset($this->_cache['time'])) {
  103.       $this->_cache['time'] = strftime('%H:%M:%S', $this->ticks);
  104.     }
  105.     return $this->_cache['time'];
  106.   }
  107.  
  108.   function dateString() {
  109.     if (! isset($this->_cache['date'])) {
  110.       $this->_cache['date'] = strftime('%Y-%m-%d', $this->ticks);
  111.     }
  112.     return $this->_cache['date'];
  113.   }
  114.  
  115.   /**
  116.   * get a short string representation for the current locale
  117.   *
  118.   * @return string time value in short time format
  119.   */
  120.   function getShortDateString() {
  121.     if (! isset($this->_cache['lshortDate'])) {
  122.       $conf = ConfigReader::getInstance();
  123.       $format = $conf->value('language', 'date_shortdate', 'Y-m-d');
  124.       $this->_cache['lshortDate'] = $this->getStringByFormat($format);
  125.     }
  126.     return $this->_cache['lshortDate'];
  127.   }
  128.  
  129.   /**
  130.   * get a short string representation for the current locale
  131.   *
  132.   * @return string time value in short time format
  133.   */
  134.   function getShortTimeString() {
  135.     if (! isset($this->_cache['lshortTime'])) {
  136.       $conf = ConfigReader::getInstance();
  137.       $format = $conf->value('language', 'date_shorttime', 'H:i');
  138.       $this->_cache['lshortTime'] = $this->getStringByFormat($format);
  139.     }
  140.     return $this->_cache['lshortTime'];
  141.   }
  142.  
  143.   /**
  144.   * get a short string representation for the current locale
  145.   *
  146.   * @return string time value in short time format
  147.   */
  148.   function getShortDateTimeString() {
  149.     if (! isset($this->_cache['lshortDateTime'])) {
  150.       $conf = ConfigReader::getInstance();
  151.       $format = $conf->value('language', 'date_shortdatetime', 'Y-m-d H:i');
  152.       $this->_cache['lshortDateTime'] = $this->getStringByFormat($format);
  153.     }
  154.     return $this->_cache['lshortDateTime'];
  155.   }
  156.  
  157.   /**
  158.   * get a long string representation for the current locale
  159.   *
  160.   * @return string time value in long time format
  161.   */
  162.   function getLongDateString() {
  163.     if (! isset($this->_cache['llongDate'])) {
  164.       $conf = ConfigReader::getInstance();
  165.       $format = $conf->value('language', 'date_longdate', 'D F j, Y');
  166.       $this->_cache['llongDate'] = $this->getStringByFormat($format);
  167.     }
  168.     return $this->_cache['llongDate'];
  169.   }
  170.  
  171.   /**
  172.   * get a long string representation for the current locale
  173.   *
  174.   * @return string time value in long time format
  175.   */
  176.   function getLongTimeString() {
  177.     if (! isset($this->_cache['llongTime'])) {
  178.       $conf = ConfigReader::getInstance();
  179.       $format = $conf->value('language', 'date_longtime', 'H:i:s');
  180.       $this->_cache['llongTime'] = $this->getStringByFormat($format);
  181.     }
  182.     return $this->_cache['llongTime'];
  183.   }
  184.  
  185.   /**
  186.   * get a long string representation for the current locale
  187.   *
  188.   * @return string time value in long time format
  189.   */
  190.   function getLongDateTimeString() {
  191.     if (! isset($this->_cache['llongDateTime'])) {
  192.       $conf = ConfigReader::getInstance();
  193.       $format = $conf->value('language', 'date_longdatetime', 'H:i:s, D F j, Y');
  194.       $this->_cache['llongDateTime'] = $this->getStringByFormat($format);
  195.     }
  196.     return $this->_cache['llongDateTime'];
  197.   }
  198.  
  199.   /**
  200.   * Get a string representation of this time in the specified format
  201.   *
  202.   * Recognised format characters are as follows:
  203.   *
  204.   * d    Day of the month, 2 digits with leading zeros    01 to 31
  205.   * D    A textual representation of a day, three letters    Mon through Sun
  206.   * j    Day of the month without leading zeros    1 to 31
  207.   * l (lowercase 'L')    A full textual representation of the day of the week    Sunday through Saturday
  208.   *
  209.   * F    A full textual representation of a month, such as January or March    January through December
  210.   * m    Numeric representation of a month, with leading zeros    01 through 12
  211.   * M    A short textual representation of a month, three letters    Jan through Dec
  212.   * n    Numeric representation of a month, without leading zeros    1 through 12
  213.   *
  214.   * Y    A full numeric representation of a year, 4 digits    Examples: 1999 or 2003
  215.   * y    A two digit representation of a year    Examples: 99 or 03
  216.   *
  217.   * a    Lowercase Ante meridiem and Post meridiem    am or pm
  218.   * A    Uppercase Ante meridiem and Post meridiem    AM or PM
  219.   * g    12-hour format of an hour without leading zeros    1 through 12
  220.   * G    24-hour format of an hour without leading zeros    0 through 23
  221.   * h    12-hour format of an hour with leading zeros    01 through 12
  222.   * H    24-hour format of an hour with leading zeros    00 through 23
  223.   * i    Minutes with leading zeros    00 to 59
  224.   * s    Seconds, with leading zeros    00 through 59
  225.   *
  226.   * @return string time value in short time format
  227.   */
  228.   function getStringByFormat($format) {
  229.     static $i18n = null;
  230.     if ($i18n === null) {
  231.       $i18n = date_make_translation_array();
  232.     }
  233.     $s = '';  // return string
  234.         $c = '';  // current character
  235.         $p = '';  // previous character
  236.  
  237.     #print "Analysing $format";
  238.         $formatLen = strlen($format);
  239.     for ($i=0; $i<$formatLen; $i++) {
  240.       $c = $format[$i];
  241.       if ($i > 0 && $format[$i-1] == '\\') {
  242.         $s .= $c;
  243.         next;
  244.       }
  245.       #print " $i: $c ($s)...";
  246.  
  247.       switch ($c) {
  248.         // day
  249.         case 'd':
  250.         case 'j':
  251.         // month
  252.         case 'm':
  253.         case 'n':
  254.         // year
  255.         case 'y':
  256.         case 'Y':
  257.         // time
  258.         case 'g':
  259.         case 'G':
  260.         case 'h':
  261.         case 'H':
  262.         case 'i':
  263.         case 's':
  264.           $s .= date($c, $this->ticks);
  265.           break;
  266.  
  267.         // day
  268.         case 'D':
  269.         case 'l':
  270.         // month
  271.         case 'F':
  272.         case 'M':
  273.         // time
  274.         case 'a':
  275.         case 'A':
  276.           $s .= $i18n[date($c, $this->ticks)];
  277.           #$s .= date($c, $this->ticks);
  278.           break;
  279.  
  280.         case '\\':
  281.           break;
  282.         default:
  283.           $s .= $c;
  284.           break;
  285.       }
  286.     }
  287.     return $s;
  288.   }
  289.  
  290.   /**
  291.   * set the date and time from seconds since epoch
  292.   *
  293.   * @param mixed $t ticks
  294.   */
  295.   function setTicks($t) {
  296.     $this->isValid = 1;
  297.     $this->ticks = $t;
  298.     $this->_cache = array();
  299.     //$this->_setStr();
  300.   }
  301.  
  302.   function _setTicks($s) {
  303.     #echo "SimpleDate::Ticks $s<br />";
  304.     #preDump(debug_backtrace());
  305.     $this->ticks = strtotime($s);
  306.     $this->_cache = array();
  307.     $this->isValid = $this->isValid && ($this->ticks != '' && $this->ticks != -1);
  308.   }
  309.  
  310.   /**
  311.   * add a whole number of days to the current date-time
  312.   * @param integer $d days to add
  313.   */
  314.   function addDays($d) {
  315.     $this->addTimeParts(0,0,0,$d,0,0);
  316.   }
  317.  
  318.   /**
  319.   * add a time (i.e. a number of seconds) to the current date-time
  320.   *
  321.   * - SimpleTime object
  322.   * - seconds
  323.   * @param mixed $d days to add
  324.   */
  325.   function addTime($t) {
  326.     if (type_is_a($t, 'SimpleTime')) {
  327.       $this->ticks += $t->seconds();
  328.     } else {
  329.       $this->ticks += $t;
  330.     }
  331.     $this->_cache = array();
  332.   }
  333.  
  334.   /**
  335.   * add a whole number of seconds to the current date-time
  336.   * @param integer $s seconds to add
  337.   */
  338.   function addSecs($s) {
  339.     $this->ticks += $s;
  340.     $this->_cache = array();
  341.   }
  342.  
  343.   /**
  344.   * round (down) the date-time to the current day
  345.   *
  346.   * sets the current YYY-MM-DD HH:MM:SS to YYYY-MM-DD 00:00:00
  347.   */
  348.   function dayRound() {
  349.     // this might look as though it would be faster by avoiding the expensive strtotime() call,
  350.     // (10000 reps took average 0.490s with PHP 4.4.2, libc6-2.3.6)
  351.     //    $this->setTimeParts(0,0,0,date('d', $this->ticks),date('m', $this->ticks),date('Y', $this->ticks));
  352.     // but this is actually faster.
  353.     // (10000 reps took average 0.385s with PHP 4.4.2, libc6-2.3.6; that's 21% faster)
  354.     $this->setStr($this->dateString());
  355.   }
  356.  
  357.   /**
  358.   * round (down) the date-time to the start of the current week (Sunday)
  359.   */
  360.   function weekRound() {
  361.     $this->dayRound();
  362.     $this->addDays(-1 * $this->dow());
  363.   }
  364.  
  365.   /**
  366.   * round (down) the date-time to the start of the current month (the 1st)
  367.   */
  368.   function monthRound() {
  369.     $this->dayRound();
  370.     $this->addDays(-1*$this->dom()+1);
  371.   }
  372.  
  373.   /**
  374.   * round (down) the date-time to the start of the current quarter (1st Jan, 1st Apr, 1st Jul, 1st Oct)
  375.   */
  376.   function quarterRound() {
  377.     $month = $this->moy();
  378.     $quarter = floor(($month-1)/3)*3+1;
  379.     $this->setTimeParts(0,0,0,1,$quarter,$this->year());
  380.   }
  381.  
  382.   /**
  383.   * round (down) the date-time to the start of the current year (1st Jan)
  384.   */
  385.   function yearRound() {
  386.     $this->dayRound();
  387.     $this->addDays(-1*$this->doy());
  388.   }
  389.  
  390.   /**
  391.   * returns the number of days between two dates ($this - $date)
  392.   * note that it will return fractional days across daylight saving boundaries
  393.   * @param SimpleDate $date date to subtract from this date
  394.   */
  395.   function daysBetween($date) {
  396.     return $this->subtract($date) / (24 * 60 * 60);
  397.   }
  398.  
  399.   /**
  400.   * returns the number of days between two dates ($this - $date) accounting for daylight saving
  401.   * @param SimpleDate $date date to subtract from this date
  402.   */
  403.   function dsDaysBetween($date) {
  404.     //Calculate the number of days as a fraction, removing fractions due to daylight saving
  405.     $numdays = $this->daysBetween($date);
  406.  
  407.     //We don't want to count an extra day (or part thereof) just because the day range
  408.     //includes going from summertime to wintertime so the date range includes an extra hour!
  409.  
  410.     $tz1 = date('Z', $this->ticks);
  411.     $tz2 = date('Z', $date->ticks);
  412.     if ($tz1 == $tz2) {
  413.       // same timezone, so return the computed amount
  414.       #echo "Using numdays $tz1 $tz2 ";
  415.       return $numdays;
  416.     } else {
  417.       // subtract the difference in the timezones to fix this
  418.       #echo "Using tzinfo: $tz1 $tz2 ";
  419.       return $numdays - ($tz2-$tz1) / (24*60*60);
  420.     }
  421.   }
  422.  
  423.   /**
  424.   * returns the number of days (or part thereof) between two dates ($this - $d)
  425.   * @param SimpleDate $date date to subtract from this date
  426.   */
  427.   function partDaysBetween($date) {
  428.     //we want this to be an integer and since we want "part thereof" we'd normally round up
  429.     //but daylight saving might cause problems....  We also have to include the part day at
  430.     //the beginning and the end
  431.  
  432.     $startwhole = $date;
  433.     $startwhole->dayRound();
  434.     $stopwhole = $this;
  435.     $stopwhole->ticks += 24*60*60-1;
  436. //     $stopwhole->_setStr();
  437.     $stopwhole->dayRound();
  438.  
  439.     return $stopwhole->dsDaysBetween($startwhole);
  440.   }
  441.  
  442.   /**
  443.   * returns the number of seconds between two times
  444.   * NB this does not specially account for daylight saving changes, so will not always give
  445.   * the 24*60*60 for two datetimes that are 1 day apart on the calendar...!
  446.   * @param SimpleDate $date date to subtract from this date
  447.   */
  448.   function subtract($date) {
  449.     #echo "$this->ticks - $date->ticks ";
  450.     return $this->ticks - $date->ticks;
  451.   }
  452.  
  453.   /**
  454.   * returns a SimpleTime object for just the time component of this date time
  455.   *
  456.   * @return SimpleTime object of just the HH:MM:SS component of this date
  457.   */
  458.   function timePart() {
  459.     $timestring = strftime('%H:%M:%S', $this->ticks);
  460.     return new SimpleTime($timestring);
  461.   }
  462.  
  463.   /**
  464.   * Sets the time component of this date-time to the specified time but with the same date as currently set
  465.   *
  466.   * The specified time can be HH:MM HH:MM:SS, seconds since midnight or a SimpleTime object
  467.   * @param mixed time to use
  468.   */
  469.   function setTime($s) {
  470.     //echo $this->dump().$s.'<br/>';
  471.  
  472.     // Benchmarks of 10000 calls to setTime($time)
  473.     //
  474.     // Original algorithm, dayRound() and then addTimeParts(); avg over 10 benchmark runs = 1.28s
  475.     // $this->dayRound();
  476.     // $time = new SimpleTime($s);
  477.     // $this->addTimeParts($time->part('s'), $time->part('i'), $time->part('H'), 0,0,0);
  478.  
  479.     // setTimeParts() directly; avg over 10 benchmark runs = 0.80s
  480.     $time = new SimpleTime($s);
  481.     //$this->setTimeParts(date('s', $time->ticks),date('i', $time->ticks),date('H', $time->ticks),
  482.     //                    date('d', $this->ticks),date('m', $this->ticks),date('Y', $this->ticks));
  483.     $this->setTimeParts($time->part('s'),        $time->part('i'),        $time->part('H'),
  484.                         date('d', $this->ticks), date('m', $this->ticks), date('Y', $this->ticks));
  485.  
  486.     return $this;
  487.   }
  488.  
  489.  
  490.   /**
  491.   * Sets this SimpleDate to the earlier of $this and $t
  492.   *
  493.   * @param SimpleDate $t 
  494.   */
  495.   function min($t) {
  496.     $this->setTicks(min($t->ticks, $this->ticks));
  497.   }
  498.  
  499.   /**
  500.   * Sets this SimpleDate to the later of $this and $t
  501.   *
  502.   * @param SimpleDate $t 
  503.   */
  504.   function max($t) {
  505.     $this->setTicks(max($t->ticks, $this->ticks));
  506.   }
  507.  
  508.   /**
  509.   * round time down to the nearest $g time-granularity measure
  510.   *
  511.   * Example: if this date time is set to 2005-11-21 17:48 and
  512.   * $g represents 00:15:00 (i.e. 15 minutes) then this date-time would
  513.   * be set to 2005-11-21 17:45 by rounding to the nearest 15 minutes.
  514.   *
  515.   * @param SimpleTime $g 
  516.   */
  517.   function floorTime($g) {
  518.     $tp = $this->timePart();
  519.     $tp->floorTime($g);
  520.     $this->setTime($tp->timeString());
  521.   }
  522.  
  523.   /**
  524.   * Add components to the current date-time
  525.   *
  526.   * Note that this function will take account of daylight saving in unusual (but quite sensible)
  527.   * ways... for example, if $today is a SimpleDate object representing midday the day before
  528.   * daylight saving ends, then $today->addTimeParts(24*60*60) will give a different result
  529.   * to $today->addTimeParts(0,0,0,1). The former will be exactly 24 hours later than the original
  530.   * value of $today (11:00), but the latter will 1 calendar day later (12:00).
  531.   *
  532.   * @param integer $sec  (optional) number of seconds to add to this date-time
  533.   * @param integer $min  (optional) number of minutes to add to this date-time
  534.   * @param integer $hour (optional) number of hours to add to this date-time
  535.   * @param integer $day  (optional) number of days to add to this date-time
  536.   * @param integer $month  (optional) number of months to add to this date-time
  537.   * @param integer $year  (optional) number of years to add to this date-time
  538.   */
  539.   function addTimeParts($sec=0, $min=0, $hour=0, $day=0, $month=0, $year=0) {
  540.     $this->ticks = mktime(
  541.                             date('H',$this->ticks) + $hour,
  542.                             date('i',$this->ticks) + $min,
  543.                             date('s',$this->ticks) + $sec,
  544.                             date('m',$this->ticks) + $month,
  545.                             date('d',$this->ticks) + $day,
  546.                             date('y',$this->ticks) + $year
  547.                         );
  548.     $this->_cache = array();
  549.   }
  550.  
  551.   /**
  552.   * Set current date-time by components
  553.   *
  554.   * @param integer $sec  (optional) seconds to set
  555.   * @param integer $min  (optional) minutes to set
  556.   * @param integer $hour (optional) hours to add set
  557.   * @param integer $day  (optional) days to add set
  558.   * @param integer $month  (optional) months to set
  559.   * @param integer $year  (optional) years to set
  560.   */
  561.   function setTimeParts($sec=0, $min=0, $hour=0, $day=0, $month=0, $year=0) {
  562.     $this->ticks = mktime(
  563.                             $hour,
  564.                             $min,
  565.                             $sec,
  566.                             $month,
  567.                             $day,
  568.                             $year
  569.                         );
  570.     $this->_cache = array();
  571.   }
  572.  
  573.   /**
  574.   * return the day of week of the current date.
  575.   * @return integer day of week (0 == Sunday, 6 == Saturday)
  576.   */
  577.   function dow() {
  578.     return date('w', $this->ticks);
  579.   }
  580.  
  581.   /**
  582.   * return the day of week of the current date as a string (in current language)
  583.   * @return string day of week (Sunday, Monday, etc)
  584.   */
  585.   function dowStr() {
  586.     return $this->_T_(date('l', $this->ticks));
  587.   }
  588.  
  589.   /**
  590.   * return the (short) day of week of the current date as a string (in current language)
  591.   * @return string day of week (Sun, Mon, etc)
  592.   */
  593.   function dowShortStr() {
  594.     return $this->_T_(date('D', $this->ticks));
  595.   }
  596.  
  597.   /**
  598.   * return the day of month
  599.   * @return integer day of month (1..31)
  600.   */
  601.   function dom() {
  602.     return intval(date('d', $this->ticks));  // use intval to remove the leading zero
  603.   }
  604.  
  605.   /**
  606.   * return integer month of year (1..12)
  607.   * @return integer month of year (1..12)
  608.   */
  609.   function moy() {
  610.     return date('m', $this->ticks);
  611.   }
  612.  
  613.   /**
  614.   * return the month of year of the current date as a string (in current language)
  615.   * @return string month of the year (January, February etc)
  616.   */
  617.   function moyStr() {
  618.     return $this->_T_(date('F', $this->ticks));
  619.   }
  620.  
  621.   /**
  622.   * return the (short) month of the year of the current date as a string (in current language)
  623.   * @return string month of the year (Jan, Feb etc)
  624.   */
  625.   function moyShortStr() {
  626.     return $this->_T_(date('M', $this->ticks));
  627.   }
  628.  
  629.   /**
  630.   * day of year (0..365)
  631.   * returns 365 only in leap years
  632.   * @return integer day of year (0..365)
  633.   */
  634.   function doy() {
  635.     return date('z', $this->ticks);
  636.   }
  637.  
  638.   /**
  639.   * four-digit year (YYYY)
  640.   * @return integer year (e.g. 2005)
  641.   */
  642.   function year() {
  643.     return date('Y', $this->ticks);
  644.   }
  645.  
  646.   /**
  647.   * dump the datetimestring and ticks in a readable format
  648.   * @param boolean $html (optional) use html line endings
  649.   * @return string datetimestring and ticks
  650.   */
  651.   function dump($html=1) {
  652.     $s = 'ticks = ' . $this->ticks . ', ' . $this->dateTimeString();
  653.     $s .= ($html ? '<br />' : '') . "\n";
  654.     return $s;
  655.   }
  656.  
  657.   /**
  658.   * translate an individual date-related word (day of week, month of year)
  659.   *
  660.   * @param string   $word    word to translate
  661.   * @returns string          translated word
  662.   */
  663.   function _T_($word) {
  664.     $i18n = date_make_translation_array();
  665.     return $i18n[$word];
  666.   }
  667.  
  668. } // class SimpleDate
  669.  
  670.  
  671. /**
  672. * Simple time class to perform basic time calculations
  673. *
  674. * @package    Bumblebee
  675. * @subpackage Misc
  676. */
  677. class SimpleTime {
  678.   /**
  679.   * cache of string formatted data
  680.   * @var array 
  681.   */
  682.   var $_cache = array();
  683.   /**
  684.   * current time in integer seconds since midnight
  685.   * @var integer 
  686.   */
  687.   var $ticks = '';
  688.   /**
  689.   * is set to a valid value
  690.   * @var boolean 
  691.   */
  692.   var $isValid = 1;
  693.  
  694.   /**
  695.   * Constructor for class
  696.   *
  697.   * Accepts the following for the initial time:
  698.   * - HH:MM:SS
  699.   * - HH:MM  (assumes :00 for seconds part)
  700.   * - SimpleTime object
  701.   */
  702.   function SimpleTime($time) {
  703.     #echo "New SimpleTime: $time, $type<br />";
  704.     if (is_numeric($time)) {
  705.       $this->setTicks($time);
  706.     } elseif (type_is_a($time, 'SimpleTime')) {
  707.       $this->setTicks($time->ticks);
  708.     } else {
  709.       $this->setStr($time);
  710.     }
  711.   }
  712.  
  713.   /**
  714.   * Set time by a string
  715.   */
  716.   function setStr($s) {
  717.     $this->_setTicks($s);
  718.     //$this->_setStr();
  719.   }
  720.  
  721.   function timeString() {
  722.     if (! isset($this->_cache['time'])) {
  723.       $this->_cache['time'] = sprintf('%02d:%02d', $this->ticks/3600, ($this->ticks%3600)/60);;
  724.     }
  725.     return $this->_cache['time'];
  726.   }
  727.  
  728.   /**
  729.   * Set time by seconds since midnight
  730.   */
  731.   function setTicks($t) {
  732.     $this->ticks = $t;
  733.     $this->_cache = array();
  734.   }
  735.  
  736.   function _setTicks($s) {
  737.     if (preg_match('/^(\d\d):(\d\d):(\d\d)$/', $s, $t)) {
  738.       #preDump($t);
  739.       $this->ticks = $t[1]*3600+$t[2]*60+$t[3];
  740.     } elseif (preg_match('/^(\d\d):(\d\d)$/', $s, $t) || preg_match('/^(\d):(\d\d)$/', $s, $t)) {
  741.       #preDump($t);
  742.       $this->ticks = $t[1]*3600+$t[2]*60;
  743.     } else {
  744.       $this->ticks = 0;
  745.       $this->inValid = 0;
  746.     }
  747.     $this->_cache = array();
  748.   }
  749.  
  750.   /**
  751.   * subtract seconds $this -  $other
  752.   * @param SimpleTime $other 
  753.   * @return integer seconds difference
  754.   */
  755.   function subtract($other) {
  756.     return $this->ticks - $other->ticks;
  757.   }
  758.  
  759.   /**
  760.   * add seconds to this time
  761.   * @param integer $s 
  762.   */
  763.   function addSecs($s) {
  764.     $this->ticks += $s;
  765.     $this->_cache = array();
  766.   }
  767.  
  768.   /**
  769.   * return current seconds
  770.   * @return integer current seconds since midnight
  771.   */
  772.   function seconds() {
  773.     return $this->ticks;
  774.   }
  775.  
  776.   /**
  777.   * set this value to the earlier of $this and $other
  778.   * @param SimpleTime $other 
  779.   */
  780.   function min($other) {
  781.     $this->setTicks(min($other->ticks, $this->ticks));
  782.   }
  783.  
  784.   /**
  785.   * set this value to the later of $this and $other
  786.   * @param SimpleTime $other 
  787.   */
  788.   function max($t) {
  789.     $this->setTicks(max($t->ticks, $this->ticks));
  790.   }
  791.  
  792.   /**
  793.   * get a string representation that includes the number of seconds
  794.   * @return string time value in HH:MM:SS format
  795.   */
  796.   function getHMSstring() {
  797.     return sprintf('%02d:%02d:%02d', $this->ticks/3600, ($this->ticks%3600)/60, $this->ticks%60);
  798.   }
  799.  
  800.   /**
  801.   * get a short string representation for the current locale
  802.   *
  803.   * @return string time value in short time format
  804.   */
  805.   function getShortString() {
  806.     if (! isset($this->_cache['short'])) {
  807.       $conf = ConfigReader::getInstance();
  808.       $format = $conf->value('language', 'date_shorttime', 'H:i');
  809.       $this->_cache['short'] = $this->getStringByFormat($format);
  810.     }
  811.     return $this->_cache['short'];
  812.   }
  813.  
  814.   /**
  815.   * get a long string representation for the current locale
  816.   *
  817.   * @return string time value in long time format
  818.   */
  819.   function getLongString() {
  820.     if (! isset($this->_cache['long'])) {
  821.       $conf = ConfigReader::getInstance();
  822.       $format = $conf->value('language', 'date_longtime', 'H:i:s');
  823.       $this->_cache['long'] = $this->getStringByFormat($format);
  824.     }
  825.     return $this->_cache['long'];
  826.   }
  827.  
  828.   /**
  829.   * Get a string representation of this time in the specified format
  830.   *
  831.   * Recognised format characters are as follows:
  832.   *
  833.   * a    Lowercase Ante meridiem and Post meridiem    am or pm
  834.   * A    Uppercase Ante meridiem and Post meridiem    AM or PM
  835.   * g    12-hour format of an hour without leading zeros    1 through 12
  836.   * G    24-hour format of an hour without leading zeros    0 through 23
  837.   * h    12-hour format of an hour with leading zeros    01 through 12
  838.   * H    24-hour format of an hour with leading zeros    00 through 23
  839.   * i    Minutes with leading zeros    00 to 59
  840.   * s    Seconds, with leading zeros    00 through 59
  841.   *
  842.   * @return string time value in short time format
  843.   */
  844.   function getStringByFormat($format) {
  845.     // cache the AM/PM data to reduce time spent in i18n function
  846.     static $i18n = null;
  847.     if ($i18n === null) {
  848.       $i18n = array();
  849.       $i18n['am'] = T_('am');
  850.       $i18n['AM'] = T_('AM');
  851.       $i18n['pm'] = T_('pm');
  852.       $i18n['PM'] = T_('PM');
  853.     }
  854.  
  855.     $s = '';  // return string
  856.         $c = '';  // current character
  857.         $p = '';  // previous character
  858.  
  859.     #print "Analysing $format";
  860.         $formatLen = strlen($format);
  861.     for ($i=0; $i<$formatLen; $i++) {
  862.       $c = $format[$i];
  863.       if ($i > 0 && $format[$i-1] == '\\') {
  864.         $s .= $c;
  865.         next;
  866.       }
  867.       #print " $i: $c ($s)...";
  868.  
  869.       switch ($c) {
  870.         case 'a':
  871.           $s .= $i18n[$this->part('a')];
  872.           break;
  873.         case 'A':
  874.           $s .= $i18n[$this->part('A')];
  875.           break;
  876.         case 'g':
  877.           $s .= ($this->part('h')-1) % 12 + 1;
  878.           break;
  879.         case 'G':
  880.           $s .= $this->part('h');
  881.           break;
  882.         case 'h':
  883.           $s .= sprintf('%02d', ($this->part('h')-1) % 12 + 1);
  884.           break;
  885.         case 'H':
  886.           $s .= sprintf('%02d', $this->part('h'));
  887.           break;
  888.         case 'i':
  889.           $s .= sprintf('%02d', $this->part('i'));
  890.           break;
  891.         case 's':
  892.           $s .= sprintf('%02d', $this->part('s'));
  893.           break;
  894.         case '\\':
  895.           break;
  896.         default:
  897.           $s .= $c;
  898.           break;
  899.       }
  900.       #print " $s<br />";
  901.     }
  902.     return $s;
  903.   }
  904.  
  905.   /**
  906.   * round time down to the nearest $g time-granularity measure
  907.   *
  908.   * @see SimpleDate::floorTime()
  909. timestring = '';
  910. //     $this->_setStr();  * @param SimpleTime $g time granularity
  911.   */
  912.   function floorTime($g) {
  913.     $gt = $g->seconds();
  914.     $this->setTicks(floor(($this->ticks+1)/$gt)*$gt);
  915.   }
  916.  
  917.   /**
  918.   * round time up to the nearest $g time-granularity measure
  919.   *
  920.   * @see SimpleTime::floorTime()
  921.   * @param SimpleTime $g time granularity
  922.   */
  923.   function ceilTime($g) {
  924.     $gt = $g->seconds();
  925.     $this->setTicks(ceil(($this->ticks-1)/$gt)*$gt);
  926.   }
  927.  
  928.   /**
  929.   * Obtain hour, minute or seconds parts of the time
  930.   *
  931.   * return hour, minute or seconds parts of the time, emulating the date('H', $ticks) etc
  932.   * functions, but not using them as they get too badly confused with timezones to be useful
  933.   * in many situations
  934.   *
  935.   * @param char $s time part to obtain (valid parts: h, i, s for hours, mins, secs)
  936.   * @return integer part of the time
  937.   */
  938.   function part($s) {
  939.     switch ($s) {
  940.       //we don't actually care about zero padding in this case.
  941.       case 'H':
  942.       case 'h':
  943.         return floor($this->ticks/(3600));
  944.       //let's just allow 'm' to give minutes as well, as it's easier
  945.       case 'i':
  946.       case 'm':
  947.         return floor(($this->ticks%3600) / 60);
  948.       case 's':
  949.         return floor($this->ticks % 60);
  950.       case 'a':
  951.         return ($this->ticks % 86400 < 43200) ? 'am' : 'pm';
  952.       case 'A':
  953.         return ($this->ticks % 86400 < 43200) ? 'AM' : 'PM';
  954.     }
  955.     //we can't use this as we're not actually using the underlying date-time types here.
  956.     //return date($s, $this->ticks);
  957.   }
  958.  
  959.   /**
  960.   * Add another time to this time
  961.   *
  962.   * @param SimpleTime $t time to add to this one
  963.   */
  964.   function addTime($t) {
  965.     $this->ticks += $t->ticks;
  966.     $this->_cache = array();
  967.   }
  968.  
  969.   /**
  970.   * dump the timestring and ticks in a readable format
  971.   * @param boolean $html (optional) use html line endings
  972.   * @return string timestring and ticks
  973.   */
  974.   function dump($html=1) {
  975.     $s = 'ticks = ' . $this->ticks . ', ' . $this->timeString();
  976.     $s .= ($html ? '<br />' : '') . "\n";
  977.     return $s;
  978.   }
  979. } // class SimpleTime
  980.  
  981.  
  982. // We need to define these just so that the date formatting routines can always
  983. // return English names for the days and dates and the translation layer will
  984. // provide the correct translation. We can't just use setlocale() and strftime()
  985. // to do this because they only work if the locale is installed on the server and
  986. // this is frequently not the case (which is why we are using gettext emulation
  987. // to begin with!)
  988. function date_make_translation_array() {
  989.   static $i18n = null;
  990.  
  991.   if ($i18n !== null) return $i18n;
  992.  
  993.   $i18n = array();
  994.   $i18n['Monday']    = T_('Monday');
  995.   $i18n['Mon']       = T_('Mon');
  996.   $i18n['Tuesday']   = T_('Tuesday');
  997.   $i18n['Tue']       = T_('Tue');
  998.   $i18n['Tues']      = T_('Tue');
  999.   $i18n['Wednesday'] = T_('Wednesday');
  1000.   $i18n['Wed']       = T_('Wed');
  1001.   $i18n['Thursday']  = T_('Thursday');
  1002.   $i18n['Thu']       = T_('Thu');
  1003.   $i18n['Thurs']     = T_('Thu');
  1004.   $i18n['Friday']    = T_('Friday');
  1005.   $i18n['Fri']       = T_('Fri');
  1006.   $i18n['Saturday']  = T_('Saturday');
  1007.   $i18n['Sat']       = T_('Sat');
  1008.   $i18n['Sunday']    = T_('Sunday');
  1009.   $i18n['Sun']       = T_('Sun');
  1010.  
  1011.   $i18n['January']   = T_('January');
  1012.   $i18n['Jan']       = T_('Jan');
  1013.   $i18n['February']  = T_('February');
  1014.   $i18n['Feb']       = T_('Feb');
  1015.   $i18n['March']     = T_('March');
  1016.   $i18n['Mar']       = T_('Mar');
  1017.   $i18n['April']     = T_('April');
  1018.   $i18n['Apr']       = T_('Apr');
  1019.   $i18n['May']       = T_('May');
  1020.   $i18n['June']      = T_('June');
  1021.   $i18n['Jun']       = T_('Jun');
  1022.   $i18n['July']      = T_('July');
  1023.   $i18n['Jul']       = T_('Jul');
  1024.   $i18n['August']    = T_('August');
  1025.   $i18n['Aug']       = T_('Aug');
  1026.   $i18n['September'] = T_('September');
  1027.   $i18n['Sep']       = T_('Sep');
  1028.   $i18n['October']   = T_('October');
  1029.   $i18n['Oct']       = T_('Oct');
  1030.   $i18n['November']  = T_('November');
  1031.   $i18n['Nov']       = T_('Nov');
  1032.   $i18n['December']  = T_('December');
  1033.   $i18n['Dec']       = T_('Dec');
  1034.  
  1035.   $i18n['am'] = T_('am');
  1036.   $i18n['AM'] = T_('AM');
  1037.   $i18n['pm'] = T_('pm');
  1038.   $i18n['PM'] = T_('PM');
  1039.  
  1040.   return $i18n;
  1041. }
  1042.  
  1043. ?>

Documentation generated on Tue, 06 Mar 2007 10:01:12 +0000 by phpDocumentor 1.3.0