TARG=time
GOFILES=\
+ format.go \
sleep.go\
tick.go\
time.go\
--- /dev/null
+package time
+
+import (
+ "strconv"
+)
+
+const (
+ numeric = iota
+ alphabetic
+ separator
+)
+
+// These are predefined layouts for use in Time.Format.
+// The standard time used in the layouts is:
+// Mon Jan 2 15:04:05 PST 2006 (PST is GMT-0800)
+// which is Unix time 1136243045.
+const (
+ ANSIC = "Mon Jan 2 15:04:05 2006"
+ UnixDate = "Mon Jan 2 15:04:05 PST 2006"
+ RFC850 = "Monday, 02-Jan-06 15:04:05 PST"
+ RFC1123 = "Mon, 02 Jan 2006 15:04:05 PST"
+ Kitchen = "3:04PM"
+ // Special case: use Z to get the time zone formatted according to ISO 8601,
+ // which is -0800 or Z for UTC
+ ISO8601 = "2006-01-02T15:04:05Z"
+)
+
+const (
+ stdLongMonth = "January"
+ stdMonth = "Jan"
+ stdNumMonth = "1"
+ stdZeroMonth = "01"
+ stdLongWeekDay = "Monday"
+ stdWeekDay = "Mon"
+ stdDay = "2"
+ stdZeroDay = "02"
+ stdHour = "15"
+ stdHour12 = "3"
+ stdZeroHour12 = "03"
+ stdMinute = "4"
+ stdZeroMinute = "04"
+ stdSecond = "5"
+ stdZeroSecond = "05"
+ stdLongYear = "2006"
+ stdYear = "06"
+ stdZulu = "1504"
+ stdPM = "PM"
+ stdpm = "pm"
+ stdTZ = "PST"
+ stdISO8601TZ = "Z"
+)
+
+var longDayNames = []string{
+ "Sunday",
+ "Monday",
+ "Tuesday",
+ "Wednesday",
+ "Thursday",
+ "Friday",
+ "Saturday",
+}
+
+var shortDayNames = []string{
+ "Sun",
+ "Mon",
+ "Tue",
+ "Wed",
+ "Thu",
+ "Fri",
+ "Sat",
+}
+
+var shortMonthNames = []string{
+ "---",
+ "Jan",
+ "Feb",
+ "Mar",
+ "Apr",
+ "May",
+ "Jun",
+ "Jul",
+ "Aug",
+ "Sep",
+ "Oct",
+ "Nov",
+ "Dec",
+}
+
+var longMonthNames = []string{
+ "---",
+ "January",
+ "February",
+ "March",
+ "April",
+ "May",
+ "June",
+ "July",
+ "August",
+ "September",
+ "October",
+ "November",
+ "December",
+}
+
+func charType(c uint8) int {
+ switch {
+ case '0' <= c && c <= '9':
+ return numeric
+ case 'a' <= c && c < 'z', 'A' <= c && c <= 'Z':
+ return alphabetic
+ }
+ return separator
+}
+
+func pieces(s string) []string {
+ p := make([]string, 20)
+ i := 0
+ // Each iteration generates one piece
+ for n := range p {
+ if i >= len(s) {
+ p = p[0:n]
+ break
+ }
+ start := i
+ c := s[i]
+ pieceType := charType(c)
+ for i < len(s) && charType(s[i]) == pieceType {
+ i++
+ }
+ p[n] = s[start:i]
+ }
+ return p
+}
+
+func zeroPad(i int) string {
+ s := strconv.Itoa(i)
+ if i < 10 {
+ s = "0" + s
+ }
+ return s
+}
+
+// Format returns a textual representation of the time value formatted
+// according to layout. The layout defines the format by showing the
+// representation of a standard time, which is then used to describe
+// the time to be formatted. Predefined layouts ANSIC, UnixDate,
+// ISO8601 and others describe standard representations.
+func (t *Time) Format(layout string) string {
+ pc := pieces(layout)
+ s := ""
+ for _, p := range pc {
+ switch p {
+ case stdYear:
+ p = strconv.Itoa64(t.Year % 100)
+ case stdLongYear:
+ p = strconv.Itoa64(t.Year)
+ case stdMonth:
+ p = shortMonthNames[t.Month]
+ case stdLongMonth:
+ p = longMonthNames[t.Month]
+ case stdNumMonth:
+ p = strconv.Itoa(t.Month)
+ case stdZeroMonth:
+ p = zeroPad(t.Month)
+ case stdWeekDay:
+ p = shortDayNames[t.Weekday]
+ case stdLongWeekDay:
+ p = longDayNames[t.Weekday]
+ case stdDay:
+ p = strconv.Itoa(t.Day)
+ case stdZeroDay:
+ p = zeroPad(t.Day)
+ case stdHour:
+ p = zeroPad(t.Hour)
+ case stdHour12:
+ p = strconv.Itoa(t.Hour % 12)
+ case stdZeroHour12:
+ p = zeroPad(t.Hour % 12)
+ case stdMinute:
+ p = strconv.Itoa(t.Minute)
+ case stdZeroMinute:
+ p = zeroPad(t.Minute)
+ case stdSecond:
+ p = strconv.Itoa(t.Second)
+ case stdZeroSecond:
+ p = zeroPad(t.Second)
+ case stdZulu:
+ p = zeroPad(t.Hour) + zeroPad(t.Minute)
+ case stdISO8601TZ:
+ // Rather ugly special case, required because the time zone is too broken down
+ // in this format to recognize easily. We cheat and take "Z" to mean "the time
+ // zone as formatted for ISO 8601".
+ if t.ZoneOffset == 0 {
+ p = "Z"
+ } else {
+ zone := t.ZoneOffset / 60 // minutes
+ if zone < 0 {
+ p = "-"
+ zone = -zone
+ } else {
+ p = "+"
+ }
+ p += zeroPad(zone / 60)
+ p += zeroPad(zone % 60)
+ }
+ case stdPM:
+ if t.Hour >= 12 {
+ p = "PM"
+ } else {
+ p = "AM"
+ }
+ case stdpm:
+ if t.Hour >= 12 {
+ p = "pm"
+ } else {
+ p = "am"
+ }
+ case stdTZ:
+ p = t.Zone
+ }
+ s += p
+ }
+ return s
+}
+
+// String returns a Unix-style representation of the time value.
+func (t *Time) String() string { return t.Format(UnixDate) }
sec -= int64(t.ZoneOffset)
return sec
}
-
-var longDayNames = []string{
- "Sunday",
- "Monday",
- "Tuesday",
- "Wednesday",
- "Thursday",
- "Friday",
- "Saturday",
-}
-
-var shortDayNames = []string{
- "Sun",
- "Mon",
- "Tue",
- "Wed",
- "Thu",
- "Fri",
- "Sat",
-}
-
-var shortMonthNames = []string{
- "---",
- "Jan",
- "Feb",
- "Mar",
- "Apr",
- "May",
- "Jun",
- "Jul",
- "Aug",
- "Sep",
- "Oct",
- "Nov",
- "Dec",
-}
-
-func copy(dst []byte, s string) {
- for i := 0; i < len(s); i++ {
- dst[i] = s[i]
- }
-}
-
-func decimal(dst []byte, n int) {
- if n < 0 {
- n = 0
- }
- for i := len(dst) - 1; i >= 0; i-- {
- dst[i] = byte(n%10 + '0')
- n /= 10
- }
-}
-
-func addString(buf []byte, bp int, s string) int {
- n := len(s)
- copy(buf[bp:bp+n], s)
- return bp + n
-}
-
-// Just enough of strftime to implement the date formats below.
-// Not exported.
-func format(t *Time, fmt string) string {
- buf := make([]byte, 128)
- bp := 0
-
- for i := 0; i < len(fmt); i++ {
- if fmt[i] == '%' {
- i++
- switch fmt[i] {
- case 'A': // %A full weekday name
- bp = addString(buf, bp, longDayNames[t.Weekday])
- case 'a': // %a abbreviated weekday name
- bp = addString(buf, bp, shortDayNames[t.Weekday])
- case 'b': // %b abbreviated month name
- bp = addString(buf, bp, shortMonthNames[t.Month])
- case 'd': // %d day of month (01-31)
- decimal(buf[bp:bp+2], t.Day)
- bp += 2
- case 'e': // %e day of month ( 1-31)
- if t.Day >= 10 {
- decimal(buf[bp:bp+2], t.Day)
- } else {
- buf[bp] = ' '
- buf[bp+1] = byte(t.Day + '0')
- }
- bp += 2
- case 'H': // %H hour 00-23
- decimal(buf[bp:bp+2], t.Hour)
- bp += 2
- case 'M': // %M minute 00-59
- decimal(buf[bp:bp+2], t.Minute)
- bp += 2
- case 'm': // %m month 01-12
- decimal(buf[bp:bp+2], t.Month)
- bp += 2
- case 'S': // %S second 00-59
- decimal(buf[bp:bp+2], t.Second)
- bp += 2
- case 'Y': // %Y year 2008
- decimal(buf[bp:bp+4], int(t.Year))
- bp += 4
- case 'y': // %y year 08
- decimal(buf[bp:bp+2], int(t.Year%100))
- bp += 2
- case 'z': // %z tz in the form -0500
- if t.ZoneOffset == 0 {
- bp = addString(buf, bp, "Z")
- } else if t.ZoneOffset < 0 {
- bp = addString(buf, bp, "-")
- decimal(buf[bp:bp+2], -t.ZoneOffset/3600)
- decimal(buf[bp+2:bp+4], (-t.ZoneOffset%3600)/60)
- bp += 4
- } else {
- bp = addString(buf, bp, "+")
- decimal(buf[bp:bp+2], t.ZoneOffset/3600)
- decimal(buf[bp+2:bp+4], (t.ZoneOffset%3600)/60)
- bp += 4
- }
- case 'Z':
- bp = addString(buf, bp, t.Zone)
- default:
- buf[bp] = '%'
- buf[bp+1] = fmt[i]
- bp += 2
- }
- } else {
- buf[bp] = fmt[i]
- bp++
- }
- }
- return string(buf[0:bp])
-}
-
-// Asctime formats the parsed time value in the style of
-// ANSI C asctime: Sun Nov 6 08:49:37 1994
-func (t *Time) Asctime() string { return format(t, "%a %b %e %H:%M:%S %Y") }
-
-// RFC850 formats the parsed time value in the style of
-// RFC 850: Sunday, 06-Nov-94 08:49:37 UTC
-func (t *Time) RFC850() string { return format(t, "%A, %d-%b-%y %H:%M:%S %Z") }
-
-// RFC1123 formats the parsed time value in the style of
-// RFC 1123: Sun, 06 Nov 1994 08:49:37 UTC
-func (t *Time) RFC1123() string { return format(t, "%a, %d %b %Y %H:%M:%S %Z") }
-
-// ISO8601 formats the parsed time value in the style of
-// ISO 8601: 1994-11-06T08:49:37Z
-func (t *Time) ISO8601() string { return format(t, "%Y-%m-%dT%H:%M:%S%z") }
-
-// String formats the parsed time value in the style of
-// date(1): Sun Nov 6 08:49:37 UTC 1994
-func (t *Time) String() string { return format(t, "%a %b %e %H:%M:%S %Z %Y") }
func TestISO8601Conversion(t *testing.T) {
for _, f := range iso8601Formats {
- if f.time.ISO8601() != f.formattedValue {
- t.Error("ISO8601():")
+ if f.time.Format(ISO8601) != f.formattedValue {
+ t.Error("ISO8601:")
t.Errorf(" want=%+v", f.formattedValue)
- t.Errorf(" have=%+v", f.time.ISO8601())
+ t.Errorf(" have=%+v", f.time.Format(ISO8601))
+ }
+ }
+}
+
+type FormatTest struct {
+ name string
+ format string
+ result string
+}
+
+var formatTests = []FormatTest{
+ FormatTest{"ANSIC", ANSIC, "Thu Feb 4 21:00:57 2010"},
+ FormatTest{"UnixDate", UnixDate, "Thu Feb 4 21:00:57 PST 2010"},
+ FormatTest{"RFC850", RFC850, "Thursday, 04-Feb-10 21:00:57 PST"},
+ FormatTest{"RFC1123", RFC1123, "Thu, 04 Feb 2010 21:00:57 PST"},
+ FormatTest{"ISO8601", ISO8601, "2010-02-04T21:00:57-0800"},
+ FormatTest{"Kitchen", Kitchen, "9:00PM"},
+ FormatTest{"am/pm", "3pm", "9pm"},
+ FormatTest{"AM/PM", "3PM", "9PM"},
+}
+
+func TestFormat(t *testing.T) {
+ // The numeric time represents Thu Feb 4 21:00:57 EST 2010
+ time := SecondsToLocalTime(1265346057)
+ for _, test := range formatTests {
+ result := time.Format(test.format)
+ if result != test.result {
+ t.Errorf("%s expected %q got %q", test.name, test.result, result)
}
}
}