"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

Magnitude subclass:#Date

	instanceVariableNames:'dateEncoding'

	classVariableNames:'DayNames MonthNames DayAbbrevs MonthAbbrevs DefaultFormats

		ShortFormats LongFormats EnvironmentChange'

	poolDictionaries:''

	category:'Magnitude-Time'

!

!Date class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Instances of Date represent dates as year, month and day encoded in the

    (private & hidden) instance dateEncoding. The value found there is

    year*100*100 + month*100 + day

    This makes magnitude-like comparison of dates easy, and the main components

    d,m,y are easily reconstructed (assuming, that this is the stuff most used).

    Do not depend on the internal representation -

    it is private and not guaranteed for future versions.

    The old representation used days since 1st Jan. 1901 internally -

    with the new implementation, it is possible to reasonably represent almost

    any Date.

    (which insurance companies will like,

     since they can now represent even very old people's birthday :-)

    Notice:

        no correction for pre-Gregorian dates (< 1583) is done.

        For dates before 1582 (when calendars were changed from Julian to Gregorian),

        the so called 'proleptic gregorian calendar' is used.

        This assumes leap years to continue in the past as if a gregorian calendar was used.

        Thus, 0000 is considered a leap year.

    The printed representation of dates is controlled by resource definitions -

    thus national variants are already supported (see file 'resources/Date.rs').

    Compatibility notice:

        due to historic reasons, there are some methods found twice

        with different names in this class. The old ST/X methods will vanish

        over time, but kept for a while to support existing applications

        (the info on how these methods should be named

         came somewhat late from the testers...).

        Please do not use methods marked as obsolete.

    Most useful methods:

        Date today

        (Date today) addDays:

        (Date today) subtractDays:

    [author:]

        Claus Gittinger

    [see also:]

        Time AbstractTime

        Filename

        OperatingSystem

"

! !

!Date class methodsFor:'initialization'!

initDefaultNames

    "read the language specific names."

    |enDayNames enDayAbbrevs enMonthNames enMonthAbbrevs|

    DayNames := Dictionary new.

    DayAbbrevs := Dictionary new.

    MonthNames := Dictionary new.

    MonthAbbrevs := Dictionary new.

    DefaultFormats := Dictionary new.

    LongFormats := Dictionary new.

    ShortFormats := Dictionary new.

    enDayNames := #('monday'

                    'tuesday'

                    'wednesday'

                    'thursday'

                    'friday'

                    'saturday'

                    'sunday').

    enDayAbbrevs := #('mon' 

                      'tue' 

                      'wed'

                      'thu' 

                      'fri' 

                      'sat' 

                      'sun').

    enMonthNames := #('january'

                      'february'

                      'march'

                      'april'

                      'may'

                      'june'

                      'july'

                      'august'

                      'september'

                      'october'

                      'november'

                      'december').

    enMonthAbbrevs := #('jan'

                        'feb'

                        'mar'

                        'apr'

                        'may'

                        'jun'

                        'jul'

                        'aug'

                        'sep'

                        'oct'

                        'nov'

                        'dec').

    DayNames at:#'en' put:enDayNames.

    DayAbbrevs at:#'en' put:enDayAbbrevs.

    MonthNames at:#'en' put:enMonthNames.

    MonthAbbrevs at:#'en' put:enMonthAbbrevs.

    DefaultFormats at:#'en' put:('%d-%m-%y').

    ShortFormats at:#'en' put:('%d-%m-%y').

    LongFormats at:#'en' put:('%(dayName), %d-%m-%y').

    "/ take the "master" language here, for the caching

    EnvironmentChange := (Smalltalk language asSymbol ~~ #'en').

    "

     Date initDefaultNames

    "

!

initNames

    "read the language specific names."

    |lang|

    DayNames isNil ifTrue:[

        self initDefaultNames.

    ].

    lang := Smalltalk language asSymbol.

    lang ~~ #'en' ifTrue:[

        self initNamesForLanguage: lang.

    ].

    EnvironmentChange := false

    "

     Date initNames

    "

!

initNamesForLanguage:language

    "read the language specific names."

    |resources lang 

     enDayNames enDayAbbrevs enMonthNames enMonthAbbrevs monthAbbrevKeys

     enDefaultFormat enLongFormat enShortFormat may|

    DayNames isNil ifTrue:[

        self initDefaultNames.

    ].

    lang := language asSymbol.

    lang ~~ #'en' ifTrue:[

	ResourcePack notNil ifTrue:[ "/ guard for tinytalk (no libview)

            resources := ResourcePack forPackage:'stx:libbasic' resourceFileName:(language,'.rs') cached:false.

	].

        resources notNil ifTrue:[

            enDayNames := DayNames at:#'en'.

            enDayAbbrevs := DayAbbrevs at:#'en'.

            enMonthNames := MonthNames at:#'en'.

            enMonthAbbrevs := MonthAbbrevs at:#'en'.

            monthAbbrevKeys := enMonthAbbrevs copy.

            monthAbbrevKeys at:5 put:'MAY_ABBREV'.

            enDefaultFormat := DefaultFormats at:#'en'.

            enShortFormat := ShortFormats at:#'en'.

            enLongFormat := LongFormats at:#'en'.

            DefaultFormats at:lang put:(resources at:'DATEFORMAT' default:enDefaultFormat).

            ShortFormats at:lang put:(resources at:'SHORTDATEFORMAT' default:enShortFormat).

            LongFormats at:lang put:(resources at:'LONGDATEFORMAT' default:enLongFormat).

            DayNames at:lang put:(resources array:enDayNames).

            DayAbbrevs at:lang put:(resources array:enDayAbbrevs).

            MonthNames at:lang put:(resources array:enMonthNames).

            MonthAbbrevs at:lang put:(resources array:monthAbbrevKeys).

            "/ may needs special care (same key for long and short name)

            may := resources string:'MAY_ABBREV' default:nil.

            may isNil ifTrue:[

                may := resources string:'may'.

            ].

            (MonthAbbrevs at:lang) at:5 put:may.

        ].

    ].

    "

     Date initNamesForLanguage:#de.

     Date initNamesForLanguage:#fr.

     Date initNamesForLanguage:#es.

    "

    "Modified (format): / 28-09-2011 / 15:56:41 / cg"

!

initialize

    DayNames isNil ifTrue:[

        self initDefaultNames.

    ].

    Smalltalk addDependent:self.

    Smalltalk language ~= 'en' ifTrue:[

        EnvironmentChange := true

    ]

! !

!Date class methodsFor:'instance creation'!

fromDays:dayCount

    "return a new Date, given the day-number starting with 0 at 1.Jan 1901;

     (i.e. 'Date fromDays:0' returns 1st Jan. 1901).

     Date asDays is the reverse operation.

     Notice, that this is not able to represent dates before 1901!!.

     Added for GNU/ST-80 compatibility"

    |year rest d yearIncrement yearAsDays|

    "approx. year"

    year := (dayCount // 366) + 1901.

    yearAsDays := (self yearAsDays:year).

    dayCount < 0 ifTrue:[

        rest := dayCount negated - yearAsDays + 1. "+1 for ST-80 compatibility"

        yearIncrement := -1.

    ] ifFalse:[

        rest := dayCount - yearAsDays + 1. "+1 for ST-80 compatibility"

        yearIncrement := 1.

    ].

    rest > 365 ifTrue:[

        [d := self daysInYear:year. rest > d] whileTrue:[

            "adjust"

            year := year + yearIncrement.

            rest := rest - d.

        ].

    ].

    ^ self newDay:rest year:year

    "

     Date fromDays:0     -> 1 jan 1901

     Date fromDays:365   -> 1 jan 1902

     Date fromDays:730   -> 1 jan 1903

     Date fromDays:1095  -> 1 jan 1904

     Date fromDays:1460  ->31 dec 1904 since 1904 was a leap year

    "

    "Modified: 1.7.1996 / 14:24:25 / cg"

!

fromDaysFrom0:dayCount

    "return a new Date, given the day-number starting with 0 at 1.Jan 0;

     (i.e. 'Date fromDaysSince0:0' returns 1st Jan. 0).

     Date asDaysSince0 is the reverse operation.

     Notice, that this is a private interface.

     Also notice: does not care for Gregorian/Julisn calendar change"

    |year rest d yearIncrement yearAsDaysFrom0|

    "approx. year"

    year := (dayCount // 366).

    yearAsDaysFrom0 := (self yearAsDaysFrom0:year).

    dayCount < 0 ifTrue:[

        rest := dayCount negated - yearAsDaysFrom0 + 1. "+1 for ST-80 compatibility"

        yearIncrement := -1.

    ] ifFalse:[

        rest := dayCount - yearAsDaysFrom0 + 1. "+1 for ST-80 compatibility"

        yearIncrement := 1.

    ].

    rest > 365 ifTrue:[

        [d := self daysInYear:year. rest > d] whileTrue:[

            "adjust"

            year := year + yearIncrement.

            rest := rest - d.

        ].

    ].

    ^ self newDay:rest year:year

    "

     Date fromDaysFrom0:0     -> 1 jan 0

     Date fromDaysFrom0:366   -> 1 jan 1

    "

!

newDay:dayInYear year:year

    "return a new Date, given the year and the day-in-year (starting at 1).

     See also: Date today / Time now / Timestamp now.

     ST-80 compatibility"

    |monthAndDay|

    ((dayInYear between:1 and:365) 

     or:[dayInYear == 366 and:[self leapYear:year]]) ifFalse:[

        "

         this error is triggered, when you try to create a

         day from an invalid day-in-year; 

         for example, 366 in a non-leap year.

         I don't know, if ST-80 wraps to the next year(s) in this case.

        "

        ^ self conversionErrorSignal raiseErrorString:' - Date: invalid day in year'.

    ].

    monthAndDay := self monthAndDayFromDayInYear:dayInYear forYear:year.

    ^ self basicNew year:year month:(monthAndDay at:1) day:(monthAndDay at:2)  

    "

     Date newDay:150 year:1994

     Date newDay:1 year:1994

     Date newDay:1 year:1901

     Date newDay:1 year:1902

     Date newDay:365 year:1992

     Date newDay:366 year:1992

     Date newDay:365 year:1994

     Date newDay:366 year:1994

     Date newDay:0 year:1994

     Date newDay:271 year:2008

     Date newDay:270 year:2008

     Date newDay:271 year:2007

    "

    "Modified: 1.7.1996 / 14:22:24 / cg"

!

newDayInWeek:dayInWeek week:week year:yearArg

    "return a new Date, given the year, the week (1..) and the day in week (1..7).

     See http://en.wikipedia.org/wiki/ISO_week_date"

    |weekDayOfJan4 dayInYear year|

    year := yearArg.

    weekDayOfJan4 := (self year:year month:1 day:4) dayInWeek.

    dayInYear := (week * 7) + dayInWeek - (weekDayOfJan4 + 3).

    dayInYear < 1 ifTrue:[

        dayInYear := dayInYear + (self daysInYear:year-1).

        year := year - 1.

    ].

    dayInYear > (self daysInYear:year) ifTrue:[

        dayInYear := dayInYear - (self daysInYear:year).

        year := year + 1.

    ].

    ^ self newDay:dayInYear year:year.

    "

     Date newDayInWeek:6 week:39 year:2008     

     Date newDayInWeek:1 week:40 year:2014     

     Date newDayInWeek:1 week:44 year:2014     

    "

!

readFrom:aStringOrStream format:aSqueakFormatArrayOrFormatString

    "return a new Date, reading a printed representation from aStream.

     aSqueakFormatArrayOrFormatString may either be a squeak formatArray

         1   day position (1, 2 or 3)

         2   month position (1..3)

         3   year position (1..3)

     or a formatString (see printing instance protocol)."

    ^ self 

        readFrom:aStringOrStream

        format:aSqueakFormatArrayOrFormatString 

        onError:[ self conversionErrorSignal raiseWith:aStringOrStream errorString:' - invalid Date' ]

    "

     Date readFrom:'19:11:1999' format:#( 1 2 3 )

     Date readFrom:'19-nov-1999' format:#( 1 2 3 )

     Date readFrom:'19:11:1999' format:#( 2 1 3 )  -> exception: wrong month

     Date readFrom:'5:12:1999' format:#( 2 1 3 )  

     Date readFrom:'may-12-1999' format:#( 2 1 3 )  

     Date readFrom:'1999 may 12' format:#( 3 2 1 )  

     Date readFrom:'12/31/2001' format:#( 2 1 3 ) 

     Date readFrom:' 31.08.2001' format:#( 1 2 3 )    

     Date readFrom:' 31.dec.2001' format:#( 1 2 3 )    

     Date readFrom:' 31.Dec.2001' format:#( 1 2 3 )    

     Date readFrom:' 31.dez.2001' format:#( 1 2 3 )    

     Date readFrom:'31/12/01' format:'%d %m %y' onError:'fail'       

     Date readFrom:'12/01' format:'%m %y' onError:'fail'       

     Date readFrom:'01' format:'%y' onError:'fail'        

     Date readFrom:'30.01' format:'%d %m' onError:'fail'       

    "

    "Created: 16.11.1995 / 22:50:17 / cg"

    "Modified: 8.10.1996 / 19:25:39 / cg"

!

readFrom:aStringOrStream format:aFormatStringOrSqueakFormatArray language:languageOrNil onError:exceptionBlock

    "return a new Date, reading a printed representation from aStream.

     aFormatStringOrSqueakFormatArray may either be a Squeak formatArray:

         1   day position (1, 2 or 3)

         2   month position (1..3)

         3   year position (1..3)

     or an ST/X formatString (see printing instance protocol).

     For now %d, %m, %monthName, %shortMonthName, %y, %Y, %y1900, %y2000, %y1950 and %y1980 are supported in the formatString.

     y1900 converts 2-digit year YY into 19YY, 

     y2000 into 20YY.

     y1950, y1980, y1970 and Y are special; 

     if the year is below 50/80/70/70, it is converted to 20YY, otherwise to 19YY. 

     The formatString can have any of these characters '-.:,;/' as separator.

     The format may be preceeded by a single numeric length (as in %2d) to specify how many

     characters to read.

     The formatString can also use a space as separator (for  ex. '%d %m %y') and any separator will be allowed.

     However, when a character separator is defined, only that separator will be expected.

     TODO: make this a general feature of all DateAndTime classes.

    "

    |str|

    str := aStringOrStream readStream.

    ^ [

        |day month year dayOfYear monthAndDay|

        aFormatStringOrSqueakFormatArray isString ifTrue:[

            |formatStream fc c sel somePartAssoc len lStr|

            formatStream := aFormatStringOrSqueakFormatArray readStream.

            [formatStream atEnd] whileFalse:[

                fc := formatStream next.

                fc == $% ifTrue:[

                    sel := ''.

                    len := nil.

                    (fc := formatStream peekOrNil) notNil ifTrue:[

                        fc isDigit ifTrue:[

                            len := fc digitValue.

                            formatStream next.

                        ]

                    ].    

                    (fc := formatStream peekOrNil) notNil ifTrue:[

                        fc == $( ifTrue:[

                            formatStream next.

                            sel := formatStream upTo:$)

                        ] ifFalse:[

                            sel := sel , (formatStream throughAnyForWhich:[:ch | ch isLetter])

                        ]

                    ].

                    len notNil ifTrue:[