Class: AbstractTime

• Inheritance
• Description
• Class protocol
  • Compatibility-Squeak
  • Compatibility-VW
  • error handling
  • format strings
  • instance creation
  • private-instance creation
  • queries
  • reading
  • timing evaluations
• Instance protocol
  • Compatibility-ANSI
  • Compatibility-ST80
  • JavaScript support
  • abstract
  • accessing
  • arithmetic
  • comparing
  • converting
  • double dispatching
  • inspecting
  • printing & storing
  • private
  • truncation & rounding
• Private classes

Inheritance:

   Object
   |
   +--Magnitude
      |
      +--AbstractChronologyObject
         |
         +--AbstractTime
            |
            +--Time
            |
            +--Timestamp

Package:

stx:libbasic

Category:

Kernel-Chronology

Version:

rev: 1.172 date: 2024/04/25 13:03:48

user: stefan

file: AbstractTime.st directory: libbasic

module: stx stc-classLibrary: libbasic

Description:

This is an abstract class providing common protocol for Time (time in day)
and Timestamp (time plus day).
There are no instances of this class in the system.
It is meant as a home for methods common to time handling classes.

copyright
COPYRIGHT (c) 1995 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.

iso8601FormatDocumentation
Abstract

  This document defines a profile of ISO 8601, the International Standard for the representation of dates and times. ISO
  8601 describes a large number of date/time formats. To reduce the scope for error and the complexity of software, it is
  useful to restrict the supported formats to a small number. This profile defines a few date/time formats, likely to satisfy
  most requirements. 


Formats

  Different standards may need different levels of granularity in the date and time, so this profile defines six levels.
  Standards that reference this profile should specify one or more of these granularities. If a given standard allows more
  than one granularity, it should specify the meaning of the dates and times with reduced precision, for example, the result
  of comparing two dates with different precisions.

  The formats are as follows. Exactly the components shown here must be present, with exactly this punctuation. Note
  that the 'T' appears literally in the string, to indicate the beginning of the time element, as specified in ISO 8601. 

     Year:
        YYYY (eg 1997)
     Year and month:
        YYYY-MM (eg 1997-07)
     Complete date:
        YYYY-MM-DD (eg 1997-07-16)
     Complete date plus hours and minutes:
        YYYY-MM-DDThh:mmTZD (eg 1997-07-16T19:20+01:00)
     Complete date plus hours, minutes and seconds:
        YYYY-MM-DDThh:mm:ssTZD (eg 1997-07-16T19:20:30+01:00)
     Complete date plus hours, minutes, seconds and a decimal fraction of a
  second
        YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00)

  where:

       YYYY = four-digit year
       MM   = two-digit month (01=January, etc.)
       DD   = two-digit day of month (01 through 31)
       hh   = two digits of hour (00 through 23) (am/pm NOT allowed)
       mm   = two digits of minute (00 through 59)
       ss   = two digits of second (00 through 59)
       s    = one or more digits representing a decimal fraction of a second
       TZD  = time zone designator (Z or +hh:mm or -hh:mm)

  This profile does not specify how many digits may be used to represent the decimal fraction of a second. An adopting
  standard that permits fractions of a second must specify both the minimum number of digits (a number greater than or
  equal to one) and the maximum number of digits (the maximum may be stated to be 'unlimited').

  This profile defines two ways of handling time zone offsets:

     1.Times are expressed in UTC (Coordinated Universal Time), with a special UTC designator ('Z'). 
     2.Times are expressed in local time, together with a time zone offset in hours and minutes. A time zone offset of
       '+hh:mm' indicates that the date/time uses a local time zone which is 'hh' hours and 'mm' minutes ahead of
       UTC. A time zone offset of '-hh:mm' indicates that the date/time uses a local time zone which is 'hh' hours and
       'mm' minutes behind UTC. 

  A standard referencing this profile should permit one or both of these ways of handling time zone offsets.

The ISO8601 printString are generated with:

     Year:
        YYYY (eg 1997)
              Date today printStringFormat:'%(year)'
              Timestamp now printStringFormat:'%(year)'  

     Year and month:
        YYYY-MM (eg 1997-07)
              Date today printStringFormat:'%(year)-%(month)'  
              Timestamp now printStringFormat:'%(year)-%(month)'  

     Complete date:
        YYYY-MM-DD (eg 1997-07-16)
              Date today printStringFormat:'%(year)-%(month)-%(day)'    
              Timestamp now printStringFormat:'%(year)-%(month)-%(day)'  

     Complete date plus hours and minutes:
        YYYY-MM-DDThh:mmTZD (eg 1997-07-16T19:20+01:00)
              Timestamp now printStringFormat:'%(year)-%(month)-%(day)T%h:%m%(TZD)'  

     Complete date plus hours, minutes and seconds:
        YYYY-MM-DDThh:mm:ssTZD (eg 1997-07-16T19:20:30+01:00)
              Timestamp now printStringFormat:'%(year)-%(month)-%(day)T%h:%m:%s%(TZD)'  

     Complete date plus hours, minutes, seconds and a decimal fraction of a second
        YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00)
              Timestamp now printStringFormat:'%(year)-%(month)-%(day)T%h:%m:%s.%(milli2)%(TZD)'  

printFormatDocumentation
bindings:
   %h      hours, 00..23 (i.e. european)  0-padded to length 2
   %u      hours, 00..12 (i.e. us)        0-padded to length 2
   %m      minutes, 00..59                0-padded to length 2
   %s      seconds, 00..59                0-padded to length 2
   %i      milliseconds, 000..999         0-padded to length 3
   %a      am/pm

Timestamp only:
   %(day)   day, 00..31                    0-padded to length 2
   %(month) month, 00..12                  0-padded to length 2
   %(year)  year, 4 digits                 0-padded to length 4

special:
   %H      24-hours - unpadded
   %U      12-hours - unpadded
   %M      minutes - unpadded
   %S      seconds - unpadded
   %I      milliseconds, unpadded
   %A      AM/PM   - uppercase

   %t      seconds within hour  (unpadded)
   %T      seconds from midNight  (unpadded)

   %(TZD)  timeZone delta of the receiver from UTC in the format +/-hh:mm

   %(milli1) milliseconds, truncated to 1/10th of a second 0..9
   %(milli2) milliseconds, truncated to 1/100th of a second 00..99 0-padded to length 2
   %(milli3) milliseconds, same as %i for convenience

Timestamp only:
   %(Day)         - day - unpadded
   %(Month)       - month - unpadded
   %(yearOrTime)  - year or time 5 digits    as in unix-ls:
                                             year if it is not the current year;
                                             time otherwise
   %(weekDay)      - day in week (1->monday, 2->tuesday, ... ,7->sunday)

   %(dayName)      - full day name
   %(DayName)      - full day name, first character uppercase
   %(DAYNAME)      - full day name, all uppercase

   %(monthName)    - full month name
   %(MonthName)    - full month name, first character uppercase
   %(MONTHNAME)    - full month name, all uppercase

   %(shortDayName) - short (abbreviated) day name
   %(ShortDayName) - short (abbreviated) day name, first character uppercase
   %(SHORTDAYNAME) - short (abbreviated) day name, all uppercase

   %(shortMonthName) - short (abbreviated) month name
   %(ShortMonthName) - short (abbreviated) month name, first character uppercase
   %(SHORTMONTHNAME) - short (abbreviated) month name, all uppercase

   %(nth)          - counting day-in-month (1->'st'; 2->'nd'; 3->'rd'; 4...->'th')
   %(weekDayNth)   - counting day-in-week (1->'st'; 2->'nd'; 3->'rd'; 4...->'th')
   %(weekNth)      - counting week-in-year (1->'st'; 2->'nd'; 3->'rd'; 4...->'th')

   %(yearRoman)    - year, in roman letters
   %(monthRoman)   - month, in roman letters


The ISO8601 printString are documented in iso8601FormatDocumentation:

Class protocol:

 dateAndTimeFromSeconds: secondCount

set date and time from seconds since 1901-01-01 00:00 UTC

Usage example(s):

Timestamp dateAndTimeFromSeconds: (Time primSecondsClock) Time dateAndTimeFromSeconds: (Time totalSeconds) Date dateAndTimeFromSeconds: (Time totalSeconds)

 milliseconds: msTime1 since: msTime2

return the number of milliseconds between two
millisecond time values, compensating for roll-over.
The same as millisecondsBetween:and: for Squeak compatibility.

 millisecondsSince: lastTime

Answer the elapsed time since last recorded in milliseconds.
Compensate for rollover.

 primSecondsClock

returns the number of seconds since 1.1.1901 UTC

Usage example(s):

Timestamp primSecondsClock

 microsecondClock
( an extension from the stx:libcompat package )

 totalSeconds

returns the number of seconds since 1.1.1901 UTC

 conversionErrorSignal

return the signal used for conversion error handling

 defaultFormatString

 printBindingMirrorClass

 epoch

answer the time when we start counting

Usage example(s):

Timestamp epoch Time epoch

 now

return an instance of myself representing this moment with at least second precision.
Timestamps will redefine this to always return millisecond precision.

Usage example(s):

Timestamp now => 2022-03-09 00:49:50.082 UtcTimestamp now => 2022-03-08 23:50:10.510Z TZTimestamp now => 2022-03-09 00:50:34.391+01 Time now => 12:50:22 AM

 nowWithMicroseconds

return an instance of myself representing this moment with microsecond precision.
(if supported by the operating system; if not, you'll get milli resolution)

Usage example(s):

Timestamp now Time now Timestamp nowWithMilliseconds 2022-03-09 01:04:02.554 Timestamp nowWithMicroseconds 2022-03-09 01:04:04.074 TZTimestamp nowWithMilliseconds 2022-03-09 01:04:05.929+01 TZTimestamp nowWithMicroseconds 2022-03-09 01:04:07.275+01 UtcTimestamp nowWithMilliseconds 2022-03-09 00:04:08.666Z UtcTimestamp nowWithMicroseconds 2022-03-09 00:04:09.898Z (1 to:200) collect:[:y| Timestamp nowWithMicroseconds ]

 nowWithMilliseconds

return an instance of myself representing this moment with millisecond precision.
(if supported by the operating system; if not, you'll get whatever the ticks are)

Usage example(s):

Time now Time nowWithMilliseconds Timestamp now Timestamp nowWithMilliseconds Timestamp nowWithMicroseconds

 nowWithNanoseconds

return an instance of myself representing this moment with nanosecond precision.
(if supported by the operating system; if not, you'll get micro or milli resolution)

Usage example(s):

Timestamp now Time now Timestamp nowWithMilliseconds 2022-03-09 01:04:02.554 Timestamp nowWithMicroseconds 2022-03-09 01:04:04.074 Timestamp nowWithNanoseconds 2024-03-01 11:43:42.918 TZTimestamp nowWithMilliseconds 2022-03-09 01:04:05.929+01 TZTimestamp nowWithMicroseconds 2022-03-09 01:04:07.275+01 TZTimestamp nowWithNanoseconds 2024-03-01 11:43:53.630+01 UtcTimestamp nowWithMilliseconds 2022-03-09 00:04:08.666Z UtcTimestamp nowWithMicroseconds 2022-03-09 00:04:09.898Z UtcTimestamp nowWithNanoseconds 2024-03-01 10:44:01.370Z { UtcTimestamp nowWithNanoseconds. UtcTimestamp nowWithNanoseconds} (1 to:200) collect:[:y| Timestamp nowWithMicroseconds ]

 utcNow

return an instance of myself representing this momentin the UTC timezone.

** This method must be redefined in concrete classes (subclassResponsibility) **

 fromOSTime: osTime

return a time, representing the time given by the operatingSystem time.
Not meant for public use.

 fromSeconds: seconds

return an instance that is constructed from seconds.
This method is only allowed for second values as returned by
getSeconds, possibly adding/subtracting to that.
Never depend on any specific interpretation of the seconds,
since it depends on how the OperatingSystem counts time
(some start at 1900, others with 1970 ...)

Usage example(s):

Time fromSeconds:0 should return midnight Timestamp fromSeconds:0 on UNIX: returns 1st. Jan 1970 on others: don't know (Timestamp day:1 month:1 year:1970 hour:1 minutes:0 seconds:0) getSeconds on UNIX: returns 0 on others: don't know

 isAbstract

Return if this class is an abstract class.
True is returned here for myself only; false for subclasses.
Abstract subclasses must redefine this again.

 microsecondClockValue

This returns a microsecond timer value.
The returned value is a 64bit value
(which is the number of microseconds since the system's boot time -
but you should not depend on that because it is system specific.
Only use for relative delta-times.

Usage example(s):

Time microsecondClockValue

Usage example(s):

|t1 t2 overhead| t1 := Time microsecondClockValue. t2 := Time microsecondClockValue. overhead := t2 - t1. t1 := Time microsecondClockValue. 100 factorial. t2 := Time microsecondClockValue. t2 - t1 - overhead

 millisecondClockValue

return the millisecond clock - since this one overruns
regularly, use the value only for short timing deltas.
Also remember that it wraps when comparing these values.

Usage example(s):

Time millisecondClockValue

 secondClock

return seconds of now - for GNU-ST compatibility

Usage example(s):

AbstractTime secondClock

 readFrom: aStringOrStream format: formatString

see format description in readFrom:format:language:onError:

 readFrom: aStringOrStream format: formatString language: languageString onError: exceptionalValue

see format description in readFrom:format:language:onError:

** This method must be redefined in concrete classes (subclassResponsibility) **

 readFrom: aStringOrStream format: formatString onError: exceptionalValue

see format description in readFrom:format:language:onError:

 microsecondsToRun: aBlock

evaluate the argument, aBlock; return the number of microseconds it took

Usage example(s):

Time microsecondsToRun:[1000 factorial]

 millisecondsToRun: aBlock

evaluate the argument, aBlock; return the number of milliseconds it took

Usage example(s):

Time millisecondsToRun:[1000 factorial]

 secondsToRun: aBlock

evaluate the argument, aBlock; return the number of seconds it took

Usage example(s):

Time secondsToRun:[1000 factorial]

 toRun: aBlock

return the TimeDuration it takes to execute aBlock.
A modern variant of Time millisecondsToRun: (which prints itself nicely)

Usage example(s):

Time toRun:[ 20000 factorial ] Time toRun:[ 2000 factorial ] Time toRun:[ 900 factorial ] Time toRun:[ 10 factorial ]

Instance protocol:

 hour12

return the hour (1..12).

Usage example(s):

Time now hour12 Time now hour24 (Time hours:0 minutes:0 seconds:0) hour24 (Time hours:0 minutes:0 seconds:0) hour12 (Time hours:1 minutes:0 seconds:0) hour24 (Time hours:1 minutes:0 seconds:0) hour12 (Time hours:12 minutes:0 seconds:0) hour24 (Time hours:12 minutes:0 seconds:0) hour12 (Time hours:13 minutes:0 seconds:0) hour24 (Time hours:13 minutes:0 seconds:0) hour12 (Time hours:23 minutes:0 seconds:0) hour24 (Time hours:23 minutes:0 seconds:0) hour12 (Time hours:24 minutes:0 seconds:0) hour24 (Time hours:24 minutes:0 seconds:0) hour12

 hour24

return the hour (0..23).

Usage example(s):

Time now hour12 Time now hour24 (Time hours:0 minutes:0 seconds:0) hour24 (Time hours:0 minutes:0 seconds:0) hour12 (Time hours:1 minutes:0 seconds:0) hour24 (Time hours:1 minutes:0 seconds:0) hour12 (Time hours:12 minutes:0 seconds:0) hour24 (Time hours:12 minutes:0 seconds:0) hour12 (Time hours:13 minutes:0 seconds:0) hour24 (Time hours:13 minutes:0 seconds:0) hour12 (Time hours:23 minutes:0 seconds:0) hour24 (Time hours:23 minutes:0 seconds:0) hour12 (Time hours:24 minutes:0 seconds:0) hour24 (Time hours:24 minutes:0 seconds:0) hour12

 meridianAbbreviation

am/pm

Usage example(s):

Time now meridianAbbreviation (Time hours:0 minutes:0 seconds:0) meridianAbbreviation (Time hours:11 minutes:59 seconds:59) meridianAbbreviation (Time hours:12 minutes:0 seconds:0) meridianAbbreviation (Time hours:12 minutes:0 seconds:1) meridianAbbreviation

 hour

return the hour (0..23).
ST-80 Timestamp compatibility
(I'd prefer the name #hours, for Time compatibility).

 minute

return the minute (0..59).
ST-80 Timestamp compatibility
(I'd prefer the name #minutes, for Time compatibility).

 second

return the second (0..59).
ST-80 Timestamp compatibility
(I'd prefer the name #seconds, for Time compatibility).

 js_add: aNumberOrString
( an extension from the stx:libjavascript package )

For JavaScript only:
Generated for +-operator in javascript.
See JavaScriptParser >> commonTranslatedSelectorFor:jsSelector

 js_addFromTime: aTime
( an extension from the stx:libjavascript package )

For JavaScript only:
Generated for +-operator in javascript.

 js_getHours
( an extension from the stx:libjavascript package )

return the hours (0..24).
For JavaScript only:
Generated for getHours() in javascript.
See JavaScriptParser >> commonTranslatedSelectorFor:jsSelector

 js_getMilliseconds
( an extension from the stx:libjavascript package )

return the millieconds (0..999).
For JavaScript only:
Generated for getMilliseconds() in javascript.
See JavaScriptParser >> commonTranslatedSelectorFor:jsSelector

Usage example(s):

JavaScriptParser evaluate:'Date.now.js_getMilliseconds;'

 js_getMinutes
( an extension from the stx:libjavascript package )

return the minutes (0..60).
For JavaScript only:
Generated for getMinutes() in javascript.
See JavaScriptParser >> commonTranslatedSelectorFor:jsSelector

 js_getSeconds
( an extension from the stx:libjavascript package )

return the seconds (0..60).
For JavaScript only:
Generated for getSeconds() in javascript.
See JavaScriptParser >> commonTranslatedSelectorFor:jsSelector

 hours

return the hour of time (0..23)

** This method must be redefined in concrete classes (subclassResponsibility) **

 milliseconds

return the milliseconds since the start of the second (0..999)

** This method must be redefined in concrete classes (subclassResponsibility) **

 minutes

return the minutes since the start of the hour (0..59)

** This method must be redefined in concrete classes (subclassResponsibility) **

 seconds

return the seconds since the start of the minute (0..59)

** This method must be redefined in concrete classes (subclassResponsibility) **

 hourInDay

return the hours (0..23)

Usage example(s):

Timestamp now hourInDay Time now hourInDay

 microseconds

return the microseconds within the current second (0..999999)

Usage example(s):

Timestamp now microseconds Timestamp nowWithMicroseconds microseconds

 minuteInDay

return the minutes (0..59)

Usage example(s):

Timestamp now minuteInDay Time now minuteInDay

 nanoseconds

return the nanoseconds within the current second (0..999999)

Usage example(s):

Timestamp now nanoseconds Timestamp nowWithMicroseconds nanoseconds

 picoseconds

return the picoseconds within the current second (0..999999999).
notice: that is NOT the total number of picoseconds,
but the fractional part (within the second) only.
Use this only for printing.
Here, fall back and generate something based on the milliseconds

Usage example(s):

Timestamp now picoseconds Timestamp nowWithMicroseconds picoseconds (TimeDuration fromPicoseconds:100) picoseconds (TimeDuration fromPicoseconds:100000) picoseconds (TimeDuration fromPicoseconds:100000) nanoseconds (TimeDuration fromPicoseconds:100000000) picoseconds (TimeDuration fromPicoseconds:100000000) nanoseconds (TimeDuration fromPicoseconds:100000000) microseconds (TimeDuration fromPicoseconds:100000000000) picoseconds (TimeDuration fromPicoseconds:100000000000) nanoseconds (TimeDuration fromPicoseconds:100000000000) microseconds (TimeDuration fromPicoseconds:100000000000) milliseconds

 secondInDay

return the seconds (0..59)

Usage example(s):

Timestamp now secondInDay Time now seconds

 timeZoneDeltaInMinutes

answer the number of minutes between local time and utc time.
Delta is positive if local time is ahead of utc, negative if behind utc.

 timeZoneName

 utcOffset

 + aNumberOrTimeDuration

Add aNumber (numberOfSeconds) or, if it's a timeDuration, add it's value

Usage example(s):

Timestamp now to:(Timestamp now + 30) by:2 do:[:time| Transcript showCR:time. ]. Timestamp now to:(Timestamp now + 30) by:2 seconds do:[:time| Transcript showCR:time. ]. (Timestamp now + 30 seconds) to:(Timestamp now) by:-2 seconds do:[:time| Transcript showCR:time. ]. (Timestamp now + 30 seconds) to:(Timestamp now) by:-2 do:[:time| Transcript showCR:time. ]. (Timestamp now + 20) - Timestamp now (Timestamp now + 0.5) - Timestamp now (Timestamp now + (TimeDuration fromString:'1m 10s')) - Timestamp now (Timestamp now + (10 seconds)) - Timestamp now

 - aTimeOrTimeDurationOrNumberOfSeconds

return the delta in seconds between 2 times or subtract a number of seconds.

Usage example(s):

should we convert to timestamp i.e. caring for time-wrapping at midnight?

Usage example(s):

no - for compatibility, we'll get the time-within-the day again

Usage example(s):

Timestamp now - 3600. -> 2018-05-09 15:37:57.485 Timestamp now - 3600 seconds. -> 2018-05-09 15:38:04.665 (Timestamp now addSeconds:10) - Timestamp now -> 10s Time now - 3600. -> 03:38:23 PM Time now - 3600 seconds. -> 03:38:35 PM (Time now addSeconds:10) - Time now -> 10s Time now - 1 hours. -> 11:04:02 Time now - 24 hours. -> 11:04:02 (TimeDuration fromString:'1.5hr') - 3600. -> 30m (TimeDuration fromString:'1.5hr') - (TimeDuration fromString:'1hr') -> 30m |t1 t2| t1 := Timestamp now. Delay waitFor:10 seconds. t2 := Timestamp now. Transcript showCR:('seconds passed: ' , (t2 - t1) printString).

Usage example(s):

Modified (comment): / 08-05-2019 / 12:49:59 / Claus Gittinger

 addDays: numberOfDays

return a new instance of myself, numberOfDays afterwards.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t addDays:7)

 addHours: numberOfHours

return a new instance of myself, numberOfHours afterwards.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t addHours:12).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t addHours:12).

 addMicroseconds: numberOfMicroSeconds

return a new instance of myself, numberOfMicroSeconds afterwards.

Usage example(s):

|t1 t2| t1 := Timestamp now. Transcript showCR:t1. t2 := t1 addMicroseconds:1000. Transcript showCR:t2. t2 := t1 addMicroseconds:1010. Transcript showCR:t2. Transcript showCR:(t2 - t1). self halt. Transcript showCR:(t2 - t1) asMicroseconds.

 addMilliseconds: numberOfMilliSeconds

return a new instance of myself, numberOfMilliSeconds afterwards.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t addMilliseconds:100).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t addMilliseconds:1000).

 addMinutes: numberOfMinutes

return a new instance of myself, numberOfMinutes afterwards.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t addMinutes:60).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t addMinutes:60).

 addSeconds: numberOfSeconds

return a new instance of myself, numberOfSeconds afterwards.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t addSeconds:60).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t addSeconds:60).

 addTime: timeAmount

return a new instance of myself, timeAmount seconds afterwards.
Provided for ST-80 compatibility.
WARNING:
AddTime is a bad name - it does not add a time, but expects
a numberOfSeconds as argument.
Use any of addSeconds/addHours etc. to make things clear

 deltaFrom: aTimeOrInteger

return the delta as a TimeDuration between 2 timeStamps.
If the argument is an Integer, the return value is an instance of my class.
The argument is supposed to be BEFORE the receiver,
computes self - aTimestamp

Usage example(s):

Time now deltaFrom:10 minutes. Time now deltaFrom:3600. Time now deltaFrom:3600 seconds. Timestamp now deltaFrom:10 minutes. Timestamp now deltaFrom:3600. Timestamp now deltaFrom:3600 seconds.

Usage example(s):

|t1 t2| t1 := Timestamp now. Delay waitForSeconds:0.5. t2 := Timestamp now. t2 deltaFrom:t1

 subtractDays: numberOfDays

return a new instance of myself, numberOfDays before.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t subtractDays:50)

 subtractHours: numberOfHours

return a new instance of myself, numberOfHours before.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t subtractHours:12).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t subtractHours:12).

 subtractMilliseconds: numberOfMilliSeconds

return a new instance of myself, numberOfMilliSeconds before.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t subtractMilliseconds:100).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t subtractMilliseconds:1000).

 subtractMinutes: numberOfMinutes

return a new instance of myself, numberOfMinutes before.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t subtractMinutes:60).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t subtractMinutes:60).

 subtractSeconds: numberOfSeconds

return a new instance of myself, numberOfSeconds before.

Usage example(s):

|t| t := Timestamp now. Transcript showCR:t. Transcript showCR:(t subtractSeconds:60).

Usage example(s):

|t| t := Time now. Transcript showCR:t. Transcript showCR:(t subtractSeconds:60).

 subtractTime: timeAmount

return a new instance of myself, timeAmount seconds before myself.
Provided for ST-80 compatibility.
WARNING:
SubtractTime is a bad name - it does not add a time, but expects
a numberOfSeconds as argument.
Use any of addSeconds/addHours etc. to make things clear

 < aTimeOrTimeDurationOrNumberOfSeconds

return true if the receiver is before the argument

Usage example(s):

(Timestamp now + 10) - Timestamp now < 10 (Timestamp now + 10) - Timestamp now < 11

 <= aTimeOrTimeDurationOrNumberOfSeconds

return true if the receiver is before or the same time as the argument

Usage example(s):

(Timestamp now + 10) - Timestamp now <= 10 (Timestamp now + 10) - Timestamp now <= 11 (Timestamp now + 10) - Timestamp now <= 9

 = aTimeOrTimeDurationOrNumberOfSeconds

return true if the receiver is the same time or duration as the argument

Usage example(s):

0 seconds = 0 (Timestamp now + 10) - Timestamp now = 10 (Timestamp now + 10) - Timestamp now = 9 (Timestamp now) = (Timestamp now + 10 - 10) (Timestamp now) = (UtcTimestamp now) (Time now + 10 seconds) - Time now = 10 (Time now + 10) - Time now = 10 (Time now + 10 seconds) > Time now (Time now + 10) > Time now (Time now + 10 milliSeconds) > Time now (Time now + 0 milliseconds) > Time now

 > aTimeOrTimeDurationOrNumberOfSeconds

return true if the receiver is after the argument

Usage example(s):

0 seconds > 0 (Timestamp now + 10) - Timestamp now > 10 (Timestamp now + 10) - Timestamp now > 9

 >= aTimeOrTimeDurationOrNumberOfSeconds

return true if the receiver is after the argument or the same

Usage example(s):

(Timestamp now + 10) - Timestamp now >= 11 (Timestamp now + 10) - Timestamp now >= 10 (Timestamp now + 10) - Timestamp now >= 9

 hash

(comment from inherited method)
instances, for which #= answers true must answer the same hash

 asAbsoluteTime

deprecated, use #asTimestamp

** This is an obsolete interface - do not use it (it may vanish in future versions) **

 asLocalTimestamp

represent myself as a timestamp in the local timezone

** This method must be redefined in concrete classes (subclassResponsibility) **

 asMilliseconds

return the number of milliseconds elapsed since some starttime,
which is subclass specific (i.e. Time: since midnight; Timestamp: since the epoch).
Use this only to compute relative millisecond deltas.

Usage example(s):

Time now asMilliseconds Timestamp now asMilliseconds (TimeDuration days:1) asMilliseconds (TimeDuration hours:1) asMilliseconds

 asNanoseconds

return the number of nanoseconds elapsed since some starttime,
which is subclass specific (i.e. Time: since midnight; Timestamp: since the epoch).
Use this only to compute relative nanosecond deltas.

Usage example(s):

Time now asNanoseconds

 asSeconds

get the seconds since some point of time in the past.
For Time instances, this is the number of seconds elapsed since midnight (truncated);
For TimeDurations, that is the duration in seconds (truncated);
For TimeStamps, that is the number of seconds since the epoch (truncated)

Usage example(s):

Timestamp now asSeconds Time now asSeconds (TimeDuration days:1) asSeconds

 asTZTimestamp

raise an error: must be redefined in concrete subclass(es)

** This method must be redefined in concrete classes (subclassResponsibility) **

 asTime

return a Time object from the receiver.

Usage example(s):

(1 seconds + 0.01 seconds) asTime

 asTimestamp

represent myself as a Timestamp

** This method must be redefined in concrete classes (subclassResponsibility) **

 asUtcTimestamp

represent myself as a timestamp in the local timezone

** This method must be redefined in concrete classes (subclassResponsibility) **

 differenceFromTimestamp: aTimestamp

return the time difference as a timeDuration instance

** This method must be redefined in concrete classes (subclassResponsibility) **

 inspectorValueListIconFor: anInspector
( an extension from the stx:libtool package )

returns the icon to be shown alongside the value list of an inspector

 addBasicPrintBindingsTo: aDictionary language: languageOrNil

marked as obsolete by exept MBP at 04-12-2021

** This is an obsolete interface - do not use it (it may vanish in future versions) **

 addPrintBindingsTo: aDictionary language: languageOrNil

marked as obsolete by exept MBP at 04-12-2021

** This is an obsolete interface - do not use it (it may vanish in future versions) **

 printIso8601CompressedOn: aStream

Timestamp now printStringIso8601 -> '2018-05-09T12:15:53.279'
Time now printStringIso8601 -> 'T16:27:08'
Date today printStringIso8601 -> '2018-05-09'

Timestamp now printStringIso8601Compressed -> '20180525T120822.699'
Time now printStringIso8601Compressed -> 'T120837'
Date today printStringIso8601Compressed -> '20180525'


** This method must be redefined in concrete classes (subclassResponsibility) **

 printIso8601FormatOn: aStream

Timestamp now printStringIso8601 -> '2018-05-09T12:15:53.279+02'
Time now printStringIso8601 -> 'T16:27:08'
Date today printStringIso8601 -> '2018-05-09'


** This method must be redefined in concrete classes (subclassResponsibility) **

 printIso8601FormatWithSubMilliseconds: withSubMilliseconds on: aStream

Timestamp now printStringIso8601 -> '2018-05-09T12:15:53.279+02'
Time now printStringIso8601 -> 'T16:27:08'
Date today printStringIso8601 -> '2018-05-09'


** This method must be redefined in concrete classes (subclassResponsibility) **

 printOn: aStream format: aFormatString

print using a format string;
See AbstractTime::PrintBindingMirror class >> #documentation for allowed format strings

Usage example(s):

Timestamp now printOn:Transcript format:'%h:%m:%s' . Transcript cr. Time now printOn:Transcript format:'%h:%m:%s' . Transcript cr. Time now printOn:Transcript format:'%H:%m:%s' . Transcript cr. Time now printOn:Transcript format:'%u:%m:%s %a'. Transcript cr. Time now printOn:Transcript format:'%h:%m' . Transcript cr. Time now printOn:Transcript format:'%H:%m %A' . Transcript cr. Time now printOn:Transcript format:'minutes:%M seconds:%S'. Transcript cr.

 printOn: aStream format: aFormatString language: languageOrNil

print using a format string;
See AbstractTime::PrintBindingMirror class >> #documentation for allowed format strings

Usage example(s):

Timestamp now printOn:Transcript format:'%h:%m:%s' . Transcript cr. Time now printOn:Transcript format:'%h:%m:%s' . Transcript cr. Time now printOn:Transcript format:'%H:%m:%s' . Transcript cr. Time now printOn:Transcript format:'%u:%m:%s %a'. Transcript cr. Time now printOn:Transcript format:'%h:%m' . Transcript cr. Time now printOn:Transcript format:'%H:%m %A' . Transcript cr. Time now printOn:Transcript format:'minutes:%M seconds:%S'. Transcript cr.

 printStringFormat: aFormatString

print using a format string.
See AbstractTime::PrintBindingMirror class >> #documentation for allowed format strings

Usage example(s):

Timestamp now printStringFormat:'%U:%m:%s %a' Timestamp now printStringFormat:'%u:%m:%s %a' Time now printStringFormat:'%U:%m:%s %a' Time now printStringFormat:'%u:%m:%s %a' Time now printStringFormat:'%h:%m:%s' Time now printStringFormat:'%H:%m:%s' Time now printStringFormat:'%H:%m:%s.%i' Timestamp now printStringFormat:'%H:%m:%s.%i' Timestamp now printStringFormat:'%H:%m:%s.%(milli1)' Timestamp now printStringFormat:'%H:%m:%s.%(milli2)' Timestamp now printStringFormat:'%(day)-%(month)-%(year) :%m:%s' => '12-03-2024 :03:53' Timestamp now printStringFormat:'%(day)-%(monthName)-%(year) :%m:%s' => '12-march-2024 :03:58' Timestamp now printStringFormat:'%(day)-%(monthname)-%(year) :%m:%s' => '12-march-2024 :03:58' Timestamp now printStringFormat:'%(day)-%(MonthName)-%(year) :%m:%s' => '12-March-2024 :04:32' Timestamp now printStringFormat:'%(day)-%(MONTHNAME)-%(year) :%m:%s' => '12-MARCH-2024 :05:27' Timestamp now printStringFormat:'%(dayName)-%(month)-%(year) :%m:%s' => 'tuesday-03-2024 :06:35' Timestamp now printStringFormat:'%(DayName)-%(month)-%(year) :%m:%s' => 'Tuesday-03-2024 :06:51' Timestamp now printStringFormat:'%(DAYNAME)-%(month)-%(year) :%m:%s' => 'TUESDAY-03-2024 :06:57' Time now printStringFormat:'%u:%m:%s %a' Time now printStringFormat:'%h:%m' Time now printStringFormat:'%h:%m' Time now printStringFormat:'%H:%m %A' Time now printStringFormat:'%m minutes after %U %a' Time now printStringFormat:'%t seconds after %U %a' Time now printStringFormat:'%T seconds from midNight'

 printStringFormat: aFormatString language: languageString

print using a format string.
See AbstractTime::PrintBindingMirror class >> #documentation for allowed format strings

Usage example(s):

Timestamp now printStringFormat:'%U:%m:%s %a' Time now printStringFormat:'%U:%m:%s %a' Time now printStringFormat:'%h:%m:%s' Time now printStringFormat:'%H:%m:%s' Time now printStringFormat:'%H:%m:%s.%i' Timestamp now printStringFormat:'%H:%m:%s.%i' Timestamp now printStringFormat:'%H:%m:%s.%(milli1)' Timestamp now printStringFormat:'%H:%m:%s.%(milli2)' Timestamp now printStringFormat:'%(day)-%(month)-%(year) :%m:%s' Timestamp now printStringFormat:'%(day)-%(monthName)-%(year) :%m:%s' language:#en Timestamp now printStringFormat:'%(day)-%(monthName)-%(year) :%m:%s' language:#de Timestamp now printStringFormat:'%(day)-%(monthName)-%(year) :%m:%s' language:#fr Time now printStringFormat:'%u:%m:%s %a' Time now printStringFormat:'%h:%m' Time now printStringFormat:'%h:%m' Time now printStringFormat:'%H:%m %A' Time now printStringFormat:'%m minutes after %U %a' Time now printStringFormat:'%t seconds after %U %a' Time now printStringFormat:'%T seconds from midNight'

 printStringIso8601

return the Iso8601 representation of the receiver with local timezon information.
This format looks like:
1999-01-01T24:00:00
or, for zero hr:min:sec,
1999-01-01
Of course, a 24 hour clock is used.

Usage example(s):

Timestamp now printStringIso8601

 printStringIso8601Compressed

return the Iso8601 representation of the receiver with local timezon information.
This format looks like:
1999-01-01T24:00:00
or, for zero hr:min:sec,
1999-01-01
Of course, a 24 hour clock is used.

Usage example(s):

Timestamp now printStringIso8601Compressed

 printStringIso8601Format

would like to make it obsolete, but it is:

Usage example(s):

Timestamp now printStringIso8601Format

 fromOSTime: osTime

set my time, from operatingSystems time parts

** This method must be redefined in concrete classes (subclassResponsibility) **

 fromOSTimeWithMilliseconds: anUninterpretedOSTime

strictly private: set the milliseconds from an OS time (since the epoch)

** This method must be redefined in concrete classes (subclassResponsibility) **

 fromOSTimeWithMilliseconds: anUninterpretedOSTime additionalPicoseconds: picos

strictly private: set the milliseconds and picoSeconds from an OS time (since the epoch)

** This method must be redefined in concrete classes (subclassResponsibility) **

 getMicroseconds

get the milliseconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.
Also be aware that the returned value is concrete-class specific;
Time returns the micros since midnight, Timestamp since the epoch.
Use this only to compute relative time deltas.
Here is a fallback, which only returns milliseocnd precision values

 getMilliseconds

get the milliseconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.
Also be aware that the returned value is concrete-class specific;
Time returns the millis since midnight, Timestamp since the epoch.
Use this only to compute relative time deltas.

** This method must be redefined in concrete classes (subclassResponsibility) **

 getNanoseconds

get the nanoseconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.
Also be aware that the returned value is concrete-class specific;
Time returns the nanos since midnight, Timestamp since the epoch.
Use this only to compute relative time deltas.
Here is a fallback, which only returns microseocnd precision values

 getSeconds

get the (truncated) seconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.

** This method must be redefined in concrete classes (subclassResponsibility) **

 setMicroseconds: nanos

set the microseconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.

 setMilliseconds: millis

set the milliseconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.

** This method must be redefined in concrete classes (subclassResponsibility) **

 setMilliseconds: arg1 additionalPicoseconds: arg2

raise an error: must be redefined in concrete subclass(es)

** This method must be redefined in concrete classes (subclassResponsibility) **

 setNanoseconds: nanos

set the nanoseconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.

 setPicoseconds: picos

set the picoseconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.

 setSeconds: secs

set the seconds since some point of time in the past.
Since I am abstract (not knowing how the time is actually
represented), this must be done by a concrete class.

** This method must be redefined in concrete classes (subclassResponsibility) **

 speciesNew

 nextMultipleOf: aTimeDuration

round the receiver up to the next multiple of a TimeDuration.

Usage example(s):

(TimeDuration fromSeconds:25) nextMultipleOf:60 seconds => 1m (TimeDuration fromMilliseconds:25234) nextMultipleOf:2 seconds => 26s Time now nextMultipleOf:10 minutes => 21:40:00 Timestamp now nextMultipleOf:10 minutes => 2023-06-06 21:40:00

 roundTo: aTimeDuration

round the receiver to the next multiple of a TimeDuration.
Bad name: should be called roundedTo: because it returns a new instance

Usage example(s):

(TimeDuration fromMicroseconds:25234) roundTo:2 milliSeconds => 26s (TimeDuration fromMilliseconds:25234) roundTo:10 milliSeconds => 25.23s (TimeDuration fromMilliseconds:25234) roundTo:100 milliSeconds => 25.2s Time now roundTo:10 minutes => 21:30:00 Timestamp now roundTo:10 minutes => 2023-06-06 21:30:00

 truncateTo: aTimeDuration

truncate the receiver to the previous multiple of a TimeDuration.
Bad name: should be called truncatedTo: because it returns a new instance

Usage example(s):

(TimeDuration fromMilliseconds:25234) truncateTo:2 seconds => 24s Time now truncateTo:10 minutes => 21:20:00 Timestamp now truncateTo:10 minutes => 2023-06-06 21:20:00

Private classes:

    PrintBindingMirror