func format(str, dbname string, tm time.Time) string {
buf := bytes.Buffer{}
var s scanner.Scanner
s.Init(strings.NewReader(str))
s.Mode = 0
s.Whitespace = 0
for tok := s.Scan(); tok != scanner.EOF; tok = s.Scan() {
if tok != '%' {
buf.WriteRune(tok)
continue
}
switch s := s.Scan(); s {
case '%':
buf.WriteRune('%')
case 'n':
buf.WriteString(dbname)
case 'Y', 'y':
buf.WriteString(strconv.Itoa(tm.Year()))
case 'm':
buf.WriteString(strconv.Itoa(int(tm.Month())))
case 'd':
buf.WriteString(strconv.Itoa(tm.Day()))
case 'H':
buf.WriteString(twodig(strconv.Itoa(tm.Hour())))
case 'M':
buf.WriteString(twodig(strconv.Itoa(tm.Minute())))
case 'S':
buf.WriteString(twodig(strconv.Itoa(tm.Second())))
}
}
return buf.String()
}
// FmtTimeMedium returns the medium time representation of 't' for 'ar_SA'
func (ar *ar_SA) FmtTimeMedium(t time.Time) string {
b := make([]byte, 0, 32)
h := t.Hour()
if h > 12 {
h -= 12
}
b = strconv.AppendInt(b, int64(h), 10)
b = append(b, ar.timeSeparator...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, ar.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20}...)
if t.Hour() < 12 {
b = append(b, ar.periodsAbbreviated[0]...)
} else {
b = append(b, ar.periodsAbbreviated[1]...)
}
return string(b)
}
// FmtTimeLong returns the long time representation of 't' for 'en_SC'
func (en *en_SC) FmtTimeLong(t time.Time) string {
b := make([]byte, 0, 32)
if t.Hour() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, en.timeSeparator...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, en.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20}...)
tz, _ := t.Zone()
b = append(b, tz...)
return string(b)
}
// FmtTimeLong returns the long time representation of 't' for 'sr_Cyrl_RS'
func (sr *sr_Cyrl_RS) FmtTimeLong(t time.Time) string {
b := make([]byte, 0, 32)
if t.Hour() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, []byte{0x2e}...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, []byte{0x2e}...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20}...)
tz, _ := t.Zone()
b = append(b, tz...)
return string(b)
}
// FmtTimeFull returns the full time representation of 't' for 'eo'
func (eo *eo) FmtTimeFull(t time.Time) string {
b := make([]byte, 0, 32)
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, []byte{0x2d, 0x61}...)
b = append(b, []byte{0x20, 0x68, 0x6f, 0x72, 0x6f}...)
b = append(b, []byte{0x20, 0x6b, 0x61, 0x6a}...)
b = append(b, []byte{0x20}...)
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, eo.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20}...)
tz, _ := t.Zone()
if btz, ok := eo.timezones[tz]; ok {
b = append(b, btz...)
} else {
b = append(b, tz...)
}
return string(b)
}
// dateSize returns the size needed to store a given time.Time.
func dateSize(v time.Time) (length uint8) {
var (
month, day, hour, min, sec uint8
year uint16
msec uint32
)
year = uint16(v.Year())
month = uint8(v.Month())
day = uint8(v.Day())
hour = uint8(v.Hour())
min = uint8(v.Minute())
sec = uint8(v.Second())
msec = uint32(v.Nanosecond() / 1000)
if hour == 0 && min == 0 && sec == 0 && msec == 0 {
if year == 0 && month == 0 && day == 0 {
return 0
} else {
length = 4
}
} else if msec == 0 {
length = 7
} else {
length = 11
}
length++ // 1 extra byte needed to store the length itself
return
}
// FmtTimeFull returns the full time representation of 't' for 'uz_Arab_AF'
func (uz *uz_Arab_AF) FmtTimeFull(t time.Time) string {
b := make([]byte, 0, 32)
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, uz.timeSeparator...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, uz.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20, 0x28}...)
tz, _ := t.Zone()
if btz, ok := uz.timezones[tz]; ok {
b = append(b, btz...)
} else {
b = append(b, tz...)
}
b = append(b, []byte{0x29}...)
return string(b)
}
func (de *DateEdit) timeToSystemTime(t time.Time) *win.SYSTEMTIME {
if t.Year() < 1601 {
if de.hasStyleBits(win.DTS_SHOWNONE) {
return nil
} else {
return &win.SYSTEMTIME{
WYear: uint16(1601),
WMonth: uint16(1),
WDay: uint16(1),
}
}
}
st := &win.SYSTEMTIME{
WYear: uint16(t.Year()),
WMonth: uint16(t.Month()),
WDay: uint16(t.Day()),
}
if de.timeOfDayDisplayed() {
st.WHour = uint16(t.Hour())
st.WMinute = uint16(t.Minute())
st.WSecond = uint16(t.Second())
}
return st
}
// FmtTimeFull returns the full time representation of 't' for 'th_TH'
func (th *th_TH) FmtTimeFull(t time.Time) string {
b := make([]byte, 0, 32)
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, []byte{0x20, 0xe0, 0xb8, 0x99, 0xe0, 0xb8, 0xb2, 0xe0, 0xb8, 0xac, 0xe0, 0xb8, 0xb4, 0xe0, 0xb8, 0x81, 0xe0, 0xb8, 0xb2, 0x20}...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, []byte{0x20, 0xe0, 0xb8, 0x99, 0xe0, 0xb8, 0xb2, 0xe0, 0xb8, 0x97, 0xe0, 0xb8, 0xb5, 0x20}...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20, 0xe0, 0xb8, 0xa7, 0xe0, 0xb8, 0xb4, 0xe0, 0xb8, 0x99, 0xe0, 0xb8, 0xb2, 0xe0, 0xb8, 0x97, 0xe0, 0xb8, 0xb5, 0x20}...)
tz, _ := t.Zone()
if btz, ok := th.timezones[tz]; ok {
b = append(b, btz...)
} else {
b = append(b, tz...)
}
return string(b)
}
func (c *Channel) ShouldSendNowGivenTime(currentTime time.Time) bool {
// We assume these are already sent
if c.TimeToNotify == "@immediately" {
return false
}
// the additional -1s is to make sure that the range always had 1 second.
// example: if you specify 01:00:00, the minute before and minute after will
// be 01:00:00 and 01:01:00. The next time computed will be an hour from now
// (in the hourly case). This means that there's a chance that this hour we
// never send anything. With an additional second it minimize this risk.
//
// Also, double sending is minimized as only 1 goroutine sends and we use a
// delivered flag in the db.
minuteBefore := currentTime.Add(time.Duration(-currentTime.Second()-1) * time.Second)
minuteAfter := minuteBefore.Add(time.Minute + time.Second)
expression := cronexpr.MustParse(c.TimeToNotify)
nextTime := expression.Next(minuteBefore)
if nextTime.IsZero() {
return false
}
// Operator overloading is so good.
// return (minuteBefore <= nextTime <= currentTime)
return (nextTime.After(minuteBefore) || nextTime.Equal(minuteBefore)) && (nextTime.Before(minuteAfter) || nextTime.Equal(minuteAfter))
}
//时间取整
func TruncDate(cyc string, now time.Time) time.Time { // {{{
//解析周期并取得距下一周期的时间
switch {
case cyc == "ss":
//按秒取整
return time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second(), 0, time.Local)
case cyc == "mi":
//按分钟取整
return time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), 0, 0, time.Local)
case cyc == "h":
//按小时取整
return time.Date(now.Year(), now.Month(), now.Day(), now.Hour(), 0, 0, 0, time.Local)
case cyc == "d":
//按日取整
return time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local)
case cyc == "m":
//按月取整
return time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, time.Local)
case cyc == "w":
//按周取整
return time.Date(now.Year(), now.Month(), now.Day()-int(now.Weekday()), 0, 0, 0, 0, time.Local)
case cyc == "q":
//回头再处理
case cyc == "y":
//按年取整
return time.Date(now.Year(), 1, 1, 0, 0, 0, 0, time.Local)
}
return time.Now()
} // }}}
// EndOf returns the end of the passed unit for the given time.
func EndOf(t time.Time, unit UnitOfTime) time.Time {
// Retrieve the individual parts of the given time.
year := t.Year()
month := t.Month()
day := t.Day()
hour := t.Hour()
minute := t.Minute()
second := t.Second()
loc := t.Location()
// Build new time.
switch unit {
case Second:
return time.Date(year, month, day, hour, minute, second, 999999999, loc)
case Minute:
return time.Date(year, month, day, hour, minute, 59, 999999999, loc)
case Hour:
return time.Date(year, month, day, hour, 59, 59, 999999999, loc)
case Day:
return time.Date(year, month, day, 23, 59, 59, 999999999, loc)
case Month:
// Catching leap years makes the month a bit more complex.
_, nextMonth, _ := t.AddDate(0, 1, 0).Date()
return time.Date(year, nextMonth, 1, 23, 59, 59, 999999999, loc).AddDate(0, 0, -1)
case Year:
return time.Date(year, time.December, 31, 23, 59, 59, 999999999, loc)
default:
return t
}
}
// BeginOf returns the begin of the passed unit for the given time.
func BeginOf(t time.Time, unit UnitOfTime) time.Time {
// Retrieve the individual parts of the given time.
year := t.Year()
month := t.Month()
day := t.Day()
hour := t.Hour()
minute := t.Minute()
second := t.Second()
loc := t.Location()
// Build new time.
switch unit {
case Second:
return time.Date(year, month, day, hour, minute, second, 0, loc)
case Minute:
return time.Date(year, month, day, hour, minute, 0, 0, loc)
case Hour:
return time.Date(year, month, day, hour, 0, 0, 0, loc)
case Day:
return time.Date(year, month, day, 0, 0, 0, 0, loc)
case Month:
return time.Date(year, month, 1, 0, 0, 0, 0, loc)
case Year:
return time.Date(year, time.January, 1, 0, 0, 0, 0, loc)
default:
return t
}
}
func (s *simClock) drawNeedle(t time.Time) {
s.Save()
defer s.Restore()
needle := func(angle float64, lineWidth float64, ratio float64, color string) {
s.BeginPath()
s.StrokeStyle = color
s.LineWidth = lineWidth
r := s.r * ratio
angle = angle - math.Pi/2
x := r * math.Cos(angle)
y := r * math.Sin(angle)
s.MoveTo(0, 0)
s.LineTo(x, y)
s.Stroke()
}
// houre
angleHour := float64(t.Hour()) / 6.0 * math.Pi
needle(angleHour, 5.0, s.hourNeedleRatio, "black")
// minute
angleMinute := float64(t.Minute()) / 30.0 * math.Pi
needle(angleMinute, 3.0, s.minuteNeedleRatio, "black")
// second
angleSecond := (float64(t.Second()) + float64(t.Nanosecond())/1000000000.0) / 30.0 * math.Pi
needle(angleSecond, 1.0, s.secondNeedleRatio, "red")
}
func Strftime(format string, t time.Time) (timestamp string, err error) {
c_format := C.CString(format)
defer func() { C.free(unsafe.Pointer(c_format)) }()
tz, offset := t.Zone()
c_tz := C.CString(tz)
defer func() { C.free(unsafe.Pointer(c_tz)) }()
c_time := C.struct_tm{
tm_year: C.int(t.Year() - 1900),
tm_mon: C.int(t.Month() - 1),
tm_mday: C.int(t.Day()),
tm_hour: C.int(t.Hour()),
tm_min: C.int(t.Minute()),
tm_sec: C.int(t.Second()),
tm_gmtoff: C.long(offset),
tm_zone: c_tz,
}
c_timestamp, trr := C.ftime(c_format, &c_time)
defer func() { C.free(unsafe.Pointer(c_timestamp)) }()
timestamp = C.GoString(c_timestamp)
if trr == nil {
timestamp = C.GoString(c_timestamp)
} else {
err = fmt.Errorf("%s - %s", trr, t)
}
return
}
func main() {
p := fmt.Println
var t time.Time = time.Now()
fmt.Println(t)
fmt.Println(t.Format(time.RFC3339))
fmt.Println(t.Format(time.RFC3339Nano))
t1, e := time.Parse(
time.RFC3339,
"2012-11-01T22:08:41-04:00")
p(t1)
p(t.Format("3:04PM"))
p(t.Format("Mon Jan _2 15:04:05 2006"))
p(t.Format("2006-01-02T15:04:05.999999-07:00"))
form := "3 04 PM"
t2, e := time.Parse(form, "8 41 PM")
p(t2)
fmt.Printf("%d - %02d - %02d T %02d : %02d : %02d . %d -00:00\n",
t.Year(), t.Month(), t.Day(),
t.Hour(), t.Minute(), t.Second(), t.Nanosecond())
ansic := "Mon Jan _2 15:04:05 2006"
_, e = time.Parse(ansic, "8:41PM")
p(e)
}
// FmtTimeLong returns the long time representation of 't' for 'uz_Latn_UZ'
func (uz *uz_Latn_UZ) FmtTimeLong(t time.Time) string {
b := make([]byte, 0, 32)
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, uz.timeSeparator...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, uz.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20, 0x28}...)
tz, _ := t.Zone()
b = append(b, tz...)
b = append(b, []byte{0x29}...)
return string(b)
}
func EasyDate(d time.Time) string {
twZone, err := time.LoadLocation("Asia/Taipei")
if err != nil {
log.Print(err.Error())
return ""
}
now := time.Now().In(twZone)
today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, twZone)
this_year := time.Date(now.Year(), time.January, 1, 0, 0, 0, 0, twZone)
yesterday := today.Add(-24 * time.Hour)
twoDaysBefore := yesterday.Add(-24 * time.Hour)
str := fmt.Sprintf("%02d:%02d:%02d", d.Hour(), d.Minute(), d.Second())
if d.After(yesterday) && d.Before(today) {
str = "昨天 " + str
} else if d.After(twoDaysBefore) && d.Before(yesterday) {
str = "前天 " + str
} else if d.After(this_year) && d.Before(twoDaysBefore) {
str = fmt.Sprintf("%d 月 %d 日 ", d.Month(), d.Day()) + str
} else if d.Before(this_year) {
str = fmt.Sprintf("%02d-%02d-%02d ", d.Year()-1911, d.Month(), d.Day()) + str
}
return str
}
// FmtTimeFull returns the full time representation of 't' for 'ja'
func (ja *ja) FmtTimeFull(t time.Time) string {
b := make([]byte, 0, 32)
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, []byte{0xe6, 0x99, 0x82}...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, []byte{0xe5, 0x88, 0x86}...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0xe7, 0xa7, 0x92, 0x20}...)
tz, _ := t.Zone()
if btz, ok := ja.timezones[tz]; ok {
b = append(b, btz...)
} else {
b = append(b, tz...)
}
return string(b)
}
func (f Format) TheHour(n int, t time.Time) (b []byte) {
b = make([]byte, 0, 64)
for _, f := range bytes.Fields(f) {
switch f[0] {
case '#':
b = append(b, Numbers[n]...)
case 'h':
b = append(b, []byte(`THE HOUR`)...)
case 'm':
m := t.Minute()
b = append(b, Numbers[m]...)
if len(f) == 2 && f[1] == '_' {
b = append(b, Sminute...)
if m != 1 {
b = append(b, 'S')
}
}
case 's':
s := t.Second()
b = append(b, Numbers[s]...)
if len(f) == 2 && f[1] == '_' {
b = append(b, Ssecond...)
if s != 1 {
b = append(b, 'S')
}
}
default:
b = append(b, f...)
}
b = append(b, ' ')
}
return b[:len(b)-1]
}
func buildTimeElement(t time.Time) string {
return fmt.Sprintf(
"<dateTime.iso8601>%d%d%dT%d:%d:%d</dateTime.iso8601>",
t.Year(), t.Month(), t.Day(),
t.Hour(), t.Minute(), t.Second(),
)
}
func (this *Rotator) switchFile(now time.Time) error {
if this.rotationByTime != NoRotation {
logFileName := this.baseFileName
logFileName += "." + now.Format(GetTimeFormat(this.rotationByTime))
// fmt.Println("next log-name will be", logFileName, ".")
switch this.rotationByTime {
default:
break
case MinutelyRotation:
this.nextRotationTime = now.Add(time.Minute).Add(-time.Duration(now.Second()) * time.Second).Unix()
case HourlyRotation:
this.nextRotationTime = now.Add(time.Hour).Add(-time.Duration(now.Second()+now.Minute()*60) * time.Second).Unix()
case DailyRotation:
this.nextRotationTime = now.Add(24 * time.Hour).Add(-time.Duration(now.Hour()*3600+now.Minute()*60+now.Second()) * time.Second).Unix()
}
// fmt.Println("next rotation time-point will be", this.nextRotationTime, " vs now ", now.Unix(), ".")
logFile, err := os.OpenFile(logFileName, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0666)
if err == nil {
this.currentFileName = logFileName
this.internalFile = logFile
this.createSymLink(logFileName)
// fmt.Println("file swapped.")
}
return err
}
return nil
}
func TestLock(t *testing.T) {
Open("memstore", "")
defer Close()
var l bool
var et time.Time
// Create a first lock
l, _ = Lock("test1", time.Minute, "owner1")
assert.True(t, l)
// Try to lock the same lock with another owner
l, _ = Lock("test1", time.Minute, "owner2")
assert.False(t, l)
// Renew the lock
l, _ = Lock("test1", time.Minute, "owner1")
assert.True(t, l)
// Unlock and then relock by someone else
Unlock("test1", "owner1")
l, et = Lock("test1", time.Minute, "owner2")
assert.True(t, l)
// LockInfo
o, et2, err := LockInfo("test1")
assert.Nil(t, err)
assert.Equal(t, "owner2", o)
assert.Equal(t, et.Second(), et2.Second())
// Create a second lock which is actually already expired ...
l, _ = Lock("test2", -time.Minute, "owner1")
assert.True(t, l)
// Take over the lock
l, _ = Lock("test2", time.Minute, "owner2")
assert.True(t, l)
}
func ParseTime(str string) (time.Time, error) {
now := time.Now()
t := time.Time{}
var err error
isShortTime := false
for _, tfmt := range inputTimeFormats {
t, err = time.ParseInLocation(tfmt, str, time.Local)
if err == nil {
if tfmt == "03:04 pm" || tfmt == "3:04 pm" || tfmt == "15:04" {
isShortTime = true
}
break
}
// fmt.Printf("%s \n", tfmt)
}
// if no year or month or day was given fill those in with todays date
if isShortTime {
t = time.Date(now.Year(), now.Month(), now.Day(), t.Hour(), t.Minute(), t.Second(), 0, time.Local)
} else if t.Year() == 0 { // no year was specified
t = time.Date(now.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), 0, time.Local)
}
return t, err
}
// FmtTimeMedium returns the medium time representation of 't' for 'be_BY'
func (be *be_BY) FmtTimeMedium(t time.Time) string {
b := make([]byte, 0, 32)
if t.Hour() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, []byte{0x2e}...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, []byte{0x2e}...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
return string(b)
}
// FmtTimeFull returns the full time representation of 't' for 'fr_BE'
func (fr *fr_BE) FmtTimeFull(t time.Time) string {
b := make([]byte, 0, 32)
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, []byte{0x20, 0x68}...)
b = append(b, []byte{0x20}...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, []byte{0x20, 0x6d, 0x69, 0x6e}...)
b = append(b, []byte{0x20}...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20, 0x73}...)
b = append(b, []byte{0x20}...)
tz, _ := t.Zone()
if btz, ok := fr.timezones[tz]; ok {
b = append(b, btz...)
} else {
b = append(b, tz...)
}
return string(b)
}
// FmtTimeMedium returns the medium time representation of 't' for 'en_SC'
func (en *en_SC) FmtTimeMedium(t time.Time) string {
b := make([]byte, 0, 32)
if t.Hour() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, en.timeSeparator...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, en.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
return string(b)
}
// FmtTimeMedium returns the medium time representation of 't' for 'zh_Hans_MO'
func (zh *zh_Hans_MO) FmtTimeMedium(t time.Time) string {
b := make([]byte, 0, 32)
if t.Hour() < 12 {
b = append(b, zh.periodsAbbreviated[0]...)
} else {
b = append(b, zh.periodsAbbreviated[1]...)
}
h := t.Hour()
if h > 12 {
h -= 12
}
b = strconv.AppendInt(b, int64(h), 10)
b = append(b, zh.timeSeparator...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, zh.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
return string(b)
}
// FmtTimeFull returns the full time representation of 't' for 'en_SC'
func (en *en_SC) FmtTimeFull(t time.Time) string {
b := make([]byte, 0, 32)
if t.Hour() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Hour()), 10)
b = append(b, en.timeSeparator...)
if t.Minute() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Minute()), 10)
b = append(b, en.timeSeparator...)
if t.Second() < 10 {
b = append(b, '0')
}
b = strconv.AppendInt(b, int64(t.Second()), 10)
b = append(b, []byte{0x20}...)
tz, _ := t.Zone()
if btz, ok := en.timezones[tz]; ok {
b = append(b, btz...)
} else {
b = append(b, tz...)
}
return string(b)
}
func newDrange(min, max time.Time, count int, hasTime bool) *drange {
// tijdzone strippen
min = time.Date(min.Year(), min.Month(), min.Day(), min.Hour(), min.Minute(), min.Second(), 0, time.UTC)
max = time.Date(max.Year(), max.Month(), max.Day(), max.Hour(), max.Minute(), max.Second(), 0, time.UTC)
/*
if count < 21 && !hasTime {
return oldDrange(min, max, size, dr_day, false)
}
*/
var r int
if max.Year()-min.Year() > 300 /* 300 jaar */ {
r = dr_cent
} else {
dur := max.Sub(min)
if hasTime && dur < time.Hour*24*4 /* 4 dagen */ {
r = dr_hour
} else if dur < time.Hour*24*50 /* 50 dagen */ {
r = dr_day
} else if dur < time.Hour*24*365*3 /* 3 jaar */ {
r = dr_month
} else if dur < time.Hour*24*365*30 /* 30 jaar */ {
r = dr_year
} else {
r = dr_dec
}
}
return oldDrange(min, max, r, true)
}