Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Header Files   Compound Members   File Members  

gregocal.h

This is the verbatim text of the gregocal.h include file.
/*
* Copyright © {1997-1999}, International Business Machines Corporation and others. All Rights Reserved.
********************************************************************************
*
* File GREGOCAL.H
*
* Modification History:
*
*   Date        Name        Description
*   04/22/97    aliu        Overhauled header.
*    07/28/98    stephen        Sync with JDK 1.2
*    09/04/98    stephen        Re-sync with JDK 8/31 putback
*    09/14/98    stephen        Changed type of kOneDay, kOneWeek to double.
*                            Fixed bug in roll() 
*   10/15/99    aliu        Fixed j31, incorrect WEEK_OF_YEAR computation.
*                           Added documentation of WEEK_OF_YEAR computation.
*   10/15/99    aliu        Fixed j32, cannot set date to Feb 29 2000 AD.
*                           {JDK bug 4210209 4209272}
********************************************************************************
*/
         
#ifndef GREGOCAL_H
#define GREGOCAL_H


#include "unicode/calendar.h"

class U_I18N_API GregorianCalendar: public Calendar {
public:

    enum EEras {
        BC,
        AD
    };

    GregorianCalendar(UErrorCode& success);

    GregorianCalendar(TimeZone* zoneToAdopt, UErrorCode& success);

    GregorianCalendar(const TimeZone& zone, UErrorCode& success);

    GregorianCalendar(const Locale& aLocale, UErrorCode& success);

    GregorianCalendar(TimeZone* zoneToAdopt, const Locale& aLocale, UErrorCode& success);

    GregorianCalendar(const TimeZone& zone, const Locale& aLocale, UErrorCode& success);

    GregorianCalendar(int32_t year, int32_t month, int32_t date, UErrorCode& success);

    GregorianCalendar(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute, UErrorCode& success);

    GregorianCalendar(int32_t year, int32_t month, int32_t date, int32_t hour, int32_t minute, int32_t second, UErrorCode& success);

    virtual ~GregorianCalendar();

    GregorianCalendar(const GregorianCalendar& source);

    GregorianCalendar& operator=(const GregorianCalendar& right);

    virtual Calendar* clone(void) const;

    void setGregorianChange(UDate date, UErrorCode& success);

    UDate getGregorianChange(void) const;

    bool_t isLeapYear(int32_t year) const;

    virtual bool_t operator==(const Calendar& that) const;

    virtual bool_t equivalentTo(const Calendar& other) const;

    virtual void add(EDateFields field, int32_t amount, UErrorCode& status);

    virtual void roll(EDateFields field, int32_t amount, UErrorCode& status);

    virtual int32_t getMinimum(EDateFields field) const;

    virtual int32_t getMaximum(EDateFields field) const;

    virtual int32_t getGreatestMinimum(EDateFields field) const;

    virtual int32_t getLeastMaximum(EDateFields field) const;

    int32_t getActualMinimum(EDateFields field) const;

    int32_t getActualMaximum(EDateFields field) const;

    virtual bool_t inDaylightTime(UErrorCode& status) const;

public:

    virtual UClassID getDynamicClassID(void) const { return (UClassID)&fgClassID; }

    static UClassID getStaticClassID(void) { return (UClassID)&fgClassID; }

protected:

    virtual void computeFields(UErrorCode& status);

    virtual void computeTime(UErrorCode& status);

private: 

    int32_t internalGetEra() const;

    // this is 2^52 - 1, the largest allowable mantissa with a 0 exponent in a 64-bit double
    static const UDate EARLIEST_SUPPORTED_MILLIS;
    static const UDate LATEST_SUPPORTED_MILLIS;

    int32_t monthLength(int32_t month) const;
    int32_t monthLength(int32_t month, int32_t year) const;

    int32_t yearLength(int32_t year) const;

    int32_t yearLength(void) const;

    void pinDayOfMonth(void);

    UDate getEpochDay(UErrorCode& status);

    static double computeJulianDayOfYear(bool_t isGregorian, int32_t year,
                                         bool_t& isLeap);

    int32_t computeRelativeDOW() const;

    int32_t computeRelativeDOW(double julianDay) const;

    int32_t computeDOYfromWOY(double julianDayOfYear) const;

    double computeJulianDay(bool_t isGregorian, int32_t year);

    void timeToFields(UDate theTime, bool_t quick, UErrorCode& status);


    int32_t weekNumber(int32_t date, int32_t day);

    bool_t validateFields(void) const;

    bool_t boundsCheck(int32_t value, EDateFields field) const;

    int32_t aggregateStamp(int32_t stamp_a, int32_t stamp_b);

    // This is measured from the standard epoch, not in Julian Days.
    UDate                fGregorianCutover;

    UDate                 fNormalizedGregorianCutover;// = gregorianCutover;

    int32_t fGregorianCutoverYear;// = 1582;

    static char fgClassID;

    static double millisToJulianDay(UDate millis);

    static UDate julianDayToMillis(double julian);

    static uint8_t julianDayToDayOfWeek(double julian);

    static double floorDivide(double numerator, double denominator);

    static int32_t floorDivide(int32_t numerator, int32_t denominator);

    static int32_t floorDivide(int32_t numerator, int32_t denominator, int32_t remainder[]);

    static int32_t floorDivide(double numerator, int32_t denominator, int32_t remainder[]);


    static const UDate       kPapalCutover;             // Cutover decreed by Pope Gregory

    static const int32_t     kJan1_1JulianDay;        // January 1, year 1 (Gregorian)
    static const int32_t     kEpochStartAsJulianDay; // January 1, 1970 (Gregorian)
    static const int32_t     kEpochYear;

    static const int32_t     kNumDays [];
    static const int32_t     kLeapNumDays [];
    static const int32_t     kMonthLength [];
    static const int32_t     kLeapMonthLength [];

    static const int32_t     kMinValues [];
    static const int32_t     kLeastMaxValues [];
    static const int32_t     kMaxValues [];

    // Useful millisecond constants
    static const int32_t    kOneSecond;
    static const int32_t    kOneMinute;
    static const int32_t    kOneHour;
    static const double        kOneDay;
    static const double        kOneWeek;
};


inline uint8_t GregorianCalendar::julianDayToDayOfWeek(double julian)
{
  // If julian is negative, then julian%7 will be negative, so we adjust
  // accordingly.  We add 1 because Julian day 0 is Monday.
  int8_t dayOfWeek = (int8_t) uprv_fmod(julian + 1, 7);
  
  uint8_t result = dayOfWeek + ((dayOfWeek < 0) ? (7 + SUNDAY) : SUNDAY);
  return result;
}

#endif // _GREGOCAL
//eof
        

Generated at Thu Feb 10 15:30:42 2000 for icu by doxygen 1.0.0 written by Dimitri van Heesch, © 1997-1999