GregorianCalendar - Code Metrics - horros/agavi2 - Measure and Improve Code Quality continuously with Scrutinizer

GregorianCalendar D
last analyzed 2017-05-30 13:20 UTC

↳ Parent: Project
Complexity

Total Complexity
115
Size/Duplication

Total Lines	1173
Duplicated Lines	2.9 %
Coupling/Cohesion

Components	1
Dependencies	5
Importance

Changes
Metric	Value
dl	34
loc	1173
rs	4.4102
c	0
b	0
f	0
wmc	115
lcom	1
cbo	5
42 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	33	1
A	initVariables()	0	11	1
B	constructorO()	0	25	4
A	constructorOO()	0	6	1
A	constructorOIII()	0	8	1
A	constructorOIIIII()	10	10	1
A	constructorOIIIIII()	11	11	1
B	setGregorianChange()	0	35	4
A	getGregorianChange()	0	4	1
A	isLeapYear()	0	8	2
A	isEquivalentTo()	0	5	2
A	getActualMinimum()	0	4	1
B	getActualMaximum()	0	73	5
A	inDaylightTime()	0	11	2
A	internalGetEra()	0	4	2
D	handleComputeMonthStart()	8	36	9
D	handleComputeJulianDay()	0	33	9
A	handleGetMonthLength()	0	10	4
A	handleGetYearLength()	0	4	2
A	monthLength()	0	5	1
A	monthLength1()	0	4	2
A	yearLength1()	0	4	2
A	yearLength()	0	4	2
A	pinDayOfMonth()	0	8	2
A	getEpochDay()	0	9	1
A	handleGetLimit()	0	4	1
B	handleGetExtendedYear()	0	30	5
A	handleGetExtendedYearFromWeekFields()	0	9	2
B	handleComputeFields()	0	55	9
A	computeJulianDayOfYear()	5	14	4
C	validateFields()	0	38	14
A	boundsCheck()	0	4	2
A	aggregateStamp()	0	7	3
A	millisToJulianDay()	0	4	1
A	julianDayToMillis()	0	4	1
A	haveDefaultCentury()	0	4	1
A	defaultCenturyStart()	0	4	1
A	defaultCenturyStartYear()	0	4	1
A	getType()	0	4	1
A	internalGetDefaultCenturyStart()	0	14	2
A	internalGetDefaultCenturyStartYear()	0	14	2
A	initializeSystemDefaultCentury()	0	17	2
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like GregorianCalendar often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use GregorianCalendar, and based on these observations, apply Extract Interface, too.
<?php

// +---------------------------------------------------------------------------+
// | This file is part of the Agavi package.                                   |
// | Copyright (c) 2005-2011 the Agavi Project.                                |
// |                                                                           |
// | For the full copyright and license information, please view the LICENSE   |
// | file that was distributed with this source code. You can also view the    |
// | LICENSE file online at http://www.agavi.org/LICENSE.txt                   |
// |   vi: set noexpandtab:                                                    |
// |   Local Variables:                                                        |
// |   indent-tabs-mode: t                                                     |
// |   End:                                                                    |
// +---------------------------------------------------------------------------+

namespace Agavi\Date;

use Agavi\Translation\Locale;
use Agavi\Translation\TranslationManager;
use Agavi\Util\Toolkit;

/**
 * Ported from ICU:
 *  icu/trunk/source/i18n/gregocal.cpp        r22379
 *  icu/trunk/source/i18n/unicode/gregocal.h  r19003
 *
 * @package    agavi
 * @subpackage date
 *
 * @author     Dominik del Bondio <[email protected]>
 * @author     The ICU Project
 * @copyright  Authors
 * @copyright  The Agavi Project
 *
 * @since      0.11.0
 *
 * @version    $Id$
 */
class GregorianCalendar extends Calendar
{
    const CUTOVER_JULIAN_DAY = 2299161;
    //const kPapalCutover = (2299161.0 - kEpochStartAsJulianDay) * AgaviDateDefinitions::MILLIS_PER_DAY;
    const PAPAL_CUTOVER      = -12219292800000.0;

    /**
     * Overloaded.
     *
     * @see        AgaviGregorianCalendar::constructorO()
     * @see        AgaviGregorianCalendar::constructorOO()
     * @see        AgaviGregorianCalendar::constructorOIII()
     * @see        AgaviGregorianCalendar::constructorOIIIII()
     * @see        AgaviGregorianCalendar::constructorOIIIIII()
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function __construct()
    {
        $this->initVariables();

        $arguments = func_get_args();

        $fName = Toolkit::overloadHelper(
            array(
                array(
                    'name' => 'constructorO',
                    'parameters' => array('object')
                ),
                array(
                    'name' => 'constructorOO',
                    'parameters' => array('object', 'object')
                    ),
                array(
                    'name' => 'constructorOIII',
                    'parameters' => array('object', 'int', 'int', 'int')
                ),
                array(
                    'name' => 'constructorOIIIII',
                    'parameters' => array('object', 'int', 'int', 'int', 'int', 'int')
                ),
                array(
                    'name' => 'constructorOIIIIII',
                    'parameters' => array('object', 'int', 'int', 'int', 'int', 'int', 'int')
                ),
            ),
            $arguments
        );
        call_user_func_array(array($this, $fName), $arguments);
    }

    /**
     * Initialize all variables to default values.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function initVariables()
    {
        parent::initVariables();

        $this->fGregorianCutover = self::PAPAL_CUTOVER;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $this->fCutoverJulianDay = self::CUTOVER_JULIAN_DAY;
        $this->fNormalizedGregorianCutover = $this->fGregorianCutover;
$answer = 42;

$correct = false;

$correct = (bool) $answer;
        $this->fGregorianCutoverYear = 1582;
        $this->fIsGregorian = true;
        $this->fInvertGregorian = false;
    }

    /**
     * Constructor.
     *
     * @param      TimeZone|Locale|TranslationManager
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function constructorO($zoneOrLocale)
    {
        $zone = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $locale = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        if ($zoneOrLocale instanceof TimeZone) {
            $this->translationManager = $zoneOrLocale->getTranslationManager();
            $zone = $zoneOrLocale;
            $locale = $this->translationManager->getCurrentLocale();
        } elseif ($zoneOrLocale instanceof Locale) {
            $this->translationManager = $zoneOrLocale->getTranslationManager();

            $zone = $this->translationManager->getDefaultTimeZone();
            $locale = $zoneOrLocale;
        } elseif ($zoneOrLocale instanceof TranslationManager) {
            $this->translationManager = $zoneOrLocale;
            $zone = $this->translationManager->getDefaultTimeZone();
            $locale = $this->translationManager->getCurrentLocale();
        } else {
            throw new \InvalidArgumentException('Object of type ' . get_class($zoneOrLocale) . ' was not expected');
        }
        parent::constructorOO($zone, $locale);
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

        $this->setTimeInMillis(self::getNow());
        $this->set(DateDefinitions::ERA, self::AD);
    }

    /**
     * Constructor.
     *
     * @param      TimeZone $zone
     * @param      Locale   $locale
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function constructorOO(TimeZone $zone, Locale $locale)
    {
        parent::constructorOO($zone, $locale);
        $this->setTimeInMillis(self::getNow());
        $this->set(DateDefinitions::ERA, self::AD);
    }

    /**
     * Constructor.
     *
     * @param      TranslationManager $tm
     * @param      int $year
     * @param      int $month
     * @param      int $date
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function constructorOIII(TranslationManager $tm, $year, $month, $date)
    {
        parent::constructorOO($tm->getDefaultTimeZone(), $tm->getCurrentLocale());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
        $this->set(DateDefinitions::ERA, self::AD);
        $this->set(DateDefinitions::YEAR, $year);
        $this->set(DateDefinitions::MONTH, $month);
        $this->set(DateDefinitions::DATE, $date);
    }

    /**
     * Constructor.
     *
     * @param      TranslationManager $tm
     * @param      int $year
     * @param      int $month
     * @param      int $date
     * @param      int $hour
     * @param      int $minute
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function constructorOIIIII(TranslationManager $tm, $year, $month, $date, $hour, $minute)

    {
        parent::constructorOO($tm->getDefaultTimeZone(), $tm->getCurrentLocale());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
        $this->set(DateDefinitions::ERA, self::AD);
        $this->set(DateDefinitions::YEAR, $year);
        $this->set(DateDefinitions::MONTH, $month);
        $this->set(DateDefinitions::DATE, $date);
        $this->set(DateDefinitions::HOUR_OF_DAY, $hour);
        $this->set(DateDefinitions::MINUTE, $minute);
    }

    /**
     * Constructor.
     *
     * @param      TranslationManager $tm
     * @param      int $year
     * @param      int $month
     * @param      int $date
     * @param      int $hour
     * @param      int $minute
     * @param      int $second
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function constructorOIIIIII(TranslationManager $tm, $year, $month, $date, $hour, $minute, $second)

    {
        parent::constructorOO($tm->getDefaultTimeZone(), $tm->getCurrentLocale());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
        $this->set(DateDefinitions::ERA, self::AD);
        $this->set(DateDefinitions::YEAR, $year);
        $this->set(DateDefinitions::MONTH, $month);
        $this->set(DateDefinitions::DATE, $date);
        $this->set(DateDefinitions::HOUR_OF_DAY, $hour);
        $this->set(DateDefinitions::MINUTE, $minute);
        $this->set(DateDefinitions::SECOND, $second);
    }

    /**
     * Useful constants for GregorianCalendar and TimeZone.
     */
     const BC = 0;
     const AD = 1;

    /**
     * Sets the GregorianCalendar change date. This is the point when the switch
     * from Julian dates to Gregorian dates occurred. Default is 00:00:00 local
     * time, October 15, 1582. Previous to this time and date will be Julian
     * dates.
     *
     * @param      float $date The given Gregorian cutover date.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function setGregorianChange($date)
    {
        $this->fGregorianCutover = $date;

        // Precompute two internal variables which we use to do the actual
        // cutover computations.  These are the normalized cutover, which is the
        // midnight at or before the cutover, and the cutover year.  The
        // normalized cutover is in pure date milliseconds; it contains no time
        // of day or timezone component, and it used to compare against other
        // pure date values.
        $cutoverDay = (int) floor($this->fGregorianCutover / DateDefinitions::MILLIS_PER_DAY);
        $this->fNormalizedGregorianCutover = $cutoverDay * DateDefinitions::MILLIS_PER_DAY;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        // Handle the rare case of numeric overflow.  If the user specifies a
        // change of UDate(Long.MIN_VALUE), in order to get a pure Gregorian
        // calendar, then the epoch day is -106751991168, which when multiplied
        // by ONE_DAY gives 9223372036794351616 -- the negative value is too
        // large for 64 bits, and overflows into a positive value.  We correct
        // this by using the next day, which for all intents is semantically
        // equivalent.
        if ($cutoverDay < 0 && $this->fNormalizedGregorianCutover > 0) {
            $this->fNormalizedGregorianCutover = ($cutoverDay + 1) * DateDefinitions::MILLIS_PER_DAY;
        }

        // Normalize the year so BC values are represented as 0 and negative
        // values.
        $cal = new GregorianCalendar($this->getTimeZone());

        $cal->setTime($date);
        $this->fGregorianCutoverYear = $cal->get(DateDefinitions::YEAR);
        if ($cal->get(DateDefinitions::ERA) == self::BC) {
            $this->fGregorianCutoverYear = 1 - $this->fGregorianCutoverYear;
        }
        $this->fCutoverJulianDay = $cutoverDay;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    }

    /**
     * Gets the Gregorian Calendar change date. This is the point when the switch
     * from Julian dates to Gregorian dates occurred. Default is 00:00:00 local
     * time, October 15, 1582. Previous to this time and date will be Julian
     * dates.
     *
     * @return     float The Gregorian cutover time for this calendar.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function getGregorianChange()
    {
        return $this->fGregorianCutover;
    }

    /**
     * Return true if the given year is a leap year. Determination of whether a
     * year is a leap year is actually very complicated. We do something crude
     * and mostly correct here, but for a real determination you need a lot of
     * contextual information. For example, in Sweden, the change from Julian to
     * Gregorian happened in a complex way resulting in missed leap years and
     * double leap years between 1700 and 1753. Another example is that after the
     * start of the Julian calendar in 45 B.C., the leap years did not regularize
     * until 8 A.D. This method ignores these quirks, and pays attention only to
     * the Julian onset date and the Gregorian cutover (which can be changed).
     *
     * @param      int  $year The given year.
     *
     * @return     bool if the given year is a leap year; false otherwise.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function isLeapYear($year)
    {
        // MSVC complains bitterly if we try to use Grego::isLeapYear here
        // NOTE: year&0x3 == year%4
        return ($year >= $this->fGregorianCutoverYear
                        ? CalendarGrego::isLeapYear($year) // Gregorian
                        : (($year & 0x3) == 0)); // Julian
    }

    /**
     * Returns true if the given Calendar object is equivalent to this
     * one.  Calendar override.
     *
     * @param      Calendar $other the Calendar to be compared with this Calendar
     *
     * @return     bool
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function isEquivalentTo(Calendar $other)
    {
        // Calendar override.
        return Calendar::isEquivalentTo($other) && $this->getGregorianChange() == $other->getGregorianChange();
    }

    /**
     * @see        AgaviCalendar::getActualMinimum()
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function getActualMinimum($field)
    {
        return $this->getMinimum($field);
    }

    /**
     * @see        AgaviCalendar::getActualMaximum()
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function getActualMaximum($field)
    {
        /* It is a known limitation that the code here (and in getActualMinimum)
		* won't behave properly at the extreme limits of GregorianCalendar's
		* representable range (except for the code that handles the YEAR
		* field).  That's because the ends of the representable range are at
		* odd spots in the year.  For calendars with the default Gregorian
		* cutover, these limits are Sun Dec 02 16:47:04 GMT 292269055 BC to Sun
		* Aug 17 07:12:55 GMT 292278994 AD, somewhat different for non-GMT
		* zones.  As a result, if the calendar is set to Aug 1 292278994 AD,
		* the actual maximum of DAY_OF_MONTH is 17, not 30.  If the date is Mar
		* 31 in that year, the actual maximum month might be Jul, whereas is
		* the date is Mar 15, the actual maximum might be Aug -- depending on
		* the precise semantics that are desired.  Similar considerations
		* affect all fields.  Nonetheless, this effect is sufficiently arcane
		* that we permit it, rather than complicating the code to handle such
		* intricacies. - liu 8/20/98

		* UPDATE: No longer true, since we have pulled in the limit values on
		* the year. - Liu 11/6/00 */

        switch ($field) {
            case DateDefinitions::YEAR:
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                /* The year computation is no different, in principle, from the
				* others, however, the range of possible maxima is large.  In
				* addition, the way we know we've exceeded the range is different.
				* For these reasons, we use the special case code below to handle
				* this field.
				*
				* The actual maxima for YEAR depend on the type of calendar:
				*
				*     Gregorian = May 17, 292275056 BC - Aug 17, 292278994 AD
				*     Julian    = Dec  2, 292269055 BC - Jan  3, 292272993 AD
				*     Hybrid    = Dec  2, 292269055 BC - Aug 17, 292278994 AD
				*
				* We know we've exceeded the maximum when either the month, date,
				* time, or era changes in response to setting the year.  We don't
				* check for month, date, and time here because the year and era are
				* sufficient to detect an invalid year setting.  NOTE: If code is
				* added to check the month and date in the future for some reason,
				* Feb 29 must be allowed to shift to Mar 1 when setting the year.
				*/
                {
                    $cal = clone $this;

                    $cal->setLenient(true);

                    $era = $cal->get(DateDefinitions::ERA);
                    $d = $cal->getTime();

                    /* Perform a binary search, with the invariant that lowGood is a
					* valid year, and highBad is an out of range year.
					*/
                    $lowGood = self::$kGregorianCalendarLimits[DateDefinitions::YEAR][1];
                    $highBad = self::$kGregorianCalendarLimits[DateDefinitions::YEAR][2] + 1;
                while (($lowGood + 1) < $highBad) {
                    $y = (int)(($lowGood + $highBad) / 2);
                    $cal->set(DateDefinitions::YEAR, $y);
                    if ($cal->get(DateDefinitions::YEAR) == $y && $cal->get(DateDefinitions::ERA) == $era) {
                        $lowGood = $y;
                    } else {
                        $highBad = $y;
                        $cal->setTime($d); // Restore original fields
                    }
                }

                return $lowGood;
            }

            default:
                return parent::getActualMaximum($field);
        }
    }

    /**
     * @see        AgaviCalendar::inDaylightTime
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function inDaylightTime()
    {
        if (!$this->getTimeZone()->useDaylightTime()) {
            return false;
        }

        // Force an update of the state of the Calendar.
        $this->complete(); // cast away const

        return ($this->internalGet(DateDefinitions::DST_OFFSET) != 0);
    }

    /**
     * Return the ERA.  We need a special method for this because the
     * default ERA is AD, but a zero (unset) ERA is BC.
     *
     * @return     int The ERA.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function internalGetEra()
    {
        return $this->_isSet(DateDefinitions::ERA) ? $this->internalGet(DateDefinitions::ERA) : self::AD;
    }

    /**
     * @see        AgaviCalendar::handleComputeMonthStart
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleComputeMonthStart($eyear, $month, $useMonth)
    {
        // If the month is out of range, adjust it into range, and
        // modify the extended year value accordingly.
        if ($month < 0 || $month > 11) {
            $eyear += Toolkit::floorDivide($month, 12, $month);
        }

        $isLeap = ($eyear % 4 == 0);
        $y = $eyear - 1;
        $julianDay = 365 * $y + floor($y / 4) + (DateDefinitions::JAN_1_1_JULIAN_DAY - 3);

        $this->fIsGregorian = ($eyear >= $this->fGregorianCutoverYear);

        if ($this->fInvertGregorian) {
            $this->fIsGregorian = !$this->fIsGregorian;
        }
        if ($this->fIsGregorian) {

            $isLeap = $isLeap && (($eyear % 100 != 0) || ($eyear % 400 == 0));
            // Add 2 because Gregorian calendar starts 2 days after
            // Julian calendar
            $gregShift = CalendarGrego::gregorianShift($eyear);

            $julianDay += $gregShift;
        }

        // At this point julianDay indicates the day BEFORE the first
        // day of January 1, <eyear> of either the Julian or Gregorian
        // calendar.

        if ($month != 0) {
            $julianDay += $isLeap ? self::$kLeapNumDays[$month] : self::$kNumDays[$month];
        }

        return $julianDay;
    }

    /**
     * @see        AgaviCalendar::handleComputeJulianDay
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleComputeJulianDay($bestField)
    {
        $this->fInvertGregorian = false;

        $jd = parent::handleComputeJulianDay($bestField);

        if (($bestField == DateDefinitions::WEEK_OF_YEAR) &&  // if we are doing WOY calculations, we are counting relative to Jan 1 *julian*
                ($this->internalGet(DateDefinitions::EXTENDED_YEAR) == $this->fGregorianCutoverYear) && $jd >= $this->fCutoverJulianDay) {
            $this->fInvertGregorian = true;  // So that the Julian Jan 1 will be used in handleComputeMonthStart
            return parent::handleComputeJulianDay($bestField);
        }

        // The following check handles portions of the cutover year BEFORE the
        // cutover itself happens.
        //if((fIsGregorian==true) != (jd >= fCutoverJulianDay)) {  /*  cutoverJulianDay)) { */

        if (($this->fIsGregorian == true) != ($jd >= $this->fCutoverJulianDay)) {  /*  cutoverJulianDay)) { */

            $this->fInvertGregorian = true;
            $jd = parent::handleComputeJulianDay($bestField);
        } else {
if (rand(1, 6) > 3) {
print "Check failed";
} else {
    //print "Check succeeded";
}
        }

        if ($this->fIsGregorian && ($this->internalGet(DateDefinitions::EXTENDED_YEAR) == $this->fGregorianCutoverYear)) {
            $gregShift = CalendarGrego::gregorianShift($this->internalGet(DateDefinitions::EXTENDED_YEAR));
            if ($bestField == DateDefinitions::DAY_OF_YEAR) {
                $jd -= $gregShift;
            } elseif ($bestField == DateDefinitions::WEEK_OF_MONTH) {
                $weekShift = 14;
                $jd += $weekShift; // shift by weeks for week based fields.
            }
        }

        return $jd;
    }

    /**
     * @see        AgaviCalendar::handleGetMonthLength
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleGetMonthLength($extendedYear, $month)
    {
        // If the month is out of range, adjust it into range, and
        // modify the extended year value accordingly.
        if ($month < 0 || $month > 11) {
            $extendedYear += Toolkit::floorDivide($month, 12, $month);
        }
        
        return $this->isLeapYear($extendedYear) ? self::$kLeapMonthLength[$month] : self::$kMonthLength[$month];
    }

    /**
     * @see        AgaviCalendar::handleGetYearLength
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleGetYearLength($eyear)
    {
        return $this->isLeapYear($eyear) ? 366 : 365;
    }

    /**
     * Return the length of the given month.
     *
     * @param      int $month The given month.
     *
     * @return     int The length of the given month.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function monthLength($month)
    {
        $year = $this->internalGet(DateDefinitions::EXTENDED_YEAR);
        return $this->handleGetMonthLength($year, $month);
    }

    /**
     * Return the length of the month according to the given year.
     *
     * @param      int $month The given month.
     * @param      int $year  The given year.
     *
     * @return     int The length of the month.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function monthLength1($month, $year)
    {
        return $this->isLeapYear($year) ? self::$kLeapMonthLength[$month] : self::$kMonthLength[$month];
    }
    
    /**
     * Return the length of the given year.
     *
     * @param      int $year The given year.
     * @return     int The length of the given year.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function yearLength1($year)
    {
        return $this->isLeapYear($year) ? 366 : 365;
    }
    
    /**
     * Return the length of the year field.
     *
     * @return     int The length of the year field
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function yearLength()
    {
        return $this->isLeapYear($this->internalGet(DateDefinitions::YEAR)) ? 366 : 365;
    }

    /**
     * After adjustments such as add(MONTH), add(YEAR), we don't want the
     * month to jump around.  E.g., we don't want Jan 31 + 1 month to go to Mar
     * 3, we want it to go to Feb 28.  Adjustments which might run into this
     * problem call this method to retain the proper month.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function pinDayOfMonth()
    {
        $monthLen = $this->monthLength($this->internalGet(DateDefinitions::MONTH));
        $dom = $this->internalGet(DateDefinitions::DATE);
        if ($dom > $monthLen) {
            $this->set(DateDefinitions::DATE, $monthLen);
        }
    }

    /**
     * Return the day number with respect to the epoch.
     * January 1, 1970 (Gregorian) is day zero.
     *
     * @return     float the day number with respect to the epoch.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function getEpochDay()
    {
        $this->complete();
        // Divide by 1000 (convert to seconds) in order to prevent overflow when
        // dealing with UDate(Long.MIN_VALUE) and UDate(Long.MAX_VALUE).
        $wallSec = $this->internalGetTime() / 1000.0 + ($this->internalGet(DateDefinitions::ZONE_OFFSET) + $this->internalGet(DateDefinitions::DST_OFFSET)) / 1000.0;

        return floor($wallSec / (DateDefinitions::MILLIS_PER_DAY / 1000.0));
    }

    /**
     * @see        AgaviCalendar::handleGetLimit
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleGetLimit($field, $limitType)
    {
        return self::$kGregorianCalendarLimits[$field][$limitType];
    }

    /**
     * @see        AgaviCalendar::handleGetExtendedYear
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleGetExtendedYear()
    {
        $year = DateDefinitions::EPOCH_YEAR;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        switch ($this->resolveFields(self::$kYearPrecedence)) {
            case DateDefinitions::EXTENDED_YEAR:
                $year = $this->internalGet(DateDefinitions::EXTENDED_YEAR, DateDefinitions::EPOCH_YEAR);
                break;

            case DateDefinitions::YEAR:
switch ($expr) {
    case "A": { //wrong
        doSomething();
        break;
    }
    case "B"; //wrong
        doSomething();
        break;
    case "C": //right
        doSomething();
        break;
}
                {
                    // The year defaults to the epoch start, the era to AD
                    $era = $this->internalGet(DateDefinitions::ERA, self::AD);
                if ($era == self::BC) {
                    $year = 1 - $this->internalGet(DateDefinitions::YEAR, 1); // Convert to extended year
                } else {
                    $year = $this->internalGet(DateDefinitions::YEAR, DateDefinitions::EPOCH_YEAR);
                }
            }
            break;

            case DateDefinitions::YEAR_WOY:
                $year = $this->handleGetExtendedYearFromWeekFields($this->internalGet(DateDefinitions::YEAR_WOY), $this->internalGet(DateDefinitions::WEEK_OF_YEAR));
                break;

            default:
                $year = DateDefinitions::EPOCH_YEAR;
        }
        return $year;
    }

    /**
     * @see        AgaviCalendar::handleGetExtendedYearFromWeekFields
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleGetExtendedYearFromWeekFields($yearWoy, $woy)
    {
        // convert year to extended form
        $era = $this->internalGet(DateDefinitions::ERA, self::AD);
        if ($era == self::BC) {
            $yearWoy = 1 - $yearWoy;
        }
        return parent::handleGetExtendedYearFromWeekFields($yearWoy, $woy);
    }

    /**
     * @see        AgaviCalendar::handleComputeFields
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    protected function handleComputeFields($julianDay)
    {
        if ($julianDay >= $this->fCutoverJulianDay) {
            $month = $this->getGregorianMonth();
            $dayOfMonth = $this->getGregorianDayOfMonth();
            $dayOfYear = $this->getGregorianDayOfYear();
            $eyear = $this->getGregorianYear();
        } else {
            // The Julian epoch day (not the same as Julian Day)
            // is zero on Saturday December 30, 0 (Gregorian).
            $julianEpochDay = $julianDay - (DateDefinitions::JAN_1_1_JULIAN_DAY - 2);
            $eyear = (int) floor((4 * $julianEpochDay + 1464) / 1461);

            // Compute the Julian calendar day number for January 1, eyear
            $january1 = 365 * ($eyear - 1) + floor(($eyear -1 ) / 4);
            $dayOfYear = ($julianEpochDay - $january1); // 0-based

            // Julian leap years occurred historically every 4 years starting
            // with 8 AD.  Before 8 AD the spacing is irregular; every 3 years
            // from 45 BC to 9 BC, and then none until 8 AD.  However, we don't
            // implement this historical detail; instead, we implement the
            // computationally cleaner proleptic calendar, which assumes
            // consistent 4-year cycles throughout time.
            $isLeap = (($eyear & 0x3) == 0); // equiv. to (eyear%4 == 0)

            // Common Julian/Gregorian calculation
            $correction = 0;
            $march1 = $isLeap ? 60 : 59; // zero-based DOY for March 1
            if ($dayOfYear >= $march1) {
                $correction = $isLeap ? 1 : 2;
            }
            $month = (int) ((12 * ($dayOfYear + $correction) + 6) / 367); // zero-based month
            $dayOfMonth = $dayOfYear - ($isLeap ? self::$kLeapNumDays[$month] : self::$kNumDays[$month]) + 1; // one-based DOM
            ++$dayOfYear;
        }

        // [j81] if we are after the cutover in its year, shift the day of the year
        if (($eyear == $this->fGregorianCutoverYear) && ($julianDay >= $this->fCutoverJulianDay)) {
            //from handleComputeMonthStart
            $gregShift = CalendarGrego::gregorianShift($eyear);
            $dayOfYear += $gregShift;
        }

        $this->internalSet(DateDefinitions::MONTH, $month);
        $this->internalSet(DateDefinitions::DAY_OF_MONTH, $dayOfMonth);
        $this->internalSet(DateDefinitions::DAY_OF_YEAR, $dayOfYear);
        $this->internalSet(DateDefinitions::EXTENDED_YEAR, $eyear);
        $era = self::AD;
        if ($eyear < 1) {
            $era = self::BC;
            $eyear = 1 - $eyear;
        }
        $this->internalSet(DateDefinitions::ERA, $era);
        $this->internalSet(DateDefinitions::YEAR, $eyear);
    }

    /**
     * Compute the julian day number of the given year.
     *
     * @param      bool   $isGregorian If true, using Gregorian calendar, otherwise using
     *                    Julian calendar.
     * @param      int    $year The given year.
     * @param      bool   $isLeap True if the year is a leap year.
     *
     * @return     double
     *
     * @author     Dominik del Bondio <[email protected]>
     * @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) + (DateDefinitions::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 += CalendarGrego::gregorianShift($year);
        }

        return $julianDay;
    }
    
    /**
     * Validates the values of the set time fields.  True if they're all valid.
     *
     * @return     bool True if the set time fields are all valid.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private function validateFields()

    {
        for ($field = 0; $field < DateDefinitions::FIELD_COUNT; ++$field) {
            // Ignore DATE and DAY_OF_YEAR which are handled below
            if ($field != DateDefinitions::DATE &&
                    $field != DateDefinitions::DAY_OF_YEAR &&
                    $this->_isSet($field) &&
                    ! $this->boundsCheck($this->internalGet($field), $field)) {
                return false;
            }
        }

        // Values differ in Least-Maximum and Maximum should be handled
        // specially.
        if ($this->_isSet(DateDefinitions::DATE)) {
            $date = $this->internalGet(DateDefinitions::DATE);
            if ($date < $this->getMinimum(DateDefinitions::DATE) ||
                    $date > $this->monthLength($this->internalGet(DateDefinitions::MONTH))) {
                return false;
            }
        }

        if ($this->_isSet(DateDefinitions::DAY_OF_YEAR)) {
            $days = $this->internalGet(DateDefinitions::DAY_OF_YEAR);
            if ($days < 1 || $days > $this->yearLength()) {
                return false;
            }
        }

        // Handle DAY_OF_WEEK_IN_MONTH, which must not have the value zero.
        // We've checked against minimum and maximum above already.
        if ($this->_isSet(DateDefinitions::DAY_OF_WEEK_IN_MONTH) &&
            0 == $this->internalGet(DateDefinitions::DAY_OF_WEEK_IN_MONTH)) {
            return false;
        }

        return true;
    }

    /**
     * Validates the value of the given time field.  True if it's valid.
     *
     * @param      int $value
     * @param      int $field
     *
     * @return     bool
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private function boundsCheck($value, $field)
    {
        return $value >= $this->getMinimum($field) && $value <= $this->getMaximum($field);
    }

    /**
     * Return the pseudo-time-stamp for two fields, given their
     * individual pseudo-time-stamps.  If either of the fields
     * is unset, then the aggregate is unset.  Otherwise, the
     * aggregate is the later of the two stamps.
     *
     * @param      int $stamp_a One given field.
     * @param      int $stamp_b Another given field.
     * @return     int The pseudo-time-stamp for two fields.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private function aggregateStamp($stamp_a, $stamp_b)
    {
        return ((($stamp_a != Calendar::kUnset && $stamp_b != Calendar::kUnset)
            ? max($stamp_a, $stamp_b)
            : Calendar::kUnset
        ));
    }

    /**
     * @var        float The point at which the Gregorian calendar rules are used,
     *                   measured in milliseconds from the standard epoch. Default
     *                   is October 15, 1582 (Gregorian) 00:00:00 UTC, that is,
     *                   October 4, 1582 (Julian) is followed by October 15, 1582
     *                   (Gregorian).  This corresponds to Julian day number
     *                   2299161. This is measured from the standard epoch, not in
     *                   Julian Days.
     */
    private $fGregorianCutover;

    /**
     * @var        int Julian day number of the Gregorian cutover
     */
    private $fCutoverJulianDay;

    /**
     * @var        float Midnight, local time (using this Calendar's TimeZone)
     *                   at or before the gregorianCutover. This is a pure
     *                   date value with no time of day or timezone component.
     */
    private $fNormalizedGregorianCutover;// = gregorianCutover;

    /**
     * @var        int The year of the gregorianCutover, with 0 representing
     *                 1 BC, -1 representing 2 BC, etc.
     */
    private $fGregorianCutoverYear;// = 1582;

    /**
     * @var        int The year of the gregorianCutover, with 0 representing
     *                 1 BC, -1 representing 2 BC, etc.
     */
    private $fGregorianCutoverJulianDay;// = 2299161;


    /**
     * Converts time as milliseconds to Julian date. The Julian date used here is
     * not a true Julian date, since it is measured from midnight, not noon.
     *
     * @param      float $millis The given milliseconds.
     *
     * @return     float The Julian date number.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private static function millisToJulianDay($millis)

    {
        return DateDefinitions::EPOCH_START_AS_JULIAN_DAY + floor($millis / DateDefinitions::MILLIS_PER_DAY);
    }

    /**
     * Converts Julian date to time as milliseconds. The Julian date used here is
     * not a true Julian date, since it is measured from midnight, not noon.
     *
     * @param      float $julian The given Julian date number.
     *
     * @return     float Time as milliseconds.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private static function julianDayToMillis($julian)

    {
        return (($julian - DateDefinitions::EPOCH_START_AS_JULIAN_DAY) * DateDefinitions::MILLIS_PER_DAY);
    }

    /**
     * @var        bool Used by handleComputeJulianDay() and
     *                  handleComputeMonthStart(). Temporary field indicating
     *                  whether the calendar is currently Gregorian as opposed to
     *                  Julian.
     */
    private $fIsGregorian;

    /**
     * @var        bool Used by handleComputeJulianDay() and
     *                  handleComputeMonthStart(). Temporary field indicating that
     *                  the sense of the gregorian cutover should be inverted to
     *                  handle certain calculations on and around the cutover
     *                  date.
     */
    private $fInvertGregorian;

    /**
     * @see        AgaviCalendar::haveDefaultCentury
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function haveDefaultCentury()
    {
        return true;
    }

    /**
     * @see        AgaviCalendar::defaultCenturyStart
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function defaultCenturyStart()
    {
        return $this->internalGetDefaultCenturyStart();
    }

    /**
     * @see        AgaviCalendar::defaultCenturyStartYear
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    public function defaultCenturyStartYear()
    {
        return $this->internalGetDefaultCenturyStartYear();
    }

    /**
     * @see        AgaviCalendar::getType
     *
     * @author     Dominik del Bondio <[email protected]>
     * @since      0.11.0
     */
    public function getType()
    {
        return Calendar::GREGORIAN;
    }

    /**
     * @var        float The system maintains a static default century start date.
     *                   This is initialized the first time it is used.
     *                   Before then, it is set to SYSTEM_DEFAULT_CENTURY to
     *                   indicate an uninitialized state.  Once the system default
     *                   century date and year are set, they do not change.
     */
    private static $fgSystemDefaultCenturyStart;

    /**
     * @var        int See documentation for systemDefaultCenturyStart.
     */
    private static $fgSystemDefaultCenturyStartYear = -1;

    /**
     * @var        int Default value that indicates the defaultCenturyStartYear is
     *                 uninitialized
     */
    private static $fgSystemDefaultCenturyYear = -1;


    /**
     * @var        float Default value that indicates the UDate of the beginning
     *                   of the system default century
     */
    private static $fgSystemDefaultCentury;

    /**
     * Returns the beginning date of the 100-year window that dates with 2-digit
     * years are considered to fall within.
     *
     * @return     float The beginning date of the 100-year window that dates
     *                   with 2-digit years are considered to fall within.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private function internalGetDefaultCenturyStart()
    {
        // lazy-evaluate systemDefaultCenturyStart
        $needsUpdate = (self::$fgSystemDefaultCenturyStart == self::$fgSystemDefaultCentury);

        if ($needsUpdate) {
            $this->initializeSystemDefaultCentury();
        }

        // use defaultCenturyStart unless it's the flag value;
        // then use systemDefaultCenturyStart

        return self::$fgSystemDefaultCenturyStart;
    }

    /**
     * Returns the first year of the 100-year window that dates with 2-digit years
     * are considered to fall within.
     *
     * @return     int The first year of the 100-year window that dates with
     *                 2-digit years are considered to fall within.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private function internalGetDefaultCenturyStartYear()
    {
        // lazy-evaluate systemDefaultCenturyStartYear
        $needsUpdate = (self::$fgSystemDefaultCenturyStart == self::$fgSystemDefaultCentury);

        if ($needsUpdate) {
            $this->initializeSystemDefaultCentury();
        }

        // use defaultCenturyStart unless it's the flag value;
        // then use systemDefaultCenturyStartYear

        return self::$fgSystemDefaultCenturyStartYear;
    }

    /**
     * Initializes the 100-year window that dates with 2-digit years are
     * considered to fall within so that its start date is 80 years before the
     * current time.
     *
     * @author     Dominik del Bondio <[email protected]>
     * @author     The ICU Project
     * @since      0.11.0
     */
    private static function initializeSystemDefaultCentury()
    {
        // initialize systemDefaultCentury and systemDefaultCenturyYear based
        // on the current time.  They'll be set to 80 years before
        // the current time.
        // No point in locking as it should be idempotent.
        if (self::$fgSystemDefaultCenturyStart == self::$fgSystemDefaultCentury) {
            $calendar = new GregorianCalendar();
            $calendar->setTime(Calendar::getNow());
            $calendar->add(DateDefinitions::YEAR, -80);

            $newStart = $calendar->getTime();
            $newYear  = $calendar->get(DateDefinitions::YEAR);
            self::$fgSystemDefaultCenturyStart = $newStart;
            self::$fgSystemDefaultCenturyStartYear = $newYear;
        }
    }

    protected static $kNumDays         = array(0,  31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334); // 0-based, for day-in-year
    protected static $kLeapNumDays     = array(0,  31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335); // 0-based, for day-in-year
    protected static $kMonthLength     = array(31, 28, 31, 30,  31,  30,  31,  31,  30,  31,  30,  31); // 0-based
    protected static $kLeapMonthLength = array(31, 29, 31, 30,  31,  30,  31,  31,  30,  31,  30,  31); // 0-based
    protected static $kGregorianCalendarLimits = array(
        //     Minimum  Greatest   Least      Maximum
        //                Minimum   Maximum
        array(        0,        0,        1,        1 ), // ERA
        array(        1,        1,   140742,   144683 ), // YEAR
        array(        0,        0,       11,       11 ), // MONTH
        array(        1,        1,       52,       53 ), // WEEK_OF_YEAR
        array(        0,        0,        4,        6 ), // WEEK_OF_MONTH
        array(        1,        1,       28,       31 ), // DAY_OF_MONTH
        array(        1,        1,      365,      366 ), // DAY_OF_YEAR
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // DAY_OF_WEEK
        array(       -1,       -1,        4,        5 ), // DAY_OF_WEEK_IN_MONTH
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // AM_PM
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // HOUR
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // HOUR_OF_DAY
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // MINUTE
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // SECOND
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // MILLISECOND
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // ZONE_OFFSET
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // DST_OFFSET
        array(  -140742,  -140742,   140742,   144683 ), // YEAR_WOY
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // DOW_LOCAL
        array(  -140742,  -140742,   140742,   144683 ), // EXTENDED_YEAR
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // JULIAN_DAY
        array(/*N/A*/-1,/*N/A*/-1,/*N/A*/-1,/*N/A*/-1 ), // MILLISECONDS_IN_DAY
    );
}

horros / agavi2

GregorianCalendar D last analyzed 2017-05-30 13:20 UTC
