示例#1
0
 /**
  * AgaviTimeZone API.
  * 
  * @see        AgaviTimeZone::useDaylightTime()
  *
  * @author     Dominik del Bondio <*****@*****.**>
  * @author     The ICU Project
  * @since      0.11.0
  */
 public function useDaylightTime()
 {
     // If DST was observed in 1942 (for example) but has never been
     // observed from 1943 to the present, most clients will expect
     // this method to return FALSE.  This method determines whether
     // DST is in use in the current year (at any point in the year)
     // and returns TRUE if so.
     $days = floor(AgaviCalendar::getNow() / AgaviDateDefinitions::MILLIS_PER_DAY);
     // epoch days
     $year = 0;
     $month = 0;
     $dom = 0;
     $dow = 0;
     AgaviCalendarGrego::dayToFields($days, $year, $month, $dom, $dow);
     if ($year > $this->finalYear) {
         // [sic] >, not >=; see above
         if ($this->finalZone) {
             return $this->finalZone->useDaylightTime();
         } else {
             return true;
         }
     }
     // Find start of this year, and start of next year
     $start = (int) AgaviCalendarGrego::fieldsToDay($year, 0, 1) * AgaviDateDefinitions::SECONDS_PER_DAY;
     $limit = (int) AgaviCalendarGrego::fieldsToDay($year + 1, 0, 1) * AgaviDateDefinitions::SECONDS_PER_DAY;
     // Return TRUE if DST is observed at any time during the current year.
     for ($i = 0, $transitionCount = count($this->transitions); $i < $transitionCount; ++$i) {
         if ($this->transitions[$i]['time'] >= $limit) {
             break;
         }
         if ($this->transitions[$i]['time'] >= $start && $this->types[$this->transitions[$i]['type']]['dstOffset'] != 0 || $this->transitions[$i]['time'] > $start && $i > 0 && $this->types[$this->transitions[$i - 1]['type']]['dstOffset'] != 0) {
             return true;
         }
     }
     return false;
 }
 /**
  * Gets the time zone offset, for current date, modified in case of
  * daylight savings. This is the offset to add *to* UTC to get local time.
  * 
  * @param      int The era of the given date.
  * @param      int The year in the given date.
  * @param      int The month in the given date.
  *                 Month is 0-based. e.g., 0 for January.
  * @param      int The day-in-month of the given date.
  * @param      int The day-of-week of the given date.
  * @param      int The millis in day in <em>standard</em> local time.
  * @param      int The length of the given month in days.
  * 
  * @return     int The offset to add *to* GMT to get local time.
  * 
  * @author     Dominik del Bondio <*****@*****.**>
  * @author     The ICU Project
  * @since      0.11.0
  */
 public function getOffsetIIIIIII($era, $year, $month, $day, $dayOfWeek, $millis, $monthLength)
 {
     // Check the month before calling Grego::monthLength(). This
     // duplicates a test that occurs in the 9-argument getOffset(),
     // however, this is unavoidable. We don't mind because this method, in
     // fact, should not be called; internal code should always call the
     // 9-argument getOffset(), and outside code should use Calendar.get(int
     // field) with fields ZONE_OFFSET and DST_OFFSET. We can't get rid of
     // this method because it's public API. - liu 8/10/98
     if ($month < AgaviDateDefinitions::JANUARY || $month > AgaviDateDefinitions::DECEMBER) {
         throw new InvalidArgumentException('Month out of range');
         return -1;
     }
     // We ignore monthLength because it can be derived from year and month.
     // This is so that February in leap years is calculated correctly.
     // We keep this argument in this function for backwards compatibility.
     return $this->getOffsetIIIIIIII($era, $year, $month, $day, $dayOfWeek, $millis, AgaviCalendarGrego::monthLength($year, $month), AgaviCalendarGrego::previousMonthLength($year, $month));
 }
 /**
  * Returns the time zone raw and GMT offset for the given moment
  * in time.  Upon return, local-millis = GMT-millis + rawOffset +
  * dstOffset.  All computations are performed in the proleptic
  * Gregorian calendar.  The default implementation in the TimeZone
  * class delegates to the 8-argument getOffset().
  *
  * @param      float Moment in time for which to return offsets, in units of 
  *                   milliseconds from January 1, 1970 0:00 GMT, either GMT
  *                   time or local wall time, depending on `local'.
  * @param      bool  If true, `date' is local wall time; otherwise it
  *                   is in GMT time.
  * @param      int   Output parameter to receive the raw offset, that is, the
  *                   offset not including DST adjustments
  * @param      int   Output parameter to receive the DST offset, that is, the 
  *                   offset to be added to `rawOffset' to obtain the total 
  *                   offset between local and GMT time. If DST is not in 
  *                   effect, this value is zero; otherwise it is a positive 
  *                   value, typically one hour.
  * 
  * @author     Dominik del Bondio <*****@*****.**>
  * @author     The ICU Project
  * @since      0.11.0
  */
 public function getOffsetRef($date, $local, &$rawOffset, &$dstOffset)
 {
     $rawOffset = $this->getRawOffset();
     // Convert to local wall millis if necessary
     if (!$local) {
         $date += $rawOffset;
         // now in local standard millis
     }
     // When local==FALSE, we might have to recompute. This loop is
     // executed once, unless a recomputation is required; then it is
     // executed twice.
     for ($pass = 0; true; ++$pass) {
         $year = $month = $dom = $dow = 0;
         $day = floor($date / AgaviDateDefinitions::MILLIS_PER_DAY);
         $millis = (int) ($date - $day * AgaviDateDefinitions::MILLIS_PER_DAY);
         AgaviCalendarGrego::dayToFields($day, $year, $month, $dom, $dow);
         $dstOffset = $this->getOffsetIIIIIII(AgaviGregorianCalendar::AD, $year, $month, $dom, $dow, $millis, AgaviCalendarGrego::monthLength($year, $month)) - $rawOffset;
         // Recompute if local==FALSE, dstOffset!=0, and addition of
         // the dstOffset puts us in a different day.
         if ($pass != 0 || $local || $dstOffset == 0) {
             break;
         }
         $date += $dstOffset;
         if (floor($date / AgaviDateDefinitions::MILLIS_PER_DAY) == $day) {
             break;
         }
     }
 }
 /**
  * Returns the time specified by the input arguments.
  *
  * @param      int The year.
  * @param      int The month.
  * @param      array The date definition.
  * @param      array The at (time into the day) definition.
  * @param      int The gmt offset.
  * @param      int The dst offset.
  *
  * @return     int The unix timestamp.
  *
  * @author     Dominik del Bondio <*****@*****.**>
  * @since      0.11.0
  */
 protected function getOnDate($year, $month, $dateDef, $atDef, $gmtOff, $dstOff)
 {
     static $cal = null;
     if (!$cal) {
         $cal = $this->getContext()->getTranslationManager()->createCalendar();
     }
     $cal->clear();
     $cal->set(AgaviDateDefinitions::YEAR, $year);
     $cal->set(AgaviDateDefinitions::MONTH, $month);
     if ($dateDef['type'] == 'date') {
         $cal->set(AgaviDateDefinitions::DATE, $dateDef['date']);
     } elseif ($dateDef['type'] == 'last') {
         $daysInMonth = AgaviCalendarGrego::monthLength($year, $month);
         $cal->set(AgaviDateDefinitions::DATE, $daysInMonth);
         // loop backwards until we found the last occurrence of the day
         while ($cal->get(AgaviDateDefinitions::DAY_OF_WEEK) != $dateDef['day']) {
             $cal->roll(AgaviDateDefinitions::DATE, -1);
         }
     } elseif ($dateDef['type'] == '<=') {
         $cal->set(AgaviDateDefinitions::DATE, $dateDef['date']);
         while ($cal->get(AgaviDateDefinitions::DAY_OF_WEEK) != $dateDef['day']) {
             $cal->roll(AgaviDateDefinitions::DATE, -1);
         }
     } elseif ($dateDef['type'] == '>=') {
         $cal->set(AgaviDateDefinitions::DATE, $dateDef['date']);
         while ($cal->get(AgaviDateDefinitions::DAY_OF_WEEK) != $dateDef['day']) {
             $cal->roll(AgaviDateDefinitions::DATE, 1);
         }
     } else {
         throw new AgaviException('Unknown on type ' . $dateDef['type']);
     }
     $time = $cal->getTime() / 1000;
     $time += $atDef['secondsInDay'];
     if ($atDef['type'] == 'wallclock') {
         $time -= $dstOff;
         $time -= $gmtOff;
     } elseif ($atDef['type'] == 'standard') {
         $time -= $gmtOff;
     }
     return $time;
 }
 /**
  * Compute the julian day number of the given year.
  * 
  * @param      bool   If true, using Gregorian calendar, otherwise using 
  *                    Julian calendar.
  * @param      int    The given year.
  * @param      bool   True if the year is a leap year.
  * 
  * @return     double 
  * 
  * @author     Dominik del Bondio <*****@*****.**>
  * @author     The ICU Project
  * @since      0.11.0
  */
 private static function computeJulianDayOfYear($isGregorian, $year, &$isLeap)
 {
     $isLeap = $year % 4 == 0;
     $y = $year - 1;
     $julianDay = 365.0 * $y + floor($y / 4) + (AgaviDateDefinitions::JAN_1_1_JULIAN_DAY - 3);
     if ($isGregorian) {
         $isLeap = $isLeap && ($year % 100 != 0 || $year % 400 == 0);
         // Add 2 because Gregorian calendar starts 2 days after Julian calendar
         $julianDay += AgaviCalendarGrego::gregorianShift($year);
     }
     return $julianDay;
 }
示例#6
0
 /**
  * Compute the Gregorian calendar year, month, and day of month from the
  * Julian day.  These values are not stored in fields, but in member
  * variables gregorianXxx.  They are used for time zone computations and by
  * subclasses that are Gregorian derivatives.  Subclasses may call this
  * method to perform a Gregorian calendar millis->fields computation.
  * To perform a Gregorian calendar fields->millis computation, call
  * computeGregorianMonthStart().
  * @see #computeGregorianMonthStart
  *
  * @param      int The julian day
  *
  * @author     Dominik del Bondio <*****@*****.**>
  * @author     The ICU Project
  * @since      0.11.0
  */
 private function computeGregorianFields($julianDay)
 {
     $gregorianDayOfWeekUnused = 0;
     AgaviCalendarGrego::dayToFields($julianDay - AgaviDateDefinitions::EPOCH_START_AS_JULIAN_DAY, $this->fGregorianYear, $this->fGregorianMonth, $this->fGregorianDayOfMonth, $gregorianDayOfWeekUnused, $this->fGregorianDayOfYear);
 }